unixsite.cpp

linux下的一款播放器

   }
   

   XLockDisplay(dis);
   XSetForeground( dis, tmpGC, WhitePixel(dis, 0 ));
   XSetBackground( dis, tmpGC, BlackPixel(dis, 0 ));
   XUnlockDisplay(dis);
   Colormap cmap = HXGetXColormap((Display*)GetWindow()->display,
                                   (Window)GetWindow()->window);
   XColor color;
    
   memset(&color, 0, sizeof(XColor));
   XLockDisplay(dis);
   XParseColor(dis, cmap, "blue", &color);
   XUnlockDisplay(dis);
   HXFindBestXColor(dis, cmap, &color);
   XLockDisplay(dis);
   XSetForeground( dis, tmpGC, color.pixel);
   XSetLineAttributes(dis, tmpGC, 1, LineSolid, CapRound, JoinRound );
   XUnlockDisplay(dis);


   //Draw up Vertical arrow.
   if( m_ScrollVertButtonT )
   {
      points[0].x = offset;
      points[0].y = SCROLL_BAR_WIDTH-offset;
      points[1].x = SCROLL_BAR_WIDTH/2;
      points[1].y = offset;
      points[2].x = SCROLL_BAR_WIDTH-offset;
      points[2].y = SCROLL_BAR_WIDTH-offset;
      points[3].x = points[0].x;
      points[3].y = points[0].y;
      XLockDisplay(dis);
      XFillPolygon( dis, m_ScrollVertButtonT, tmpGC, points, 4, Convex, CoordModeOrigin);
      XUnlockDisplay(dis);
   }
    
   //Draw down Vertical arrow.
   if( m_ScrollVertButtonB )
   {
      points[0].x = offset;
      points[0].y = offset;
      points[1].x = SCROLL_BAR_WIDTH-offset;
      points[1].y = offset;
      points[2].x = SCROLL_BAR_WIDTH/2;
      points[2].y = SCROLL_BAR_WIDTH-offset;
      points[3].x = points[0].x;
      points[3].y = points[0].y;
      XLockDisplay(dis);
      XFillPolygon( dis, m_ScrollVertButtonB, tmpGC, points, 4, Convex, CoordModeOrigin);
      XUnlockDisplay(dis);
   }
    
   //Draw Left Horizontal arrow.
   if( m_ScrollHorizButtonL )
   {
      points[0].x = SCROLL_BAR_WIDTH-offset;
      points[0].y = offset;
      points[1].x = SCROLL_BAR_WIDTH-offset;
      points[1].y = SCROLL_BAR_WIDTH-offset;
      points[2].x = offset;
      points[2].y = SCROLL_BAR_WIDTH/2;
      points[3].x = points[0].x;
      points[3].y = points[0].y;
      XLockDisplay(dis);
      XFillPolygon( dis, m_ScrollHorizButtonL, tmpGC, points, 4, Convex, CoordModeOrigin);
      XUnlockDisplay(dis);
   }
    
   //Draw Right Horizontal arrow.
   if( m_ScrollHorizButtonR )
   {
      points[0].x = offset;
      points[0].y = SCROLL_BAR_WIDTH-offset;
      points[1].x = offset;
      points[1].y = offset;
      points[2].x = SCROLL_BAR_WIDTH-offset;
      points[2].y = SCROLL_BAR_WIDTH/2;
      points[3].x = points[0].x;
      points[3].y = points[0].y;
      XLockDisplay(dis);
      XFillPolygon( dis, m_ScrollHorizButtonR, tmpGC, points, 4, Convex, CoordModeOrigin);
      XUnlockDisplay(dis);
   }
    
   //Free the GC and go.
   XLockDisplay(dis);
   XFreeGC( dis, tmpGC );
   XUnlockDisplay(dis);
}

BOOL CHXUnixSite::_InButton( HXxPoint& pt, int x, int y )
{
   BOOL retVal =FALSE;
   if( x>= pt.x && x< pt.x+SCROLL_BAR_WIDTH && y>=pt.y && y<pt.y+SCROLL_BAR_WIDTH )
      retVal=TRUE;
   else
      retVal=FALSE;

   return retVal;
}

void CHXUnixSite::_CreateHorizScrollBar()
{
   HX_ASSERT( m_ScrollHorizButtonL == 0 );
   HX_ASSERT( m_ScrollHorizButtonR == 0 );
    
   HXxSize  mySize;

   HXxWindow* pParentWindow = NULL;
   if(GetParentSite())
   {
      pParentWindow = GetParentSite()->GetWindow();
   }
   if(pParentWindow)
   {
      GetParentSite()->GetSize(mySize);
   }

   HX_ASSERT( pParentWindow );
   HX_ASSERT( pParentWindow->window != 0 );
    
   if( m_ScrollVertButtonB )
   {
      // if the other bar already exists, don't overlap it!
      mySize.cx -= SCROLL_BAR_WIDTH;
   }

   m_ptScrollHorizPosL.x = m_topleft.x;
   m_ptScrollHorizPosL.y = m_topleft.y+mySize.cy-SCROLL_BAR_WIDTH;

#ifndef _ARROWS_SIDE_BY_SIDE    
   m_ptScrollHorizPosR.x = m_topleft.x+mySize.cx-SCROLL_BAR_WIDTH;
#else    
   m_ptScrollHorizPosR.x = m_topleft.x+SCROLL_BAR_WIDTH;
#endif
   m_ptScrollHorizPosR.y = m_topleft.y+mySize.cy-SCROLL_BAR_WIDTH;

   Display* dis     = (Display*)GetWindow()->display;
   XLockDisplay(dis);
   Pixel blackPixel = BlackPixel( dis, DefaultScreen(dis) );
   XUnlockDisplay(dis);
   Pixel greyPixel  = blackPixel;

   Colormap cmap = HXGetXColormap(dis, (Window)GetWindow()->window);
   XColor color;
    
   XLockDisplay(dis);
   XParseColor(dis, cmap, "gray", &color);
   XUnlockDisplay(dis);
   HXFindBestXColor(dis, cmap, &color);
   greyPixel = color.pixel;

   XLockDisplay(dis);
   m_ScrollHorizButtonL = XCreateSimpleWindow( dis,
                                               (Window)pParentWindow->window,
                                               m_ptScrollHorizPosL.x, m_ptScrollHorizPosL.y,
                                               SCROLL_BAR_WIDTH, SCROLL_BAR_WIDTH,
                                               1,
                                               blackPixel,
                                               greyPixel
                                               );
   m_ScrollHorizButtonR = XCreateSimpleWindow( dis,
                                               (Window)pParentWindow->window,
                                               m_ptScrollHorizPosR.x, m_ptScrollHorizPosR.y,
                                               SCROLL_BAR_WIDTH, SCROLL_BAR_WIDTH,
                                               1,
                                               blackPixel,
                                               greyPixel
                                               );
   XUnlockDisplay(dis);
   HX_ASSERT( m_ScrollHorizButtonR && m_ScrollHorizButtonL );
    
}

void CHXUnixSite::_CreateVertScrollBar()
{
   HX_ASSERT( m_ScrollVertButtonB == 0 );
   HX_ASSERT( m_ScrollVertButtonT == 0 );
    
   HXxSize  mySize;

   HXxWindow* pParentWindow = NULL;
   if(GetParentSite())
   {
      pParentWindow = GetParentSite()->GetWindow();
   }
   if(pParentWindow)
   {
      GetParentSite()->GetSize(mySize);
   }

   HX_ASSERT( pParentWindow );
   HX_ASSERT( pParentWindow->window != 0 );
    
   if( m_ScrollHorizButtonR )
   {
      // if the other bar already exists, don't overlap it!
      mySize.cy -= SCROLL_BAR_WIDTH;
   }
    
    
   m_ptScrollVertPosT.x = m_topleft.x+mySize.cx-SCROLL_BAR_WIDTH;
   m_ptScrollVertPosT.y = m_topleft.y;

   m_ptScrollVertPosB.x = m_topleft.x+mySize.cx-SCROLL_BAR_WIDTH;
#ifndef _ARROWS_SIDE_BY_SIDE    
   m_ptScrollVertPosB.y = m_topleft.y+mySize.cy-SCROLL_BAR_WIDTH;
#else
   m_ptScrollVertPosB.y = m_topleft.y+SCROLL_BAR_WIDTH;
#endif    

   Display* dis     = (Display*)GetWindow()->display;
   XLockDisplay(dis);
   Pixel blackPixel = BlackPixel( dis, DefaultScreen(dis) );
   XUnlockDisplay(dis);
   Pixel greyPixel  = blackPixel;
   Colormap cmap = HXGetXColormap((Display*)GetWindow()->display,
                                   (Window)GetWindow()->window);
   XColor color;
   XLockDisplay(dis);
   XParseColor(dis, cmap, "gray", &color);
   XUnlockDisplay(dis);
   HXFindBestXColor(dis, cmap, &color);
   greyPixel = color.pixel;
    
   HX_ASSERT( GetWindow() );
   XLockDisplay(dis);
   m_ScrollVertButtonT = XCreateSimpleWindow( dis,
                                              (Window)pParentWindow->window,
                                              m_ptScrollVertPosT.x, m_ptScrollVertPosT.y,
                                              SCROLL_BAR_WIDTH, SCROLL_BAR_WIDTH,
                                              1,
                                              blackPixel,
                                              greyPixel
                                              );
   m_ScrollVertButtonB = XCreateSimpleWindow( dis,
                                              (Window)pParentWindow->window,
                                              m_ptScrollVertPosB.x, m_ptScrollVertPosB.y,
                                              SCROLL_BAR_WIDTH, SCROLL_BAR_WIDTH,
                                              1,
                                              blackPixel,
                                              greyPixel
                                              );
   XUnlockDisplay(dis);

   HX_ASSERT( m_ScrollVertButtonB && m_ScrollVertButtonT );

}

//
// Inherited CHXBaseSite methods.
//
void CHXUnixSite::_NeedWindowedSite()
{
#ifdef _DEBUG   
   fprintf( stderr, "CHXUnixSite::_NeedWindowedSite do something here....\n" );
#endif   
   //Nothing to do on unix....
}

void CHXUnixSite::_AttachWindow()
{
   void* pDummy=NULL; 
   if(!z_mapSiteToWindow.Lookup((void*)this, pDummy))
   {
      z_mapSiteToWindow.SetAt((void*)this, (void*)m_pWindow);
   }

   //Set the display variable.
   if( m_pWindow->display == NULL )
   {
      HX_ASSERT(zm_display);
      m_pWindow->display = zm_display;
   }
   
   //Now that we have a window be sure to init the CUnixRootSurf.
   //this lets it set up the display, colormap, etc.
   ((CUnixRootSurf*)m_pRootSurface)->Init();
}

void CHXUnixSite::_DetachWindow()
{
   void* pDummy; 

   if (z_mapSiteToWindow.Lookup((void*)this, pDummy))
   {
      z_mapSiteToWindow.RemoveKey((void*)this);
   }
}

void* CHXUnixSite::_Create(void* pParentWindow, UINT32 style)
{
   HRESULT result = HXR_OK;
   if( m_pWindow && m_pWindow->window )
   {
      HX_ASSERT( "We already have created a window"==NULL);
      return NULL;
   }

   if (pParentWindow==NULL || style)
   {
      m_bIsChildWindow = FALSE;
   }
   else
   {
      m_bIsChildWindow = TRUE;
   }

   if( _OpenXDisplay(NULL) != HXR_OK )
   {
      return NULL;
   }
   return (void*)CreateXWindow((Window)pParentWindow);
}


void CHXUnixSite::_Destroy(HXxWindow* pWindow)
{
    _DestroySliders();
    if (GetWindow())
    {
	Display* pDis = (Display*)GetWindow()->display;
	XLockDisplay(pDis);
	XDestroyWindow( pDis, (Window)pWindow->window );
	XUnlockDisplay(pDis);
    }
}

void CHXUnixSite::_SetSize(HXxSize size)
{
   HX_ASSERT( m_pWindow && m_pWindow->display && m_pWindow->window);
   //The scroll bars get resized also...
   _DestroySliders();
   Display* pDis = (Display*)GetWindow()->display;
   XLockDisplay(pDis);
   XResizeWindow(pDis,
                 (Window) m_pWindow->window,
                 size.cx,
                 size.cy);
   XUnlockDisplay(pDis);
}

void CHXUnixSite::_SetPosition(HXxPoint position)
{
   HX_ASSERT( m_pWindow && m_pWindow->display && m_pWindow->window);
   _DestroyScrollButtons();
   XLockDisplay((Display*) m_pWindow->display);
   XMoveWindow((Display*)m_pWindow->display,
               (Window)m_pWindow->window,
               position.x,
               position.y);
   XUnlockDisplay((Display*) m_pWindow->display);
}

void CHXUnixSite::_DamageRect(HXxRect rect)
{
   if(GetWindow())
   {    
      m_bDamaged = TRUE;
   }
   return;
}

void CHXUnixSite::_DamageRegion(HXxRegion rect)
{
   if(GetWindow())
   {    
      m_bDamaged = TRUE;
   }
   return;
}

void CHXUnixSite::_SendOSUpdateMessage()
{
   //We need to redraw our window here, m_pWindow.
}

void CHXUnixSite::_ShowSite(BOOL bShow)
{
   if( bShow )
   {
      _MapScrollButtons();
   }
   else
   {
      _UnmapScrollButtons();
   }
   //do nothing....
}

BOOL CHXUnixSite::_AtSystemTime()
{
   return TRUE;
}

void CHXUnixSite::_GetDeviceCaps( void* hdc,
                                  UINT16& uBitsPerPixel,
                                  UINT16& uHorzRes,
                                  UINT16& uVertRes )
{
   Screen* pScreen = NULL;
   HXxWindow* pWin = GetWindow();
   HX_ASSERT( pWin );
   if( pWin )
   {
       Display* dis = (Display*)pWin->display;
       HX_ASSERT( dis );
       if( dis )
       {
	   Display* pDisp = (Display*)GetWindow()->display;
	   XLockDisplay(pDisp);
           pScreen = DefaultScreenOfDisplay(pDisp);    
	   XUnlockDisplay(pDisp);
           
           uBitsPerPixel = pScreen->root_depth;
           uHorzRes      = pScreen->width;
           uVertRes      = pScreen->height;   
       }
   }
}

void CHXUnixSite::_GetWindowRect(HXxRect* destRect)
{
   HX_ASSERT( "Doesn't seem to be used anywhere"==NULL );
}

void CHXUnixSite::_DestroySliders()
{
   _DestroyScrollButtons();
}

void CHXUnixSite::_ForwardUpdateEvent(HXxEvent* pEvent)
{
   GC gc = NULL;
   AddRef();

   HX_ASSERT(GetWindow()->window);
   HX_ASSERT(m_pUser);
   if(m_bIsChildWindow)
   {
      //Create a clip region that excludes our higher z-order
      //siblings and is clipped to our parent.