unixsite.cpp

来自「symbian 下的helix player源代码」· C++ 代码 · 共 2,150 行 · 第 1/5 页

           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.
      if( !m_bRegionIsValid )
      {
         RecomputeClip();
      }

      // The problem is that regions are locked to the origin so we
      // will need to reverse shift the region before we set the
      // origin of the graph port! get the GC from the video surface
      gc = ((CUnixRootSurf*)m_pRootSurface)->GetGC();
      HX_ASSERT( gc );
        
      //Actually setup our clip region
      Display* pDis = (Display*)GetWindow()->display;
      XLockDisplay(pDis);
      XSetRegion( pDis, gc, (Region) m_Region );
      XUnlockDisplay(pDis);
   }

   XEvent* pXEvent = (XEvent*) pEvent->param2; 
   XExposeEvent* exposeEvent = (XExposeEvent*) pXEvent;
   
   // get the rect for this site with respect to our parent
   HXRECTANGLE exposedRect = { exposeEvent->x,
                             exposeEvent->y,
                             exposeEvent->width,
                             exposeEvent->height };
   HXREGION* exposedRegion = HXCreateRegion();
   HXUnionRectWithRegion(&exposedRect, exposedRegion,  exposedRegion);
   
   // does the site intersect the current clipping region?
   HXREGION* resultRegion = HXCreateRegion();
   HXIntersectRegion(exposedRegion, m_Region, resultRegion);
   BOOL bSiteIntersectsExposed = (HXEmptyRegion(resultRegion)==FALSE);
   
   HXDestroyRegion(resultRegion);
   HXDestroyRegion(exposedRegion);
   
   // if the exposed region intersects the sites clipping region
   if(bSiteIntersectsExposed)
   {
      m_pUser->HandleEvent(pEvent);
   }
   
   //If the user doesn't handle the standard update event then send
   //them the cross platform HX_SURFACE_UPDATE event don't damage the
   //original event structure
   if(!pEvent->handled && m_pUser )
   {
      HX_ASSERT(GetWindow());
      HXxEvent event;
      event.event   = HX_SURFACE_UPDATE;
      event.window  = GetWindow()->window;
      event.param1  = m_pVideoSurface;
      event.param2  = GetWindow();
      event.result  = 0;
      event.handled = FALSE;
      m_pUser->HandleEvent(&event);
      pEvent->handled = event.handled;
   }
   

   //reset the gc to use no region
   if(m_bIsChildWindow && gc)
   {
      Display* pDisp = (Display*)GetWindow()->display;
      XLockDisplay(pDisp);
      XSetClipMask(pDisp, gc, None);
      XUnlockDisplay(pDisp);
   }

   //Handle the drawing of our arrows...
   _DrawArrows();

   //Now do all our children.... 
   CHXMapPtrToPtr::Iterator i = m_ChildrenMap.Begin();
   for(;i!=m_ChildrenMap.End();++i)
   {
      CHXUnixSite* pSite = (CHXUnixSite*) *i;
      pSite->_ForwardUpdateEvent(pEvent);
   }
   
   Release();
}

UINT32 CHXUnixSite::_MapKeySymToHXVK(KeySym sym, UINT32& uFlags )
{
   //XXXgfw if we add the extended flag in the HX_KEYBOARD event
   //structure then we can modify the flags here to show that these
   //keys are 'extended' in the windows sense.
   UINT32 ulRet = 0;
   switch( sym )
   {
      case XK_Shift_R:
         ulRet = XK_Shift_L;
         break;
      case XK_Alt_R:
         ulRet = XK_Alt_L;
         break;
      case XK_KP_Home:
         ulRet = XK_Home;
         break;
      case XK_KP_Next:
         ulRet = XK_Next;
         break;
      case XK_KP_Prior:
         ulRet = XK_Prior;
         break;
      case XK_KP_Enter:
         ulRet = XK_Return;
         break;
      case XK_KP_End:
         ulRet = XK_End;
         break;
      case XK_KP_Begin:
         ulRet = XK_Begin;
         break;
      case XK_KP_Left:
         ulRet = XK_Left;
         break;
      case XK_KP_Up:
         ulRet = XK_Up;
         break;
      case XK_Control_R:
         ulRet = XK_Control_L;
         break;
      case XK_KP_Right:
         ulRet = XK_Right;
         break;
      case XK_KP_Down:
         ulRet = XK_Down;
         break;
      case XK_KP_Insert:
         ulRet = XK_Insert;
         break;
      case XK_KP_Delete:
         ulRet = XK_Delete;
         break;
      default:
         ulRet = sym;
         break;
   }
   if( ulRet != sym )
   {
      //We have mapped a key from Right hand side, keypad, arrows
      //or other parts of an extended keyboard. Set the flag.
      uFlags |= HX_EXTENDED_KEY_MASK;
   }
   return ulRet;
}


BOOL CHXUnixSite::_ConvertToHXEvent(HXxEvent* pEvent )
{
   // get original events info from pEvent
   XEvent* pXEvent = (XEvent*) pEvent->param2;
   XButtonEvent* buttonEvent = (XButtonEvent*) pXEvent;

   
   //===============================================================
   //   Convert all other event to RMA generic events and pass back.
   //===============================================================
   if( ((pEvent->event == ButtonPress)   ||
        (pEvent->event == ButtonRelease) ||
        (pEvent->event == MotionNotify ) ||
        (pEvent->event == EnterNotify)   ||
        (pEvent->event == FocusIn)       ||
        (pEvent->event == FocusOut)      ||
        (pEvent->event == KeyPress)      ||
        (pEvent->event == KeyRelease)    ||
        (pEvent->event == LeaveNotify))
       )
   {
      // set modifier flags for all events....
      UINT32 flags = 0;

      // create new HXxEvent
      HXxEvent theEvent;

      //XXXgfw ouch....
      static HXxPoint realPt = {0,0};

      //Init certain members. 
      memset(&theEvent, 0, sizeof(HXxEvent));
      theEvent.window  = pEvent->window;
      theEvent.handled = FALSE;

      //
      // NOTE:
      //
      // theEvent must be filled in by *ALL* event types.
      // theEvent will be memcopied into the pEvent passed
      // back to the basesite at the end of the method.
      // 

      //==================================================
      // LEAVE NOTIFY EVENT
      //==================================================            
      if( pEvent->event==LeaveNotify)
      {
         if( m_pTopLevelSite->m_pMouseInSite )
         {
            HXxPoint oobPoint;
            oobPoint.x = -1;
            oobPoint.y = -1;
            HXxEvent Outevent = { HX_MOUSE_LEAVE,
                                  m_pWindow->window,
                                  (void*)&oobPoint,
                                  0, 0,
                                  FALSE };
            m_pTopLevelSite->m_pMouseInSite->EventOccurred(&Outevent);
            m_pTopLevelSite->m_pMouseInSite = NULL;
         }
         pEvent->handled=TRUE;
         return TRUE;
      }

      //==================================================
      // ENTER NOTIFY EVENT
      //==================================================
      if( pEvent->event==EnterNotify)
      {
         pEvent->handled=TRUE;
         return TRUE;
      }

      //==================================================
      // KEY PRESS/RELEASE EVENT
      //==================================================
      if ( pEvent->event == KeyPress || pEvent->event==KeyRelease )
      {
         XKeyEvent* pKeyEvent = (XKeyEvent*)pEvent->param2;

         //
         //Set the event type
         //
         theEvent.event = pEvent->event==KeyPress?HX_KEY_DOWN:HX_KEY_UP;

         //
         // Fill in the scan/key code.
         //
         flags =  pKeyEvent->keycode;
         flags &= 0x000000ff; //the scan code only gets bits 0-7
               
         //
         // build key modifier list...
         //
         if( pKeyEvent->state & ShiftMask )
            flags |= HX_SHIFT_MASK;
               
         if( pKeyEvent->state & ControlMask )
            flags |= HX_CTRL_MASK;
               
         if( pKeyEvent->state & LockMask )
            flags |= HX_CAPS_LOCK_MASK;

         if( pKeyEvent->state & Mod1Mask)
            flags |= HX_ALT_MASK;
                  
         if( pKeyEvent->state & Mod2Mask)
            flags |= HX_NUM_LOCK_MASK;
                  
         if( pKeyEvent->state & Mod5Mask)
            flags |= HX_SCROLL_LOCK_MASK;

         //
         //Store the char pressed.
         //
         KeySym sym;
         char   szBuf[10]; /* Flawfinder: ignore */
         int    nNum;
                  
         //Save the state of the keys...
         unsigned int unSave = pKeyEvent->state;
         pKeyEvent->state=0;

         //Lookup the key without any state.
         nNum = XLookupString( pKeyEvent, szBuf, 10, &sym, NULL );
         if( nNum > 0 )
         {
            theEvent.param1 = (void*)*szBuf;
         }
         else
         {
            theEvent.param1 = (void*)_MapKeySymToHXVK(sym, flags);
            flags |= HX_VIRTUAL_KEY_MASK;
         }
         //restore the state of the event
         pKeyEvent->state = unSave;
               
         //Set the flags...
         theEvent.param2 = (void*)flags;

         //Check for HX_CHAR needed or not.
         if( theEvent.event == HX_KEY_DOWN )
         {
            //We have to send an extra HX_CHAR event
            HXxEvent extraEvent;
            memcpy( &extraEvent, &theEvent, sizeof( extraEvent ) ); /* Flawfinder: ignore */

            //Change the type.
            extraEvent.event = HX_CHAR;
                  
            //
            //Change the keycode to an translated ascii char.
            //
            KeySym sym;
            char   szBuf[10]; /* Flawfinder: ignore */
            int    nNum;
                  
            nNum = XLookupString( pKeyEvent, szBuf, 10, &sym, NULL );
                  
            if( nNum > 0 )
            {
               extraEvent.param1 = (void*)*szBuf;
            }
            else
            {
               extraEvent.param1 = (void*)_MapKeySymToHXVK(sym, flags);
               flags |= HX_VIRTUAL_KEY_MASK;
            }
            extraEvent.param2 = (void*)flags;

            //
            // Now send the extra event....
            //
            CHXBaseSite::EventOccurred(&extraEvent);
         }
      }
            
      //==================================================
      // FOCUS OUT EVENT
      //==================================================            
      if ( pEvent->event == FocusOut )
      {
         theEvent.event = HX_LOSE_FOCUS;
      }

      if ( pEvent->event == FocusIn )
      {
         theEvent.event = HX_SET_FOCUS;
      }

      //==================================================
      // MOUSE MOVE EVENT
      //==================================================            
      if( pEvent->event == MotionNotify )
      {
         XMotionEvent* pp = (XMotionEvent*)pEvent->param2;
         theEvent.event = HX_MOUSE_MOVE; 
               
         if( pp->state&Button1Mask )
            flags |= HX_PRIMARY_BUTTON;
               
         if( pp->state&Button2Mask )
            flags |= HX_CONTEXT_BUTTON;
               
         if( pp->state&Button3Mask )
            flags |= HX_THIRD_BUTTON;
               
         if(pp->state & ShiftMask)
            flags |= HX_SHIFT_KEY;
               
         if(pp->state & ControlMask)
            flags |= HX_CTRL_KEY;
               
         if(pp->state & Mod1Mask)
            flags |= HX_ALT_COMMAND_KEY;
               
         theEvent.param2 = (void*) flags;
               
         //Grab the X and Y.
         theEvent.param1 = (void*) &realPt;
         realPt.x = pp->x;
         realPt.y = pp->y;
      }
            
      //==================================================
      // BUTTON PRESS/RELEASE EVENT
      //==================================================            
      if((pEvent->event == ButtonPress) || (pEvent->event == ButtonRelease))
      {
         // remap event
         if (pEvent->event == ButtonPress)
         {
            if (buttonEvent->button == Button3)
               theEvent.event = HX_CONTEXT_BUTTON_DOWN;
            else
               theEvent.event = HX_PRIMARY_BUTTON_DOWN;
         }
         else if (pEvent->event == ButtonRelease)
         {
            if (buttonEvent->button == Button3)
               theEvent.event = HX_CONTEXT_BUTTON_UP;
            else
               theEvent.event = HX_PRIMARY_BUTTON_UP;
         }
            
         if(buttonEvent->state & ShiftMask)
            flags |= HX_SHIFT_KEY;
               
         if(buttonEvent->state & ControlMask)
            flags |= HX_CTRL_KEY;