macsite.cpp

linux下的一款播放器

	    ControlHandle theControl = NULL;
	    
	    HXxWindow* pWindow = GetWindow();
	    
	    if (pWindow && pWindow->window)
	    {
		w = (WindowPtr)pWindow->window;
	    }
	    
	    HX_ASSERT(w);
	    
	    if (!w) return HXR_FAIL;

	    GrafPtr savePort;
	    ::GetPort(&savePort);
	    ::SetPort(::GetWindowPort(w));
	    
	    Point oldOrigin;
	    Rect portRect;
	    ::GetPortBounds(::GetWindowPort(w), &portRect);
	    oldOrigin.h = portRect.left;
	    oldOrigin.v = portRect.top;
	    
	    SetOriginAndMaintainClipRgn(0,0); // origin must be at 0,0 for scroll bar maintenence
	    
	    Point localPt = macEvent->where;
	    ::GlobalToLocal(&localPt);
	    
	    short thePart = 0;
	    theControl = ::FindControlUnderMouse(localPt, w, &thePart);
	    
	    if (theControl && ((theControl == m_hHScrollBar) || (theControl == m_hVScrollBar)))
	    {
		short trackedPart = ::TrackControl(theControl, localPt, m_ScrollBarActionProc);
                // xxxbobclark Carbon Porting Notes: TrackControl is deprecated, use HandleControlClick.
		
		long pageSize;
		
		if (theControl == m_hHScrollBar)
		{
		    pageSize = m_nHorizPageSize;
		}
		else
		{
		    pageSize = m_nVertPageSize;
		}
		
		switch (trackedPart)
		{
		    case kControlUpButtonPart:
			::SetControl32BitValue(theControl, ::GetControl32BitValue(theControl)-1);
			break;
		    case kControlDownButtonPart:
			::SetControl32BitValue(theControl, ::GetControl32BitValue(theControl)+1);
			break;
		    case kControlPageUpPart:
			::SetControl32BitValue(theControl, ::GetControl32BitValue(theControl)-pageSize);
			break;
		    case kControlPageDownPart:
			::SetControl32BitValue(theControl, ::GetControl32BitValue(theControl)+pageSize);
			break;
		}
		
		if (theControl == m_hHScrollBar)
		{
		    m_XSliderPos = ::GetControl32BitValue(theControl);
		}
		if (theControl == m_hVScrollBar)
		{
		    m_YSliderPos = ::GetControl32BitValue(theControl);
		}
		
		HXxPoint ptSiteOrigin;
		GetMacContentAreaOffset(ptSiteOrigin);
		Rect invalRect;
		invalRect.left = ptSiteOrigin.x;
		invalRect.top = ptSiteOrigin.y;
		
		if (m_hHScrollBar)
		{
		    Rect controlRect;
		    ::GetControlBounds(m_hHScrollBar, &controlRect);
		    invalRect.right = controlRect.right;
		    invalRect.bottom = controlRect.top;
		}
		if (m_hVScrollBar)
		{
		    Rect controlRect;
		    ::GetControlBounds(m_hVScrollBar, &controlRect);
		    invalRect.right = controlRect.left;
		    invalRect.bottom = controlRect.bottom;
		}
		
		::InvalWindowRect(w, &invalRect);
		handled = TRUE;
	    }
	    
	    if (!handled)
	    {
		HXxWindow* pWindow = GetWindow();
		if (pWindow && pWindow->window)
		{
		    // see if it's in this site

		    SetOriginAndMaintainClipRgn(-pWindow->x, -pWindow->y);
		    Point p = macEvent->where;
		    ::GlobalToLocal(&p);
		    HXxPoint loc;
		    loc.x = p.h;
		    loc.y = p.v;
		    
		    HX_ASSERT(m_RegionForMouse);
		    if (IsPointInClippingRegion(&loc))
		    {
			HXxPoint offset = {0,0};
			GetMacContentAreaOffset(offset);

//			UDrawingUtils::SetOriginAndMaintainClipRgn(-offset.x, -offset.y);


                        if (m_pUser)
                        {
//                            m_pUser->HandleEvent(pEvent);
//                            handled = pEvent->handled;
                        }
		    }
		    
		    SetOriginAndMaintainClipRgn(oldOrigin.h, oldOrigin.v);
		    
		    ::SetPort(savePort);
		}
		
	    }
	}
    }
    return handled;
}

/************************************************************************
 *  Method:
 *    CHXMacSite::_HandleAllOSEvents
 */
/* static */
void CHXMacSite::_HandleAllOSEvents(HXxEvent* pEvent)
{
    EventRecord* macEvent = (EventRecord*) pEvent->param1;
    
    CHXSimpleList::Iterator ndx = zm_ListOfMacSites.Begin();
    for ( ; ndx != zm_ListOfMacSites.End(); ++ndx)
    {
	CHXMacSite* pMacSite = (CHXMacSite*)(*ndx);
	
	HX_ASSERT( pMacSite );
	
	pMacSite->_HandleOSEvents(pEvent);
    }
    
/*
    if (gRecentUpdateEvent)
    {
	EventRecord* macEvent = (EventRecord*)pEvent->param1;
	if (macEvent->what == updateEvt)
	{
	    // XXXbobclark
	    // clearly we're handling the recent update event and since we've
	    // just done it let's clear that puppy out.
	    gRecentUpdateEvent = false;
	}
    }
*/
}


/************************************************************************
 *  Method:
 *    CHXMacSite::_ConvertRegionToMacRegion
 *	utility function to convert between the RealNetworks
 *	regions that the site classes use and Mac-specific
 *	RgnHandle's.
 */
/* static */
RgnHandle
CHXMacSite::_ConvertRegionToMacRegion( HXREGION* pRegion )
{
    HX_ASSERT(IsMacInCooperativeThread());
    if ( !IsMacInCooperativeThread() ) return nil; // Hoo-boy would this ever suck

    RgnHandle rgn = ::NewRgn();
    
    if ( rgn )
    {
	::OpenRgn();
	
	for ( long i = 0; i < pRegion->numRects; i++ )
	{
	    Rect r;
	    r.left = pRegion->rects[i].x1;
	    r.top = pRegion->rects[i].y1;
	    r.right = pRegion->rects[i].x2;
	    r.bottom = pRegion->rects[i].y2;
	    
	    ::FrameRect( &r );
	}
	
	::CloseRgn( rgn );
    }

    return rgn;
}



/************************************************************************
 *  Method:
 *    CHXMacSite::_ConvertToHXEvent
 */
BOOL
CHXMacSite::_ConvertToHXEvent( HXxEvent* pEvent )
{
    if (pEvent->event == mouseDown || pEvent->event == mouseUp)
    {
	HXxWindow* pWindow = GetWindow();
	if (pWindow && pWindow->window)
	{
	    GrafPtr savePort;
	    GetPort(&savePort);

	    WindowPtr w = (WindowPtr)pWindow->window;
	    
	    Point oldOrigin;
#if defined(_CARBON) || defined(_MAC_UNIX)
	    SetPort( GetWindowPort(w) );
	    Rect portRect;
	    GetPortBounds( GetWindowPort(w), &portRect );
	    oldOrigin.h = portRect.left;
	    oldOrigin.v = portRect.top;
#else
	    SetPort( w );
	    oldOrigin.h = w->portRect.left;
	    oldOrigin.v = w->portRect.top;
#endif
	    static HXxPoint realPt = {0,0};
	    
	    EventRecord* macEvent = (EventRecord*)pEvent->param1;
	    Point localPoint = macEvent->where;

	    GlobalToLocal( &localPoint );

	    realPt.x = localPoint.h;
	    realPt.y = localPoint.v;

	    UINT32 flags = 0;
	    if (macEvent->modifiers & shiftKey) flags |= HX_SHIFT_KEY;
	    if (macEvent->modifiers & controlKey) flags |= HX_CTRL_KEY;
	    if (macEvent->modifiers & cmdKey) flags |= HX_ALT_COMMAND_KEY;
	    
	    if (flags & HX_CTRL_KEY)
	    {
		pEvent->event = pEvent->event == mouseDown ?
			HX_CONTEXT_BUTTON_DOWN : HX_CONTEXT_BUTTON_UP;
	    }
	    else
	    {
		pEvent->event = pEvent->event == mouseDown ?
			HX_PRIMARY_BUTTON_DOWN : HX_PRIMARY_BUTTON_UP;
	    }
	    pEvent->param1 = (void*)&realPt;
	    pEvent->param2 = (void*)flags;

	    SetPort(savePort);

	    return FALSE;
	}
    }
    if (pEvent->event == nullEvent && _AtSystemTime())
    {
	EventRecord* macEvent = (EventRecord*)pEvent->param1;
	
	HXxWindow* pWindow = GetWindow();
	if (pWindow && pWindow->window)
	{
	    WindowPtr w = (WindowPtr)pWindow->window;
	    if (w == ::FrontWindow())
	    {
		GrafPtr savePort;
		::GetPort(&savePort);
#if defined(_CARBON) || defined(_MAC_UNIX)
		::SetPort( GetWindowPort(w) );
#else
		::SetPort(w);
#endif

		Point oldOrigin;

#if defined(_CARBON) || defined(_MAC_UNIX)
		Rect portRect;
		GetPortBounds( GetWindowPort( w ), &portRect );
		oldOrigin.h = portRect.left;
		oldOrigin.v = portRect.top;
#else
		oldOrigin.h = w->portRect.left;
		oldOrigin.v = w->portRect.top;
#endif
		
		// see if it's in this site

		Point p = macEvent->where;
		::GlobalToLocal(&p);
		HXxPoint loc;
		loc.x = p.h;
		loc.y = p.v;
		
		HX_ASSERT(m_RegionForMouse);
		if (m_RegionForMouse && IsPointInClippingRegion(&loc))
		{
		    static Point sLastGlobalLocation = {0,0};

		    if (macEvent->where.h != sLastGlobalLocation.h || macEvent->where.v != sLastGlobalLocation.v)
		    {
			sLastGlobalLocation = macEvent->where;
			Point localPt = sLastGlobalLocation;
			::GlobalToLocal(&localPt);

			m_MostRecentConvertedMouseLoc.x = localPt.h;
			m_MostRecentConvertedMouseLoc.y = localPt.v;

			UINT32 flags = 0;
			if (macEvent->modifiers & shiftKey) flags += HX_SHIFT_KEY;
			if (macEvent->modifiers & controlKey) flags += HX_CTRL_KEY;
			if (macEvent->modifiers & cmdKey) flags += HX_ALT_COMMAND_KEY;

			// don't change the event until we're done looking at it!
			// (the pre-converted version that is.)

			pEvent->event = HX_MOUSE_MOVE;
			pEvent->param1 = (void*)&m_MostRecentConvertedMouseLoc;
			pEvent->param2 = (void*)flags;

			// This will eventually be handled by the base site.
			// It's possible that the base site will need to translate
			// this into HX_MOUSE_ENTER and HX_MOUSE_LEAVE first,
			// though, which is why we don't simply handle it here.
		    }
		}
		else
		{
		    if (m_pTopLevelSite->m_pMouseInSite == this)
		    {
			m_pTopLevelSite->GenerateMouseLeaveMessage();
		    }
		}
		
		
		::SetPort(savePort);
	    }
	}
    }
    return FALSE; //pEvent->handled;
}

/************************************************************************
 *  Method:
 *    CHXMacSite::_GenerateOSEvent
 */
void
CHXMacSite::_GenerateOSEvent(HXxEvent* pEvent, HXxEvent* pEvent2)
{
}

/************************************************************************
 *  Method:
 *    CHXMacSite::_GenerateSetCursorEvent
 */
void
CHXMacSite::_GenerateSetCursorEvent()
{
    Point oldOrigin;

    HXxWindow* pWindow = GetWindow();
    if (!pWindow || !pWindow->window)
    {
	return;
    }

    WindowPtr w = (WindowPtr)pWindow->window;

    GrafPtr savePort;
    ::GetPort(&savePort);

#if defined(_CARBON) || defined(_MAC_UNIX)
    ::SetPort(::GetWindowPort(w));
#else
    ::SetPort(w);
#endif

#if defined(_CARBON) || defined(_MAC_UNIX)
    Rect portRect;
    GetPortBounds( GetWindowPort( w ), &portRect );
    oldOrigin.h = portRect.left;
    oldOrigin.v = portRect.top;
#else
    oldOrigin.h = w->portRect.left;
    oldOrigin.v = w->portRect.top;
#endif

    SetOriginAndMaintainClipRgn(-pWindow->x, -pWindow->y);

    HXxPoint offset = {0,0};
    GetMacContentAreaOffset(offset);

    SetOriginAndMaintainClipRgn(-offset.x, -offset.y);
    
    Point location;
    GetMouse(&location);

    HXxEvent theEvent;
    memset(&theEvent, 0, sizeof(theEvent));

    theEvent.event = HX_MOUSE_MOVE;
    
    HXxPoint mouseLoc;
    mouseLoc.x = location.h;
    mouseLoc.y = location.v;
    theEvent.param1 = (void*)&mouseLoc;
    
    SetOriginAndMaintainClipRgn(oldOrigin.h, oldOrigin.v);

    if (m_pUser)
	m_pUser->HandleEvent(&theEvent);

    ::SetPort(savePort);
}


void
CHXMacSite::_ScaleFullScreen(HXxWindow* pWindow)
{
    if (m_pParentSite != nil)
    {
	CHXMacSite* pParentSite = (CHXMacSite*)m_pParentSite;
	m_fStretchMultiple = pParentSite->m_fStretchMultiple;
	m_pHXxFullScreenWindow->window = pParentSite->m_pHXxFullScreenWindow->window;
	
	if (0 /*pParentSite->m_pStatusSite == this*/)
	{
	}
	else
	{
	    if (m_pWindow) pWindow = m_pWindow;
	    
	    m_pHXxFullScreenWindow->x = (long)((double)pWindow->x * m_fStretchMultiple);
	    m_pHXxFullScreenWindow->y = (long)((double)pWindow->y * m_fStretchMultiple);
	    m_pHXxFullScreenWindow->width = (long)((double)pWindow->width * m_fStretchMultiple);
	    m_pHXxFullScreenWindow->height = (long)((double)pWindow->height * m_fStretchMultiple);
	    
	    m_pHXxFullScreenWindow->clipRect.left = (long)((double)pWindow->clipRect.left * m_fStretchMultiple);
	    m_pHXxFullScreenWindow->clipRect.top = (long)((double)pWindow->clipRect.top * m_fStretchMultiple);
	    m_pHXxFullScreenWindow->clipRect.right = (long)((double)pWindow->clipRect.right * m_fStretchMultiple);
	    m_pHXxFullScreenWindow->clipRect.bottom = (long)((double)pWindow->clipRect.bottom * m_fStretchMultiple);
	}
    }


    CHXMapPtrToPtr::Iterator i = m_ChildrenMap.Begin();
    for ( ; i != m_ChildrenMap.End(); ++i)
    {
	CHXBaseSite* pSite = (CHXBaseSite*) *i;
	
	CHXMacSite* pMacSite = (CHXMacSite*)pSite;
	pMacSite->_ScaleFullScreen(pWindow);
    }
}

/************************************************************************
 *  Method:
 *    CHXMacSite::_EnterFullScreen
 */
HX_RESULT
CHXMacSite::_EnterFullScreen()
{
    if (zm_bFullScreenActive)
    {
	return HXR_UNEXPECTED;
    }
    
    zm_bFullScreenActive = TRUE;
    
    if (m_pTopLevelSite == this)
    {
	short desiredWidth, desiredHeight;