开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
macsite.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：65k
源码类别：

Symbian

开发平台：

C/C++

macsite.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. #ifndef _MACINTOSH
  37. #ifndef _MAC_UNIX
  38. #error This is the Macintosh platform specific implementation.
  39. #endif
  40. #endif
  42. #include "hxcom.h"
  44. #include "hxtypes.h"
  45. #include "hxwintyp.h"
  46. #include "hxmap.h"
  47. #include "hxslist.h"
  48. #include "ihxpckts.h"
  49. #include "hxwin.h"
  50. #include "hxengin.h"
  51. #include "hxsite2.h"
  52. #include "chxxtype.h"
  53. #include "hxvctrl.h"
  54. #include "hxvsurf.h"
  55. #include "hxcodec.h"
  56. #include "surface.h"
  57. #include "vidosurf.h"
  58. #include "sitetext.h"
  59. #include "chxpckts.h"
  60. #include "hxevent.h"
  61. #include "bltpatch.h"
  62. #include "hxprefs.h"
  64. #include "hxevent.h"
  65. #include "hxcore.h"
  67. #include "platform/mac/macsite.h"
  68. #include "platform/mac/macsurf.h"
  69. #include "platform/mac/macroot.h"
  71. #ifdef _CARBON
  72. #ifndef _MAC_MACHO
  73. #include <ControlDefinitions.h>
  74. #endif
  75. #endif
  77. #include "platform/mac/hx_moreprocesses.h"
  79. //#include "../dcondev/dcon.h"
  81. #include "basesurf.h"
  83. #include "hxtick.h"
  84. #include "hxvimlog.h"
  85. #include "hxheap.h"
  86. #ifdef _DEBUG
  87. #undef HX_THIS_FILE
  88. static const char HX_THIS_FILE[] = __FILE__;
  89. #endif
  91. #define SCROLL_BAR_WIDTH 16
  93. CHXSimpleList CHXMacSite::zm_ListOfMacSites;
  94. BOOL CHXMacSite::zm_bFullScreenActive = FALSE;
  95. Ptr CHXMacSite::zm_pRememberFullScreenInformation = nil;
  97. extern "C" void MacSiteHandleAllEvents(HXxEvent* pEvent);
  101. /*
  102.  *
  103.  * SetOriginAndMaintainClipRgn is designed to replace
  104.  * SetOrigin(). It will internally call SetOrigin
  105.  * if necessary, and it will also adjust the clip
  106.  * region in order to maintain the parts of the
  107.  * screen that the clip region refers to. This
  108.  * is necessary because, sadly, SetOrigin() in
  109.  * the Mac Toolbox does NOT change the values in
  110.  * the clipRgn so it suddenly refers to a different
  111.  * part of the screen!
  112.  *
  113.  */
  114. void SetOriginAndMaintainClipRgn(short horizOffset, short vertOffset)
  115. {
  116.     // SetOriginMaintainClip, like SetOrigin(), assumes
  117.     // that the port is set correctly.
  118.     GrafPtr curPort;
  119.     ::GetPort( &curPort );
  121.     Rect portBounds;
  122.     
  123. #if defined(_CARBON) || defined(_MAC_UNIX)
  124.     ::GetPortBounds( curPort, &portBounds );
  125. #else
  126.     portBounds = curPort->portRect;
  127. #endif
  129.     if ( ( horizOffset == portBounds.left ) && ( vertOffset == portBounds.top ) )
  130.     {
  131. return; // everything is already (presumably) set up correctly.
  132.     }
  133.     
  134.     RgnHandle clipRgn = ::NewRgn();
  135.     
  136.     ::GetClip( clipRgn );
  137.     
  138.     Rect clipRgnBounds;
  139. #if defined(_CARBON) || defined(_MAC_UNIX)
  140.     ::GetRegionBounds(clipRgn, &clipRgnBounds);
  141. #else
  142.     clipRgnBounds = (**clipRgn).rgnBBox;
  143. #endif
  144.     
  145.     // if the clip region goes too close to -32768 or 32767, we run the
  146.     // risk of rolling over those values when we do an OffsetRgn(). Sadly,
  147.     // OffsetRgn does NOT internally check for rollovers, but blithely
  148.     // slams those rolled-over values into the region, resulting in a
  149.     // meaningless region. To avoid that we're trimming the region to
  150.     // noticeable values. (i.e. if we see regions with a width or height
  151.     // of 44444, we can use that as a magic cookie type signature.)
  152.     if (clipRgnBounds.left < -25252
  153. || clipRgnBounds.top < -25252
  154. || clipRgnBounds.right > 25252
  155. || clipRgnBounds.bottom > 25252
  156. )
  157.     {
  158. RgnHandle soonToBeSectedRgnCopy = ::NewRgn();
  159. ::SetRectRgn( soonToBeSectedRgnCopy, -22222, -22222, 22222, 22222 );
  161. ::SectRgn( clipRgn, soonToBeSectedRgnCopy, clipRgn );
  163. ::DisposeRgn( soonToBeSectedRgnCopy );
  164.     }
  165.     ::OffsetRgn( clipRgn, horizOffset - portBounds.left, vertOffset - portBounds.top );
  166.     
  167.     ::SetOrigin( horizOffset, vertOffset );
  168.     ::SetClip( clipRgn );
  169.     ::DisposeRgn( clipRgn );
  170. }
  174. /************************************************************************
  175.  *  Method:
  176.  *    CHXMacSite constructor
  177.  */
  178. CHXMacSite::CHXMacSite(IUnknown* pContext, IUnknown* pUnkOuter, INT32 lZOrder)
  179.   : CHXBaseSite(pContext, pUnkOuter, lZOrder)
  180.   , m_hHScrollBar(NULL)
  181.   , m_hVScrollBar(NULL)
  182.   , m_ScrollBarActionProc(NULL)
  183.   , m_nHorizPageSize(1)
  184.   , m_nVertPageSize(1)
  185.   , m_bCreatedOSWindow(FALSE)
  186.   , m_pHXxFullScreenWindow(NULL)
  187.   , m_fStretchMultiple(0.0)
  188.   , m_RememberMacPort(nil)
  189.   , m_bInternalResizeOnFullscreen(TRUE)
  190.   , m_pMacSiteRedrawCallback(NULL)
  191. #ifdef THREADS_SUPPORTED
  193. #ifdef USE_CARBON_TIMER
  194. #ifdef _MAC_MACHO
  195.   , m_RedrawCFTimerRef(NULL)
  196. #else
  197.   , m_RedrawCarbonTimerRef(NULL)
  198.   , m_RedrawCarbonTimerUPP(NULL)
  199. #endif
  200. #endif
  202.   , m_pIHXCoreMutex(NULL)
  203.   , m_pClientEngine(NULL)
  204. #endif
  205. {
  206.     m_RememberMacOrigin.h = 0;
  207.     m_RememberMacOrigin.v = 0;
  208.     
  209.     m_MostRecentConvertedMouseLoc.x = 0;
  210.     m_MostRecentConvertedMouseLoc.y = 0;
  211.     
  212.     m_RememberNonFullscreenSize.cx = 0;
  213.     m_RememberNonFullscreenSize.cy = 0;
  214.     m_RememberNonFullscreenPosition.x = 0;
  215.     m_RememberNonFullscreenPosition.y = 0;
  216.     
  217.     IHXPreferences* pPreferences = NULL;
  218.     IHXBuffer* pBuffer = NULL;
  219.     
  220.     if (HXR_OK == m_pContext->QueryInterface(IID_IHXPreferences, (void**)&pPreferences))
  221.     {
  222. if (pPreferences->ReadPref("MacFullscreenInternalResize", pBuffer) == HXR_OK)
  223. {
  224.     m_bInternalResizeOnFullscreen = ::atoi((char*)pBuffer->GetBuffer()) == 1;
  225.     HX_RELEASE(pBuffer);
  226. }
  227. HX_RELEASE(pPreferences);
  228.     }
  229.     
  230.     zm_ListOfMacSites.AddTail(this);
  231.     
  232.     m_pMacSiteRedrawCallback = new MacSiteRedrawCallback(this);
  233.     m_pMacSiteRedrawCallback->AddRef();
  235. #ifdef THREADS_SUPPORTED
  236.     // xxxzach - TEMP - installing the event loop timer when running in the embedded player
  237.     // results in a crash when loading a 2nd page. 
  238.     //    appears to call the timer proc after ~CHXMacSite has been called
  239.     // so don't install timer if running as embedded player
  240.     const OSType kPlayerSignature = 'PNst';
  241. #ifdef USE_CARBON_TIMER
  242. #ifdef _MAC_MACHO
  243.     memset(&m_RedrawCFTimerContext, 0, sizeof(CFRunLoopTimerContext));
  244.     
  245.     m_RedrawCFTimerContext.info = (void*)this; // info is what's passed into the timer function
  246.     
  247.     m_RedrawCFTimerRef = ::CFRunLoopTimerCreate(
  248.                 kCFAllocatorDefault,
  249.                 ::CFAbsoluteTimeGetCurrent() + 31536000.0, // a year from now
  250.                 31536000.0, // every year
  251.                 0, //CFOptionFlags
  252.                 0, //CFIndexOrder
  253.                 CHXMacSite::RedrawCFTimer,
  254.                 &m_RedrawCFTimerContext);
  255.     
  256.     ::CFRunLoopAddTimer(
  257.                 ::CFRunLoopGetCurrent(),
  258.                 m_RedrawCFTimerRef,
  259.                 kCFRunLoopCommonModes
  260.                 );
  261. #else
  262.     m_RedrawCarbonTimerUPP = ::NewEventLoopTimerUPP(
  263. (EventLoopTimerProcPtr)CHXMacSite::RedrawCarbonTimer);
  265.     OSStatus osStatus = ::InstallEventLoopTimer(
  266. GetMainEventLoop(), kEventDurationForever, kEventDurationForever,
  267. m_RedrawCarbonTimerUPP, this, &m_RedrawCarbonTimerRef);
  268.     HX_ASSERT(osStatus == noErr);
  269. #endif
  270. #endif
  271.     
  272.     m_pContext->QueryInterface(IID_IHXCoreMutex, (void**)&m_pIHXCoreMutex);
  273.     HX_ASSERT(m_pIHXCoreMutex);
  274.     
  275.     m_pContext->QueryInterface(IID_IHXClientEngine, (void**)&m_pClientEngine);
  276. #endif
  277. }
  279. /************************************************************************
  280.  *  Method:
  281.  *    CHXMacSite destructor
  282.  */
  283. CHXMacSite::~CHXMacSite()
  284. {
  285. #ifdef THREADS_SUPPORTED
  286.     HX_RELEASE(m_pIHXCoreMutex);
  287.     HX_RELEASE(m_pClientEngine);
  288.     
  289. #ifdef USE_CARBON_TIMER
  290. #ifdef _MAC_MACHO
  291.     ::CFRunLoopRemoveTimer(
  292.                 ::CFRunLoopGetCurrent(),
  293.                 m_RedrawCFTimerRef,
  294.                 kCFRunLoopCommonModes
  295.                 );
  296.     
  297.     m_RedrawCFTimerRef = NULL;
  298.     memset(&m_RedrawCFTimerContext, 0, sizeof(CFRunLoopTimerContext));
  299. #else
  300.     ::RemoveEventLoopTimer(m_RedrawCarbonTimerRef);
  301.     m_RedrawCarbonTimerRef = NULL;
  303.     ::DisposeEventLoopTimerUPP(m_RedrawCarbonTimerUPP);
  304.     m_RedrawCarbonTimerUPP = NULL;
  305. #endif
  306. #endif
  308. #endif
  309.     _DestroySliders();
  310.     
  311.     if (m_pMacSiteRedrawCallback &&
  312. m_pMacSiteRedrawCallback->m_ulMacSiteRedrawCallbackPendingID &&
  313. m_pScheduler)
  314.     {
  315. m_pScheduler->Remove(m_pMacSiteRedrawCallback->m_ulMacSiteRedrawCallbackPendingID);
  316. m_pMacSiteRedrawCallback->m_ulMacSiteRedrawCallbackPendingID = 0;
  317.     }
  318.     HX_RELEASE(m_pMacSiteRedrawCallback);
  319.     
  320.     LISTPOSITION pos = zm_ListOfMacSites.Find(this);
  321.     zm_ListOfMacSites.RemoveAt(pos);
  322. }
  324. /************************************************************************
  325.  *  Method:
  326.  *    CHXMacSite::GetWindow
  327.  */
  328. STDMETHODIMP_(HXxWindow*) CHXMacSite::GetWindow() 
  329. {
  330.     if (zm_bFullScreenActive)
  331.     {
  332. if (m_pHXxFullScreenWindow) return m_pHXxFullScreenWindow;
  333. if (m_pParentSite) return m_pParentSite->GetWindow();
  335. HX_ASSERT(!"shouldn't get here");
  336.     }
  337.     return CHXBaseSite::GetWindow();
  340.     if (zm_bFullScreenActive && m_pHXxFullScreenWindow) return m_pHXxFullScreenWindow;
  341.     
  342. return m_pWindow;
  343.     return CHXBaseSite::GetWindow();
  344. }
  346. /************************************************************************
  347.  *  Method:
  348.  *    CHXMacSite::_NeedWindowedSite
  349.  */
  350. void
  351. CHXMacSite::_NeedWindowedSite()
  352. {
  353. }
  355. /************************************************************************
  356.  *  Method:
  357.  *    CHXMacSite::_AttachWindow
  358.  */
  359. void
  360. CHXMacSite::_AttachWindow()
  361. {
  362.     m_pHXxFullScreenWindow = new HXxWindow;
  363.     if (m_pTopLevelSite == this)
  364.     {
  365. Rect r = {0,0,0,0};
  366. m_pHXxFullScreenWindow->window = ::NewCWindow(nil, &r, "p", false, plainDBox, nil, false, 0);
  368. // if we created the mac window we need to update the HXxWindow parameters
  369. // so we're not clipped out later
  370. if (m_bCreatedOSWindow)
  371. {
  372.     HX_ASSERT(m_pWindow);
  373.     
  374.     WindowPtr w = (WindowPtr)m_pWindow->window;
  375.     
  376.     HX_ASSERT(w);
  377.     
  378.     m_pWindow->x = 0;
  379.     m_pWindow->y = 0;
  380.     
  381.     Rect bounds;
  382.     ::GetPortBounds(::GetWindowPort(w), &bounds);
  383.     
  384.     m_pWindow->width = bounds.right-bounds.left;
  385.     m_pWindow->height = bounds.bottom-bounds.top;
  386.     
  387.     m_pWindow->clipRect.left = 0;
  388.     m_pWindow->clipRect.top = 0;
  389.     m_pWindow->clipRect.right = m_pWindow->width;
  390.     m_pWindow->clipRect.bottom = m_pWindow->height;
  391. }
  392.     }
  393.     else
  394.     {
  395. CHXMacSite* pMacParentSite = (CHXMacSite*)m_pParentSite; // XXXbobclark Ewwww! (Can we use RTTI ya think?)
  396. m_pHXxFullScreenWindow->window = pMacParentSite->m_pHXxFullScreenWindow->window;
  397.     }
  398. }
  400. /************************************************************************
  401.  *  Method:
  402.  *    CHXMacSite::_DetachWindow
  403.  */
  404. void
  405. CHXMacSite::_DetachWindow()
  406. {
  407. }
  409. /************************************************************************
  410.  *  Method:
  411.  *    CHXMacSite::_Create
  412.  */
  413. void*
  414. CHXMacSite::_Create(void* ParentWindow, UINT32 style)
  415. {
  416.     if (!ParentWindow)
  417.     {
  418. Rect r = {200,400,40,40};
  419. WindowPtr w = ::NewCWindow(nil, &r, "p", true, documentProc, (WindowPtr)-1L, false, 0);
  421. if (w)
  422. {
  423.     m_bCreatedOSWindow = TRUE;
  424.     return w;
  425. }
  426.     }
  427.     
  428.     m_bCreatedOSWindow = FALSE;
  429.     return ParentWindow;
  430. }
  432. /************************************************************************
  433.  *  Method:
  434.  *    CHXMacSite::_Destroy
  435.  */
  436. void
  437. CHXMacSite::_Destroy(HXxWindow* pWindow)
  438. {
  439.     if (CMacSurface::zm_pOverlaySurface == (CMacSurface*)m_pVideoSurface)
  440.     {
  441. CMacSurface::CleanUpOverlay();
  442. CMacSurface::zm_pOverlaySurface = nil;
  443.     }
  444.     
  445.     if (pWindow && m_bCreatedOSWindow)
  446.     {
  447. WindowPtr w = (WindowPtr)pWindow->window;
  448. if (w)
  449. {
  450.     ::DisposeWindow(w);
  451. }
  452. m_bCreatedOSWindow = FALSE;
  453.     }
  454. }
  456. /************************************************************************
  457.  *  Method:
  458.  *    CHXMacSite::_SetSize
  459.  */
  460. void
  461. CHXMacSite::_SetSize(HXxSize size)
  462. {
  463.     if (m_bCreatedOSWindow && m_pWindow && m_pWindow->window)
  464.     {
  465. WindowPtr w = (WindowPtr)m_pWindow->window;
  466. ::SizeWindow(w, size.cx, size.cy, true);
  468. m_pWindow->x = 0;
  469. m_pWindow->y = 0;
  471. Rect bounds;
  472. ::GetPortBounds(::GetWindowPort(w), &bounds);
  474. m_pWindow->width = bounds.right-bounds.left;
  475. m_pWindow->height = bounds.bottom-bounds.top;
  477. m_pWindow->clipRect.left = 0;
  478. m_pWindow->clipRect.top = 0;
  479. m_pWindow->clipRect.right = m_pWindow->width;
  480. m_pWindow->clipRect.bottom = m_pWindow->height;
  481.     }
  482.     // delete the scroll bars so it recreates them in the right spot
  483.     _DestroySliders();
  484. }
  486. /************************************************************************
  487.  *  Method:
  488.  *    CHXMacSite::_SetPosition
  489.  */
  490. void
  491. CHXMacSite::_SetPosition(HXxPoint position)
  492. {
  493.     if (m_bCreatedOSWindow && m_pWindow && m_pWindow->window)
  494.     {
  495. WindowPtr w = (WindowPtr)m_pWindow->window;
  496. ::MoveWindow(w, position.x, position.y, false);
  497.     }
  498.     else
  499.     {
  500. m_screenOffset = position;
  501.     }
  502.     // delete the scroll bars so it recreates them in the right spot.
  503.     _DestroySliders();
  504. }
  506. /************************************************************************
  507.  *  Method:
  508.  *    CHXMacSite::_DamageRect
  509.  */
  510. void
  511. CHXMacSite::_DamageRect(HXxRect rect)
  512. {
  513. }
  515. /************************************************************************
  516.  *  Method:
  517.  *    CHXMacSite::_DamageRect
  518.  */
  519. void
  520. CHXMacSite::_DamageRegion(HXxRegion rgn)
  521. {
  522. }
  524. /************************************************************************
  525.  *  Method:
  526.  *    CHXMacSite::_ShouldEnterForceRedraw
  527.  */
  528. BOOL
  529. CHXMacSite::_ShouldEnterForceRedraw()
  530. {
  531.     if (InterlockedIncrement(&m_lBltEntryCount) > 1)
  532.     {
  533.         InterlockedDecrement(&m_lBltEntryCount);
  534.         return FALSE; 
  535.     }
  537. #ifdef THREADS_SUPPORTED
  538. #ifdef USE_CARBON_TIMER
  539.     if (!IsMacInCooperativeThread())
  540.     {
  541. // we need to schedule a Carbon Timer callback
  542. // to access ourselves at system time.
  544. // XXXMEH 06/17/2002 - we moved this InterlockDecrement()
  545. // to BEFORE the SetEventLoopTimerNextFireTime(). The reason
  546. // is that sometimes, you actually get an IMMEDIATE callback
  547. // on the main thread before you have decremented m_lBltEntryCount.
  548. // When this happened while the decrement was AFTER SetEventLoopTimerNextFireTime(),
  549. // then the ForceRedraw() would bail out early at the
  550. // if(InterlockedIncrement(&m_lBltEntryCount) > 1) at the
  551. // top of this method and the blt would never happen.
  552.         InterlockedDecrement(&m_lBltEntryCount);
  553. #ifdef _MAC_MACHO
  554. HX_ASSERT(m_RedrawCFTimerRef);
  555.         ::CFRunLoopTimerSetNextFireDate(
  556.                         m_RedrawCFTimerRef,
  557.                         ::CFAbsoluteTimeGetCurrent() // immediately!
  558.                         );
  559. #else
  560. HX_ASSERT(m_RedrawCarbonTimerRef);
  561. ::SetEventLoopTimerNextFireTime(m_RedrawCarbonTimerRef, kEventDurationNoWait);
  562. #endif
  563.         // XXXMEH 06/17/2002 - We USED to decrement m_lBltEntryCount here - 
  564.         // now we have moved it before SetEventLoopTimerNextFireTime()
  565. return FALSE;
  566.     }
  567. #endif
  568. #endif
  570.     HXxWindow* topWindow = GetWindow();
  571.     if (_AtSystemTime() && topWindow && topWindow->window)
  572.     {
  573. ::GetPort(&m_RememberMacPort);
  574. WindowPtr w = (WindowPtr)topWindow->window;
  575. #if defined(_CARBON) || defined(_MAC_UNIX)
  576. ::SetPort( GetWindowPort( w ) );
  577. #else
  578. ::SetPort(w);
  579. #endif
  581. // remember old origin
  583. #if defined(_CARBON) || defined(_MAC_UNIX)
  584. Rect portRect;
  585. GetPortBounds( GetWindowPort( w ), &portRect );
  586. m_RememberMacOrigin.h = portRect.left;
  587. m_RememberMacOrigin.v = portRect.top;
  588. #else
  589. m_RememberMacOrigin.h = w->portRect.left;
  590. m_RememberMacOrigin.v = w->portRect.top;
  591. #endif
  593. // get new origin
  595. HXxPoint offset;
  596. offset.x = 0;
  597. offset.y = 0;
  598. GetMacContentAreaOffset(offset);
  600. // see if the clip region overlaps where we know we're supposed to be.
  602. Rect siteRect = { 0, 0, topWindow->height, topWindow->width };
  603. OffsetRect( &siteRect, topWindow->x, topWindow->y );
  605. BOOL bSiteClippedOutSoRedrawNecessary = FALSE;
  607. RgnHandle clippedSiteRgn = ::NewRgn();
  608. RgnHandle siteRgn = ::NewRgn();
  610. ::RectRgn(siteRgn, &siteRect);
  612. #if defined(_CARBON) || defined(_MAC_UNIX)
  613. RgnHandle clipRgn = ::NewRgn();
  614. ::GetPortClipRegion( GetWindowPort( w ), clipRgn );
  615. ::SectRgn( siteRgn, clipRgn, clippedSiteRgn );
  616. ::DisposeRgn( clipRgn );
  617. #else
  618. ::SectRgn(siteRgn, w->clipRgn, clippedSiteRgn);
  619. #endif
  621. if (::EmptyRgn(clippedSiteRgn))
  622. {
  623.     bSiteClippedOutSoRedrawNecessary = TRUE;
  624. }
  626. DisposeRgn(siteRgn);
  627. DisposeRgn(clippedSiteRgn);
  629. if (bSiteClippedOutSoRedrawNecessary)
  630. {
  631.     // D'oh, doesn't intersect! So let's just draw next time around.
  633.     // we need to schedule a redraw if one ain't there already.
  634.     if (!m_pMacSiteRedrawCallback->m_ulMacSiteRedrawCallbackPendingID
  635. && m_pScheduler)
  636.     {
  637. m_pMacSiteRedrawCallback->m_ulMacSiteRedrawCallbackPendingID =
  638. m_pScheduler->RelativeEnter(m_pMacSiteRedrawCallback, 1);
  639.     }
  641.     goto returnfalse;
  642. }
  644. // set new origin
  646. // xxxbobclark
  647. // Sheesh. OK, so the clip region is relative to the current
  648. // origin, but it is NOT magically shifted when you call
  649. // SetOrigin. So whenever you call SetOrigin, you're also
  650. // "secretly" changing which actual pixels of the window are
  651. // within the clip region.
  652. // That's why this utility function was written
  653. SetOriginAndMaintainClipRgn(-offset.x, -offset.y);
  654.     }
  655.     
  656.     return TRUE;
  658. returnfalse:
  659.     // xxxbobclark I needed to move this code around because CWPro 7's compiler
  660.     // was running out of local variable space. Odd.
  661.     
  662.     ::SetPort(m_RememberMacPort);
  663.     // decrement count since it won't execute ForceRedraw.
  664.     InterlockedDecrement(&m_lBltEntryCount);
  665.     return FALSE;
  667. }
  669. /************************************************************************
  670.  *  Method:
  671.  *    CHXMacSite::_ExitForceRedraw
  672.  */
  673. void
  674. CHXMacSite::_ExitForceRedraw()
  675. {
  676.     HXxWindow* topWindow = GetParentWindow();
  677.     if (_AtSystemTime() && topWindow && topWindow->window)
  678.     {
  679. // restore old origin
  681. SetOriginAndMaintainClipRgn(m_RememberMacOrigin.h, m_RememberMacOrigin.v);
  683. ::SetPort(m_RememberMacPort);
  684. m_RememberMacPort = nil;
  685.     }
  686.     
  687.     InterlockedDecrement(&m_lBltEntryCount);
  688. }
  690. /************************************************************************
  691.  *  Method:
  692.  *    CHXMacSite::_SendOSUpdateMessage
  693.  */
  694. void
  695. CHXMacSite::_SendOSUpdateMessage()
  696. {
  697. #if 0
  698.     ASSERT(GetOSWindow());
  699.     
  700.     if (GetOSWindow())
  701.     {
  702. GrafPtr savePort;
  703. ::GetPort(&savePort);
  705. WindowPtr w = (WindowPtr)GetOSWindow();
  706. ::SetPort(w);
  707. // XXXbobclark
  708. // I still haven't fully grokked how to avoid loops: _HandleOSEvent on an
  709. // update event can call _ForceRedraw(), which in turn calls _SendOSUpdateMessage,
  710. // where InvalRect() can generate an update event.... And we need this to function
  711. // properly, so things like paused movies will redraw if they're obscured then shown.
  713. // ::InvalRect(&w->portRect);
  714. ::SetPort(savePort);
  715.     }
  716. #endif
  717. }
  719. /************************************************************************
  720.  *  Method:
  721.  *    CHXMacSite::_ShowSite
  722.  */
  723. void
  724. CHXMacSite::_ShowSite(BOOL bShow)
  725. {
  726.     if (m_pWindow && m_pWindow->window)
  727.     {
  728. // XXXbobclark I think that the cross-platform stuff should take care of this...
  729.     }
  730. }
  732. /************************************************************************
  733.  *  Method:
  734.  *    CHXMacSite::_AtSystemTime
  735.  */
  736. BOOL
  737. CHXMacSite::_AtSystemTime()
  738. {
  739.     return IsMacInCooperativeThread();
  740. }
  742. /************************************************************************
  743.  *  Method:
  744.  *    CHXMacSite::_EventOccurred
  745.  */
  746. HX_RESULT
  747. CHXMacSite::_EventOccurred(HXxEvent* pEvent)
  748. {
  749.     return HXR_OK;
  750. }
  752. /************************************************************************
  753.  *  Method:
  754.  *    CHXMacSite::_GetDeviceCaps
  755.  */
  756. void
  757. CHXMacSite::_GetDeviceCaps(void* hdc, UINT16& uBytesPerPixel, UINT16& uHorizRes,
  758. UINT16& uVertRes)
  759. {
  760.     static UINT16 sBytesPerPixel = 4;
  761.     static UINT16 sHorizRes = 640;
  762.     static UINT16 sVertRes = 480;
  763.     static BOOL sInited = FALSE;
  764.     
  765.     if (!sInited && _AtSystemTime())
  766.     {
  767. GDHandle mainGD = ::GetMainDevice();
  768. sHorizRes = (**mainGD).gdRect.right - (**mainGD).gdRect.left;
  769. sVertRes = (**mainGD).gdRect.bottom - (**mainGD).gdRect.top;
  770. PixMapHandle pmh = (**mainGD).gdPMap;
  771. if (pmh)
  772. {
  773.     sBytesPerPixel = (**pmh).pixelSize;
  774. }
  775.     }
  776.     
  777.     uBytesPerPixel = sBytesPerPixel;
  778.     uHorizRes = sHorizRes;
  779.     uVertRes = sVertRes;
  780. }
  782. /************************************************************************
  783.  *  Method:
  784.  *    CHXMacSite::_GetWindowRect
  785.  */
  786. void
  787. CHXMacSite::_GetWindowRect(HXxRect* destRect)
  788. {
  789. }
  791. /************************************************************************
  792.  *  Method:
  793.  *    CHXMacSite::_DestroySliders
  794.  */
  795. void
  796. CHXMacSite::_DestroySliders()
  797. {
  798.     if (m_hHScrollBar)
  799.     {
  800. ::DisposeControl(m_hHScrollBar);
  801. m_hHScrollBar = NULL;
  802.     }
  803.     if (m_hVScrollBar)
  804.     {
  805. ::DisposeControl(m_hVScrollBar);
  806. m_hVScrollBar = NULL;
  807.     }
  808. }
  810. /************************************************************************
  811.  *  Method:
  812.  *    CHXMacSite::_HandleOSEvents
  813.  */
  814. BOOL
  815. CHXMacSite::_HandleOSEvents(HXxEvent* pEvent)
  816. {
  817.     BOOL handled = FALSE;
  818.     {
  819. EventRecord* macEvent = (EventRecord*) pEvent->param1;
  821. // if we switch out while in full-screen, unfortunately we need
  822. // to turn off full-screen.
  824. if (zm_bFullScreenActive && macEvent->what == nullEvent)
  825. {
  826.     ProcessSerialNumber currentPSN;
  827.     ProcessSerialNumber frontPSN;
  828.     
  829.     ::GetCurrentProcess(&currentPSN);
  830.     ::GetFrontProcess(&frontPSN);
  831.     
  832.     Boolean bCurrentIsFront = TRUE;
  833.     ::SameProcess(&currentPSN, &frontPSN, &bCurrentIsFront);
  834.     
  835.     if (!bCurrentIsFront)
  836.     {
  838. ExitFullScreen();
  840. HXxWindow* pWindow = GetWindow();
  841. if (pWindow && pWindow->window)
  842. {
  843.     GrafPtr savePort;
  844.     ::GetPort(&savePort);
  845.     WindowPtr w = (WindowPtr)pWindow->window;
  846.     ::SetPort(::GetWindowPort(w));
  847.     Rect windowBounds;
  848.     ::GetPortBounds(::GetWindowPort(w), &windowBounds);
  849.     ::InvalWindowRect(w, &windowBounds);
  850.     ::SetPort(savePort);
  851. }
  853. handled = TRUE;
  854.     }
  855. }
  857. if (macEvent->what == keyDown)
  858. {
  859.     char theKey = macEvent->message & 0x000000ff;
  860.     
  861.     if (CHXMacSite::zm_bFullScreenActive && theKey == 0x1b)
  862.     {
  863. ExitFullScreen();
  864.     }
  865.     else
  866.     {
  867. if (m_pUser)
  868.     m_pUser->HandleEvent(pEvent);
  870. handled = pEvent->handled;
  871.     }
  872. }
  874. if (macEvent->what == updateEvt || macEvent->what == activateEvt)
  875. {
  876.     HX_ASSERT(_AtSystemTime());
  877.     
  878.     WindowPtr w = (WindowPtr)macEvent->message;
  880.     if (w)
  881.     {
  882. if (zm_bFullScreenActive && m_pHXxFullScreenWindow && m_pHXxFullScreenWindow->window
  883. && m_pHXxFullScreenWindow->window == w)
  884. {
  885.     GrafPtr savePort;
  886.     ::GetPort(&savePort);
  887. #if defined(_CARBON) || defined(_MAC_UNIX)
  888.     ::SetPort( GetWindowPort( w ) );
  889. #else
  890.     ::SetPort(w);
  891. #endif
  892.     RGBColor holdRGB;
  893.     RGBColor theRGB = {0x0000, 0x0000, 0x0000};
  894.     ::GetBackColor(&holdRGB);
  895.     ::RGBBackColor(&theRGB);
  896. #if defined(_CARBON) || defined(_MAC_UNIX)
  897.     Rect portRect;
  898.     GetPortBounds( GetWindowPort( w ), &portRect );
  899.     ::EraseRect( &portRect );
  900. #else
  901.     ::EraseRect(&w->portRect);
  902. #endif
  903.     ::RGBBackColor(&holdRGB);
  904.     ::SetPort(savePort);
  905. }
  907. m_pTopLevelSite->RecomputeClip();
  909. // see if overlay is active... if so, then we might just need
  910. // to fill with a color key!
  911. if (CMacSurface::zm_pOverlaySurface)
  912. {
  913.     CMacSurface* pMacSurface = (CMacSurface*)m_pVideoSurface;
  914.     if (pMacSurface == CMacSurface::zm_pOverlaySurface)
  915.     {
  916. // aha! THIS site's surface is in fact the overlay surface.
  917. m_pVideoSurface->FillColorKey();
  918.     }
  919. }
  920. HXxRect siteRectToDamage;
  921. siteRectToDamage.left = 0;
  922. siteRectToDamage.top = 0;
  923. siteRectToDamage.right = m_size.cx;
  924. siteRectToDamage.bottom = m_size.cy;
  925. DamageRect(siteRectToDamage);
  926.          InternalForceRedraw();
  927.     }
  929.     HXxWindow* pWindow = GetWindow();
  930.     if (pWindow && pWindow->window == (WindowPtr)macEvent->message)
  931.     {
  932. // XXXbobclark commented out 'cause it's already done for "honest"
  933. // update events. I don't wanna do this for fake update events.
  934. // m_pTopLevelSite->RecomputeClip();
  935. // ForceRedraw();
  936. if (pEvent->param2 && _AtSystemTime())
  937. {
  938.     // for update events, param2 may contain a RgnHandle into
  939.     // which we add the area that we are handling updates in,
  940.     // so the TLC knows it doesn't have to draw there.
  941.     
  942.     if (m_bBltHasBeenCalled)
  943.     {
  944. if (!m_bThisOrAChildHasBlitted)
  945. {
  946.     CHXMacSite* pMacSite = this;
  947.     while (pMacSite)
  948.     {
  949. pMacSite->m_bThisOrAChildHasBlitted = TRUE;
  950. pMacSite = (CHXMacSite*)pMacSite->m_pParentSite;
  951.     }
  952. }
  953.     }
  954.     
  955.     if (m_bThisOrAChildHasBlitted)
  956.     {
  957. RgnHandle handledRgn = ::NewRgn();
  958. RgnHandle passedInRgn = (RgnHandle)pEvent->param2;
  960. HXxPoint ptSiteOrigin;
  961. GetMacContentAreaOffset(ptSiteOrigin);
  963. Rect myRect = { ptSiteOrigin.y, ptSiteOrigin.x,
  964. ptSiteOrigin.y + m_size.cy,
  965. ptSiteOrigin.x + m_size.cx };
  967. ::RectRgn(handledRgn, &myRect);
  968. ::UnionRgn(passedInRgn, handledRgn, passedInRgn);
  969. ::DisposeRgn(handledRgn);
  970.     }
  971. }
  972.     }
  973.     
  974.     if (m_hHScrollBar || m_hVScrollBar)
  975.     {
  976. Point oldOrigin;
  977. Rect portRect;
  978. GetPortBounds(GetWindowPort(w), &portRect);
  979. oldOrigin.h = portRect.left;
  980. oldOrigin.v = portRect.top;
  982. SetOriginAndMaintainClipRgn(0,0);
  984. if (m_hHScrollBar)
  985. {
  986.     ::Draw1Control(m_hHScrollBar);
  987.     handled = TRUE;
  988. }
  989. if (m_hVScrollBar)
  990. {
  991.     ::Draw1Control(m_hVScrollBar);
  992.     handled = TRUE;
  993. }
  995. SetOriginAndMaintainClipRgn(oldOrigin.h, oldOrigin.v);
  996.     }
  997. }
  999. if (macEvent->what == mouseDown || macEvent->what == mouseUp)
  1000. {
  1001.     WindowPtr w = nil;
  1003.     ControlHandle theControl = NULL;
  1004.     
  1005.     HXxWindow* pWindow = GetWindow();
  1006.     
  1007.     if (pWindow && pWindow->window)
  1008.     {
  1009. w = (WindowPtr)pWindow->window;
  1010.     }
  1011.     
  1012.     HX_ASSERT(w);
  1013.     
  1014.     if (!w) return HXR_FAIL;
  1016.     GrafPtr savePort;
  1017.     ::GetPort(&savePort);
  1018.     ::SetPort(::GetWindowPort(w));
  1019.     
  1020.     Point oldOrigin;
  1021.     Rect portRect;
  1022.     ::GetPortBounds(::GetWindowPort(w), &portRect);
  1023.     oldOrigin.h = portRect.left;
  1024.     oldOrigin.v = portRect.top;
  1025.     
  1026.     SetOriginAndMaintainClipRgn(0,0); // origin must be at 0,0 for scroll bar maintenence
  1027.     
  1028.     Point localPt = macEvent->where;
  1029.     ::GlobalToLocal(&localPt);
  1030.     
  1031.     short thePart = 0;
  1032.     theControl = ::FindControlUnderMouse(localPt, w, &thePart);
  1033.     
  1034.     if (theControl && ((theControl == m_hHScrollBar) || (theControl == m_hVScrollBar)))
  1035.     {
  1036. short trackedPart = ::TrackControl(theControl, localPt, m_ScrollBarActionProc);
  1038. long pageSize;
  1040. if (theControl == m_hHScrollBar)
  1041. {
  1042.     pageSize = m_nHorizPageSize;
  1043. }
  1044. else
  1045. {
  1046.     pageSize = m_nVertPageSize;
  1047. }
  1049. switch (trackedPart)
  1050. {
  1051.     case kControlUpButtonPart:
  1052. ::SetControl32BitValue(theControl, ::GetControl32BitValue(theControl)-1);
  1053. break;
  1054.     case kControlDownButtonPart:
  1055. ::SetControl32BitValue(theControl, ::GetControl32BitValue(theControl)+1);
  1056. break;
  1057.     case kControlPageUpPart:
  1058. ::SetControl32BitValue(theControl, ::GetControl32BitValue(theControl)-pageSize);
  1059. break;
  1060.     case kControlPageDownPart:
  1061. ::SetControl32BitValue(theControl, ::GetControl32BitValue(theControl)+pageSize);
  1062. break;
  1063. }
  1065. if (theControl == m_hHScrollBar)
  1066. {
  1067.     m_XSliderPos = ::GetControl32BitValue(theControl);
  1068. }
  1069. if (theControl == m_hVScrollBar)
  1070. {
  1071.     m_YSliderPos = ::GetControl32BitValue(theControl);
  1072. }
  1074. HXxPoint ptSiteOrigin;
  1075. GetMacContentAreaOffset(ptSiteOrigin);
  1076. Rect invalRect;
  1077. invalRect.left = ptSiteOrigin.x;
  1078. invalRect.top = ptSiteOrigin.y;
  1080. if (m_hHScrollBar)
  1081. {
  1082.     Rect controlRect;
  1083.     ::GetControlBounds(m_hHScrollBar, &controlRect);
  1084.     invalRect.right = controlRect.right;
  1085.     invalRect.bottom = controlRect.top;
  1086. }
  1087. if (m_hVScrollBar)
  1088. {
  1089.     Rect controlRect;
  1090.     ::GetControlBounds(m_hVScrollBar, &controlRect);
  1091.     invalRect.right = controlRect.left;
  1092.     invalRect.bottom = controlRect.bottom;
  1093. }
  1095. ::InvalWindowRect(w, &invalRect);
  1096. handled = TRUE;
  1097.     }
  1098.     
  1099.     if (!handled)
  1100.     {
  1101. HXxWindow* pWindow = GetWindow();
  1102. if (pWindow && pWindow->window)
  1103. {
  1104.     // see if it's in this site
  1106.     SetOriginAndMaintainClipRgn(-pWindow->x, -pWindow->y);
  1107.     Point p = macEvent->where;
  1108.     ::GlobalToLocal(&p);
  1109.     HXxPoint loc;
  1110.     loc.x = p.h;
  1111.     loc.y = p.v;
  1112.     
  1113.     HX_ASSERT(m_RegionForMouse);
  1114.     if (IsPointInClippingRegion(&loc))
  1115.     {
  1116. HXxPoint offset = {0,0};
  1117. GetMacContentAreaOffset(offset);
  1119. // UDrawingUtils::SetOriginAndMaintainClipRgn(-offset.x, -offset.y);
  1122.                         if (m_pUser)
  1123.                         {
  1124. //                            m_pUser->HandleEvent(pEvent);
  1125. //                            handled = pEvent->handled;
  1126.                         }
  1127.     }
  1128.     
  1129.     SetOriginAndMaintainClipRgn(oldOrigin.h, oldOrigin.v);
  1130.     
  1131.     ::SetPort(savePort);
  1132. }
  1134.     }
  1135. }
  1136.     }
  1137.     return handled;
  1138. }
  1140. /************************************************************************
  1141.  *  Method:
  1142.  *    CHXMacSite::_HandleAllOSEvents
  1143.  */
  1144. /* static */
  1145. void CHXMacSite::_HandleAllOSEvents(HXxEvent* pEvent)
  1146. {
  1147.     EventRecord* macEvent = (EventRecord*) pEvent->param1;
  1148.     
  1149.     CHXSimpleList::Iterator ndx = zm_ListOfMacSites.Begin();
  1150.     for ( ; ndx != zm_ListOfMacSites.End(); ++ndx)
  1151.     {
  1152. CHXMacSite* pMacSite = (CHXMacSite*)(*ndx);
  1154. HX_ASSERT( pMacSite );
  1156. pMacSite->_HandleOSEvents(pEvent);
  1157.     }
  1158.     
  1159. /*
  1160.     if (gRecentUpdateEvent)
  1161.     {
  1162. EventRecord* macEvent = (EventRecord*)pEvent->param1;
  1163. if (macEvent->what == updateEvt)
  1164. {
  1165.     // XXXbobclark
  1166.     // clearly we're handling the recent update event and since we've
  1167.     // just done it let's clear that puppy out.
  1168.     gRecentUpdateEvent = false;
  1169. }
  1170.     }
  1171. */
  1172. }
  1175. /************************************************************************
  1176.  *  Method:
  1177.  *    CHXMacSite::_ConvertRegionToMacRegion
  1178.  * utility function to convert between the RealNetworks
  1179.  * regions that the site classes use and Mac-specific
  1180.  * RgnHandle's.
  1181.  */
  1182. /* static */
  1183. RgnHandle
  1184. CHXMacSite::_ConvertRegionToMacRegion( HXREGION* pRegion )
  1185. {
  1186.     HX_ASSERT(IsMacInCooperativeThread());
  1187.     if ( !IsMacInCooperativeThread() ) return nil; // Hoo-boy would this ever suck
  1189.     RgnHandle rgn = ::NewRgn();
  1190.     
  1191.     if ( rgn )
  1192.     {
  1193. ::OpenRgn();
  1195. for ( long i = 0; i < pRegion->numRects; i++ )
  1196. {
  1197.     Rect r;
  1198.     r.left = pRegion->rects[i].x1;
  1199.     r.top = pRegion->rects[i].y1;
  1200.     r.right = pRegion->rects[i].x2;
  1201.     r.bottom = pRegion->rects[i].y2;
  1202.     
  1203.     ::FrameRect( &r );
  1204. }
  1206. ::CloseRgn( rgn );
  1207.     }
  1209.     return rgn;
  1210. }
  1214. /************************************************************************
  1215.  *  Method:
  1216.  *    CHXMacSite::_ConvertToHXEvent
  1217.  */
  1218. BOOL
  1219. CHXMacSite::_ConvertToHXEvent( HXxEvent* pEvent )
  1220. {
  1221.     if (pEvent->event == mouseDown || pEvent->event == mouseUp)
  1222.     {
  1223. HXxWindow* pWindow = GetWindow();
  1224. if (pWindow && pWindow->window)
  1225. {
  1226.     GrafPtr savePort;
  1227.     GetPort(&savePort);
  1229.     WindowPtr w = (WindowPtr)pWindow->window;
  1230.     
  1231.     Point oldOrigin;
  1232. #if defined(_CARBON) || defined(_MAC_UNIX)
  1233.     SetPort( GetWindowPort(w) );
  1234.     Rect portRect;
  1235.     GetPortBounds( GetWindowPort(w), &portRect );
  1236.     oldOrigin.h = portRect.left;
  1237.     oldOrigin.v = portRect.top;
  1238. #else
  1239.     SetPort( w );
  1240.     oldOrigin.h = w->portRect.left;
  1241.     oldOrigin.v = w->portRect.top;
  1242. #endif
  1243.     SetOriginAndMaintainClipRgn(-pWindow->x, -pWindow->y);
  1244.     
  1245.     static HXxPoint realPt = {0,0};
  1246.     
  1247.     EventRecord* macEvent = (EventRecord*)pEvent->param1;
  1248.     Point localPoint = macEvent->where;
  1250.     GlobalToLocal( &localPoint );
  1252.     realPt.x = localPoint.h;
  1253.     realPt.y = localPoint.v;
  1255.     UINT32 flags = 0;
  1256.     if (macEvent->modifiers & shiftKey) flags |= HX_SHIFT_KEY;
  1257.     if (macEvent->modifiers & controlKey) flags |= HX_CTRL_KEY;
  1258.     if (macEvent->modifiers & cmdKey) flags |= HX_ALT_COMMAND_KEY;
  1259.     
  1260.     if (flags & HX_CTRL_KEY)
  1261.     {
  1262. pEvent->event = pEvent->event == mouseDown ?
  1263. HX_CONTEXT_BUTTON_DOWN : HX_CONTEXT_BUTTON_UP;
  1264.     }
  1265.     else
  1266.     {
  1267. pEvent->event = pEvent->event == mouseDown ?
  1268. HX_PRIMARY_BUTTON_DOWN : HX_PRIMARY_BUTTON_UP;
  1269.     }
  1270.     pEvent->param1 = (void*)&realPt;
  1271.     pEvent->param2 = (void*)flags;
  1273.     SetOriginAndMaintainClipRgn(oldOrigin.h, oldOrigin.v);
  1274.     SetPort(savePort);
  1276.     return FALSE;
  1277. }
  1278.     }
  1279.     if (pEvent->event == nullEvent && _AtSystemTime())
  1280.     {
  1281. EventRecord* macEvent = (EventRecord*)pEvent->param1;
  1283. HXxWindow* pWindow = GetWindow();
  1284. if (pWindow && pWindow->window)
  1285. {
  1286.     WindowPtr w = (WindowPtr)pWindow->window;
  1287.     if (w == ::FrontWindow())
  1288.     {
  1289. GrafPtr savePort;
  1290. ::GetPort(&savePort);
  1291. #if defined(_CARBON) || defined(_MAC_UNIX)
  1292. ::SetPort( GetWindowPort(w) );
  1293. #else
  1294. ::SetPort(w);
  1295. #endif
  1297. Point oldOrigin;
  1299. #if defined(_CARBON) || defined(_MAC_UNIX)
  1300. Rect portRect;
  1301. GetPortBounds( GetWindowPort( w ), &portRect );
  1302. oldOrigin.h = portRect.left;
  1303. oldOrigin.v = portRect.top;
  1304. #else
  1305. oldOrigin.h = w->portRect.left;
  1306. oldOrigin.v = w->portRect.top;
  1307. #endif
  1309. // see if it's in this site
  1311. SetOriginAndMaintainClipRgn(-pWindow->x, -pWindow->y);
  1313. Point p = macEvent->where;
  1314. ::GlobalToLocal(&p);
  1315. HXxPoint loc;
  1316. loc.x = p.h;
  1317. loc.y = p.v;
  1319. HX_ASSERT(m_RegionForMouse);
  1320. if (m_RegionForMouse && IsPointInClippingRegion(&loc))
  1321. {
  1322.     static Point sLastGlobalLocation = {0,0};
  1324.     if (macEvent->where.h != sLastGlobalLocation.h || macEvent->where.v != sLastGlobalLocation.v)
  1325.     {
  1326. sLastGlobalLocation = macEvent->where;
  1327. Point localPt = sLastGlobalLocation;
  1328. ::GlobalToLocal(&localPt);
  1330. m_MostRecentConvertedMouseLoc.x = localPt.h;
  1331. m_MostRecentConvertedMouseLoc.y = localPt.v;
  1333. UINT32 flags = 0;
  1334. if (macEvent->modifiers & shiftKey) flags += HX_SHIFT_KEY;
  1335. if (macEvent->modifiers & controlKey) flags += HX_CTRL_KEY;
  1336. if (macEvent->modifiers & cmdKey) flags += HX_ALT_COMMAND_KEY;
  1338. // don't change the event until we're done looking at it!
  1339. // (the pre-converted version that is.)
  1341. pEvent->event = HX_MOUSE_MOVE;
  1342. pEvent->param1 = (void*)&m_MostRecentConvertedMouseLoc;
  1343. pEvent->param2 = (void*)flags;
  1345. // This will eventually be handled by the base site.
  1346. // It's possible that the base site will need to translate
  1347. // this into HX_MOUSE_ENTER and HX_MOUSE_LEAVE first,
  1348. // though, which is why we don't simply handle it here.
  1350. SetOriginAndMaintainClipRgn(oldOrigin.h, oldOrigin.v);
  1351.     }
  1352. }
  1353. else
  1354. {
  1355.     SetOriginAndMaintainClipRgn(oldOrigin.h, oldOrigin.v);
  1356.     if (m_pTopLevelSite->m_pMouseInSite == this)
  1357.     {
  1358. m_pTopLevelSite->GenerateMouseLeaveMessage();
  1359.     }
  1360. }
  1363. ::SetPort(savePort);
  1364.     }
  1365. }
  1366.     }
  1367.     return FALSE; //pEvent->handled;
  1368. }
  1370. /************************************************************************
  1371.  *  Method:
  1372.  *    CHXMacSite::_GenerateOSEvent
  1373.  */
  1374. void
  1375. CHXMacSite::_GenerateOSEvent(HXxEvent* pEvent, HXxEvent* pEvent2)
  1376. {
  1377. }
  1379. /************************************************************************
  1380.  *  Method:
  1381.  *    CHXMacSite::_GenerateSetCursorEvent
  1382.  */
  1383. void
  1384. CHXMacSite::_GenerateSetCursorEvent()
  1385. {
  1386.     Point oldOrigin;
  1388.     HXxWindow* pWindow = GetWindow();
  1389.     if (!pWindow || !pWindow->window)
  1390.     {
  1391. return;
  1392.     }
  1394.     WindowPtr w = (WindowPtr)pWindow->window;
  1396.     GrafPtr savePort;
  1397.     ::GetPort(&savePort);
  1399. #if defined(_CARBON) || defined(_MAC_UNIX)
  1400.     ::SetPort(::GetWindowPort(w));
  1401. #else
  1402.     ::SetPort(w);
  1403. #endif
  1405. #if defined(_CARBON) || defined(_MAC_UNIX)
  1406.     Rect portRect;
  1407.     GetPortBounds( GetWindowPort( w ), &portRect );
  1408.     oldOrigin.h = portRect.left;
  1409.     oldOrigin.v = portRect.top;
  1410. #else
  1411.     oldOrigin.h = w->portRect.left;
  1412.     oldOrigin.v = w->portRect.top;
  1413. #endif
  1415.     SetOriginAndMaintainClipRgn(-pWindow->x, -pWindow->y);
  1417.     HXxPoint offset = {0,0};
  1418.     GetMacContentAreaOffset(offset);
  1420.     SetOriginAndMaintainClipRgn(-offset.x, -offset.y);
  1421.     
  1422.     Point location;
  1423.     GetMouse(&location);
  1425.     HXxEvent theEvent;
  1426.     memset(&theEvent, 0, sizeof(theEvent));
  1428.     theEvent.event = HX_MOUSE_MOVE;
  1429.     
  1430.     HXxPoint mouseLoc;
  1431.     mouseLoc.x = location.h;
  1432.     mouseLoc.y = location.v;
  1433.     theEvent.param1 = (void*)&mouseLoc;
  1434.     
  1435.     SetOriginAndMaintainClipRgn(oldOrigin.h, oldOrigin.v);
  1437.     if (m_pUser)
  1438. m_pUser->HandleEvent(&theEvent);
  1440.     ::SetPort(savePort);
  1441. }
  1444. void
  1445. CHXMacSite::_ScaleFullScreen(HXxWindow* pWindow)
  1446. {
  1447.     if (m_pParentSite != nil)
  1448.     {
  1449. CHXMacSite* pParentSite = (CHXMacSite*)m_pParentSite;
  1450. m_fStretchMultiple = pParentSite->m_fStretchMultiple;
  1451. m_pHXxFullScreenWindow->window = pParentSite->m_pHXxFullScreenWindow->window;
  1453. if (0 /*pParentSite->m_pStatusSite == this*/)
  1454. {
  1455. }
  1456. else
  1457. {
  1458.     if (m_pWindow) pWindow = m_pWindow;
  1459.     
  1460.     m_pHXxFullScreenWindow->x = (long)((double)pWindow->x * m_fStretchMultiple);
  1461.     m_pHXxFullScreenWindow->y = (long)((double)pWindow->y * m_fStretchMultiple);
  1462.     m_pHXxFullScreenWindow->width = (long)((double)pWindow->width * m_fStretchMultiple);
  1463.     m_pHXxFullScreenWindow->height = (long)((double)pWindow->height * m_fStretchMultiple);
  1464.     
  1465.     m_pHXxFullScreenWindow->clipRect.left = (long)((double)pWindow->clipRect.left * m_fStretchMultiple);
  1466.     m_pHXxFullScreenWindow->clipRect.top = (long)((double)pWindow->clipRect.top * m_fStretchMultiple);
  1467.     m_pHXxFullScreenWindow->clipRect.right = (long)((double)pWindow->clipRect.right * m_fStretchMultiple);
  1468.     m_pHXxFullScreenWindow->clipRect.bottom = (long)((double)pWindow->clipRect.bottom * m_fStretchMultiple);
  1469. }
  1470.     }
  1473.     CHXMapPtrToPtr::Iterator i = m_ChildrenMap.Begin();
  1474.     for ( ; i != m_ChildrenMap.End(); ++i)
  1475.     {
  1476. CHXBaseSite* pSite = (CHXBaseSite*) *i;
  1478. CHXMacSite* pMacSite = (CHXMacSite*)pSite;
  1479. pMacSite->_ScaleFullScreen(pWindow);
  1480.     }
  1481. }
  1483. /************************************************************************
  1484.  *  Method:
  1485.  *    CHXMacSite::_EnterFullScreen
  1486.  */
  1487. HX_RESULT
  1488. CHXMacSite::_EnterFullScreen()
  1489. {
  1490.     if (zm_bFullScreenActive)
  1491.     {
  1492. return HXR_UNEXPECTED;
  1493.     }
  1494.     
  1495.     zm_bFullScreenActive = TRUE;
  1496.     
  1497.     if (m_pTopLevelSite == this)
  1498.     {
  1499. short desiredWidth, desiredHeight;
  1501. GDHandle aGD = ::GetMainDevice();
  1503. // Check the UseOverlay preference here, since _OverlayAvailable() doesn't update its
  1504. // value on Preference changes.
  1505. BOOL bDoScreenResSwitch = FALSE;
  1506. IHXPreferences* pPreferences = NULL;
  1507. if (m_pContext && (HXR_OK == m_pContext->QueryInterface(IID_IHXPreferences, (void**)&pPreferences)))
  1508. {
  1509.     IHXBuffer* pBuffer = NULL;
  1510.     if (pPreferences->ReadPref("UseOverlay", pBuffer) == HXR_OK)
  1511.     {
  1512. bDoScreenResSwitch = ::atoi((char*)pBuffer->GetBuffer()) != 1;
  1513.     }
  1514.     HX_RELEASE(pBuffer);
  1515. }
  1516. HX_RELEASE(pPreferences);
  1518. if (!bDoScreenResSwitch)
  1519. {
  1520.     // if an overlay exists then let's assume we don't have
  1521.     // to switch resolutions.
  1522.     desiredWidth = (**aGD).gdRect.right - (**aGD).gdRect.left;
  1523.     desiredHeight = (**aGD).gdRect.bottom - (**aGD).gdRect.top;
  1524. }
  1525. else
  1526. {
  1527.     desiredWidth = m_size.cx;
  1528.     desiredHeight = m_size.cy;
  1529. }
  1531. ::BeginFullScreen(
  1532. &zm_pRememberFullScreenInformation,
  1533. ::GetMainDevice(),
  1534. &desiredWidth,
  1535. &desiredHeight,
  1536. nil,
  1537. nil,
  1538. fullScreenAllowEvents );
  1540. _DestroySliders();
  1542. CMacRootSurface::VisRgnChangedCallback();
  1544. GDHandle mainGD = ::GetMainDevice();
  1545. Rect bounds = (**mainGD).gdRect;
  1547. if (m_pHXxFullScreenWindow && m_pHXxFullScreenWindow->window)
  1548. {
  1549.     WindowPtr w = (WindowPtr)m_pHXxFullScreenWindow->window;
  1550.     ::ShowWindow(w);
  1551.     ::SizeWindow(w, bounds.right-bounds.left, bounds.bottom-bounds.top, true);
  1552.     ::MoveWindow(w, bounds.left, bounds.top, true);
  1553.     
  1554.     HXxPoint newPosition;
  1555.     newPosition.x = bounds.left;
  1556.     newPosition.y = bounds.top;
  1557.     
  1558.     HXxSize newSize;
  1559.     newSize.cx = bounds.right-bounds.left;
  1560.     newSize.cy = bounds.bottom-bounds.top;
  1561.     
  1562.     double theXZoomFactor = (double)newSize.cx / (double)m_pWindow->width;
  1563.     double theYZoomFactor = (double)newSize.cy / (double)m_pWindow->height;
  1564.     
  1565.     if (theXZoomFactor < theYZoomFactor)
  1566.     {
  1567. theYZoomFactor = theXZoomFactor;
  1568. newSize.cy = (long)((double)m_pWindow->height * theYZoomFactor);
  1570. newPosition.y += ((bounds.bottom-bounds.top)-newSize.cy)/2;
  1571.     }
  1572.     else
  1573.     {
  1574. theXZoomFactor = theYZoomFactor;
  1575. newSize.cx = (long)((double)m_pWindow->width * theXZoomFactor);
  1577. newPosition.x += ((bounds.right-bounds.left)-newSize.cx)/2;
  1578.     }
  1579.     m_fStretchMultiple = theXZoomFactor;
  1580.     
  1581.     m_pHXxFullScreenWindow->x = newPosition.x;
  1582.     m_pHXxFullScreenWindow->y = newPosition.y;
  1583.     
  1584.     m_pHXxFullScreenWindow->width = newSize.cx;
  1585.     m_pHXxFullScreenWindow->height = newSize.cy;
  1586.     
  1587.     m_pHXxFullScreenWindow->clipRect.left = newPosition.x;
  1588.     m_pHXxFullScreenWindow->clipRect.top = newPosition.y;
  1589.     m_pHXxFullScreenWindow->clipRect.right = newPosition.x + newSize.cx;
  1590.     m_pHXxFullScreenWindow->clipRect.bottom = newPosition.y + newSize.cy;
  1591.     
  1592. #if defined(_CARBON) || defined(_MAC_UNIX)
  1593.     ::SetPort( GetWindowPort( (WindowPtr)m_pHXxFullScreenWindow->window ) );
  1594. #else
  1595.     ::SetPort((WindowPtr)m_pHXxFullScreenWindow->window);
  1596. #endif
  1597.     RGBColor holdRGB;
  1598.     RGBColor theRGB = {0x0000, 0x0000, 0x0000};
  1599.     ::GetBackColor(&holdRGB);
  1600.     ::RGBBackColor(&theRGB);
  1601.     ::EraseRect(&bounds);
  1602.     ::RGBBackColor(&holdRGB);
  1603.     
  1604.     if (m_bInternalResizeOnFullscreen)
  1605.     {
  1606. GetSize(m_RememberNonFullscreenSize);
  1607. GetPosition(m_RememberNonFullscreenPosition);
  1608. m_pTopLevelSite->m_bDisableForceRedraw = TRUE;
  1609. SetSize(newSize);
  1610. m_pTopLevelSite->m_bDisableForceRedraw = FALSE;
  1611. SetPosition(newPosition);
  1612.     }
  1613.     else
  1614.     {
  1615. _ScaleFullScreen(m_pWindow);
  1616.     }
  1618.     SetOriginAndMaintainClipRgn(-m_pHXxFullScreenWindow->x, -m_pHXxFullScreenWindow->y);
  1619. }
  1620. m_bInFullScreen = TRUE;
  1621.     }
  1622.     
  1623.     return HXR_OK;
  1624. }
  1626. /************************************************************************
  1627.  *  Method:
  1628.  *    CHXMacSite::_ExitFullScreen
  1629.  */
  1630. HX_RESULT
  1631. CHXMacSite::_ExitFullScreen()
  1632. {
  1633.     CMacRootSurface::VisRgnChangedCallback();
  1634.     if (m_pTopLevelSite == this)
  1635.     {
  1636. m_bInFullScreen = FALSE;
  1637. _DestroySliders();
  1639. if (m_pHXxFullScreenWindow && m_pHXxFullScreenWindow->window)
  1640. {
  1641.     WindowPtr w = (WindowPtr)m_pHXxFullScreenWindow->window;
  1642.     GrafPtr savePort;
  1643.     ::GetPort(&savePort);
  1644.     ::SetPort(::GetWindowPort(w));
  1645.     // we need to restore the origin for the next time we may
  1646.     // enter fullscreen mode. xxxbobclark
  1647.     SetOriginAndMaintainClipRgn(0,0);
  1648.     ::HideWindow(w);
  1649.     ::SetPort(savePort);
  1650. }
  1652. if (!m_bInternalResizeOnFullscreen)
  1653. {
  1654.     HXxSize fullscreenSize;
  1656.     fullscreenSize.cx = m_pHXxFullScreenWindow->width;
  1657.     fullscreenSize.cy = m_pHXxFullScreenWindow->height;
  1659.     HXxSize nonfullscreenSize;
  1661.     nonfullscreenSize.cx = (long)((double)fullscreenSize.cx / m_fStretchMultiple);
  1662.     nonfullscreenSize.cy = (long)((double)fullscreenSize.cy / m_fStretchMultiple);
  1664.     if (m_pWatcher)
  1665.     {
  1666. HRESULT hres = m_pWatcher->ChangingSize(fullscreenSize, nonfullscreenSize);
  1667.     }
  1668. }
  1670. ::EndFullScreen(zm_pRememberFullScreenInformation, nil);
  1672.     }
  1673.     
  1674.     if (CMacSurface::zm_pOverlaySurface == (CMacSurface*)m_pVideoSurface)
  1675.     {
  1676. CMacSurface::CleanUpOverlay();
  1677. CMacSurface::zm_pOverlaySurface = nil;
  1678.     }
  1679.     zm_bFullScreenActive = FALSE;
  1681.     if (m_pTopLevelSite == this)
  1682.     {
  1683. if (m_bInternalResizeOnFullscreen)
  1684. {
  1685.     m_pTopLevelSite->m_bDisableForceRedraw = TRUE;
  1686.     SetSize(m_RememberNonFullscreenSize);
  1687.     m_pTopLevelSite->m_bDisableForceRedraw = FALSE;
  1688.     SetPosition(m_RememberNonFullscreenPosition);
  1689. }
  1690.     }
  1691.     
  1692.     return HXR_OK;
  1693. }
  1695. /************************************************************************
  1696.  *  Method:
  1697.  *    CHXMacSite::_TestFullScreen
  1698.  */
  1699. HX_RESULT
  1700. CHXMacSite::_TestFullScreen(void* hTestBitmap, const char* pszStatusText)
  1701. {
  1702.     return HXR_OK;
  1703. }
  1705. /************************************************************************
  1706.  *  Method:
  1707.  *    CHXMacSite::_TryCreateXSlider
  1708.  */
  1709. void
  1710. CHXMacSite::_TryCreateXSlider()
  1711. {
  1712.     if (!IsSiteVisible())
  1713.     {
  1714. return;
  1715.     }
  1716.     
  1717.     HXxWindow* pWindow = GetWindow();
  1718.     if (!pWindow || !pWindow->window)
  1719.     {
  1720. return;
  1721.     }
  1722.     
  1723.     WindowPtr w = (WindowPtr)pWindow->window;
  1724.     
  1725.     GrafPtr savePort;
  1726.     ::GetPort(&savePort);
  1727.     ::SetPort(::GetWindowPort(w));
  1728.     
  1729.     Point oldOrigin;
  1730.     Rect portRect;
  1731.     ::GetPortBounds(::GetWindowPort(w), &portRect);
  1732.     oldOrigin.h = portRect.left;
  1733.     oldOrigin.v = portRect.top;
  1734.     
  1735.     SetOriginAndMaintainClipRgn(0,0); // scroll bar maintenance requires origin at 0,0.
  1736.     
  1737.     HXxPoint offset = {0,0};
  1738.     GetMacContentAreaOffset(offset);
  1739.     
  1740.     HXxPoint position;
  1741.     HXxSize size;
  1742.     
  1743.     HX_ASSERT(GetParentSite());
  1744.     
  1745.     if (GetParentSite())
  1746.     {
  1747. GetParentSite()->GetSize(size);
  1748. position.x = 0;
  1749. position.y = 0;
  1750.     }
  1751.     
  1752.     Rect controlRect;
  1753.     controlRect.left = position.x + offset.x;
  1754.     controlRect.top = position.y + offset.y + size.cy - SCROLL_BAR_WIDTH;
  1755.     controlRect.right = controlRect.left + size.cx;
  1756.     controlRect.bottom = controlRect.top + SCROLL_BAR_WIDTH;
  1757.     
  1758.     if (m_hHScrollBar && ::GetControlOwner(m_hHScrollBar) != w)
  1759.     {
  1760. ::DisposeControl(m_hHScrollBar);
  1761. m_hHScrollBar = NULL;
  1762. m_XSliderPos = 0;
  1763.     }
  1764.     
  1765.     if (m_hHScrollBar)
  1766.     {
  1767. // if it already exists, then we may simply need to
  1768. // move it...
  1769. Rect oldControlRect;
  1770. ::GetControlBounds(m_hHScrollBar, &oldControlRect);
  1772. if (!::EqualRect(&oldControlRect, &controlRect))
  1773. {
  1774.     ::SetControlBounds(m_hHScrollBar, &controlRect);
  1775.     ::InvalWindowRect(w, &oldControlRect);
  1776. }
  1777.     }
  1778.     else
  1779.     {
  1780. ::CreateScrollBarControl(w, &controlRect, 0, 0, 2, 1, false, NULL, &m_hHScrollBar);
  1781. ::SetControlReference(m_hHScrollBar, 0);
  1782.     }
  1783.     
  1784.     // invaling the rect seems to ameliorate this problem where extra scrollbars
  1785.     // were being spuriously displayed.
  1786.     ::InvalWindowRect(w, &controlRect);
  1787.     
  1788.     SetOriginAndMaintainClipRgn(oldOrigin.h, oldOrigin.v);
  1789.     ::SetPort(savePort);
  1790. }
  1792. /************************************************************************
  1793.  *  Method:
  1794.  *    CHXMacSite::_SetXSliderValues
  1795.  */
  1796. void
  1797. CHXMacSite::_SetXSliderValues(INT32 range, INT32 pageSize)
  1798. {
  1799.     HXxWindow* pWindow = GetWindow();
  1800.     if (!pWindow || !pWindow->window)
  1801.     {
  1802. return;
  1803.     }
  1804.     
  1805.     WindowPtr w = (WindowPtr)pWindow->window;
  1806.     
  1807.     Point oldOrigin;
  1808.     Rect portRect;
  1809.     ::GetPortBounds(::GetWindowPort(w), &portRect);
  1810.     oldOrigin.h = portRect.left;
  1811.     oldOrigin.v = portRect.top;
  1812.     
  1813.     SetOriginAndMaintainClipRgn(0,0);
  1814.     
  1815.     ::SetControl32BitMinimum(m_hHScrollBar, 0);
  1816.     ::SetControl32BitMaximum(m_hHScrollBar, range - pageSize);
  1817.     ::SetControlViewSize(m_hHScrollBar, pageSize);
  1818.     
  1819.     ::SetControl32BitValue(m_hHScrollBar, m_XSliderPos);
  1820.     
  1821.     m_nHorizPageSize = pageSize / 2;
  1822.     
  1823.     SetOriginAndMaintainClipRgn(oldOrigin.h, oldOrigin.v);
  1824.     SetMacControlRange(m_hHScrollBar, range);
  1825.     
  1826.     m_nHorizPageSize = pageSize;
  1827. }
  1829. /************************************************************************
  1830.  *  Method:
  1831.  *    CHXMacSite::_TryCreateYSlider
  1832.  */
  1833. void
  1834. CHXMacSite::_TryCreateYSlider()
  1835. {
  1836.     if (!IsSiteVisible())
  1837.     {
  1838. return;
  1839.     }
  1840.     
  1841.     HXxWindow* pWindow = GetWindow();
  1842.     if (!pWindow || !pWindow->window)
  1843.     {
  1844. return;
  1845.     }
  1846.     
  1847.     WindowPtr w = (WindowPtr)pWindow->window;
  1848.     
  1849.     GrafPtr savePort;
  1850.     ::GetPort(&savePort);
  1851.     ::SetPort(::GetWindowPort(w));
  1852.     
  1853.     Point oldOrigin;
  1854.     Rect portRect;
  1855.     ::GetPortBounds(::GetWindowPort(w), &portRect);
  1856.     oldOrigin.h = portRect.left;
  1857.     oldOrigin.v = portRect.top;
  1858.     
  1859.     HXxPoint offset = {0,0};
  1860.     GetMacContentAreaOffset(offset);
  1861.     
  1862.     SetOriginAndMaintainClipRgn(0,0);
  1863.     
  1864.     HXxPoint position;
  1865.     HXxSize size;
  1866.     
  1867.     HX_ASSERT(GetParentSite());
  1868.     
  1869.     if (GetParentSite())
  1870.     {
  1871. GetParentSite()->GetSize(size);
  1873. position.x = 0;
  1874. position.y = 0;
  1875.     }
  1876.     
  1877.     Rect controlRect;
  1878.     controlRect.left = position.x + offset.x + size.cx - SCROLL_BAR_WIDTH;
  1879.     controlRect.top = position.y + offset.y;
  1880.     controlRect.right = controlRect.left + SCROLL_BAR_WIDTH;
  1881.     controlRect.bottom = controlRect.top + size.cy;
  1882.     
  1883.     if (_DoesXSliderExist())
  1884.     {
  1885. controlRect.bottom -= SCROLL_BAR_WIDTH; // ensure that both scroll bars don't overlap at the bottom right corner
  1886.     }
  1887.     
  1888.     if (m_hVScrollBar && ::GetControlOwner(m_hVScrollBar) != w)
  1889.     {
  1890. ::DisposeControl(m_hVScrollBar);
  1891. m_hVScrollBar = NULL;
  1892. m_YSliderPos = 0;
  1893.     }
  1894.     
  1895.     if (m_hVScrollBar)
  1896.     {
  1897. Rect oldControlRect;
  1898. ::GetControlBounds(m_hVScrollBar, &oldControlRect);
  1900. if (!::EqualRect(&oldControlRect, &controlRect))
  1901. {
  1902.     ::SetControlBounds(m_hVScrollBar, &controlRect);
  1903.     ::InvalWindowRect(w, &oldControlRect);
  1904. }
  1905.     }
  1906.     else
  1907.     {
  1908. ::CreateScrollBarControl(w, &controlRect, 0, 0, 2, 1, false, NULL, &m_hVScrollBar);
  1909. ::SetControlReference(m_hVScrollBar, 0);
  1910.     }
  1911.     
  1912.     ::InvalWindowRect(w, &controlRect);
  1913.     
  1914.     SetOriginAndMaintainClipRgn(oldOrigin.h, oldOrigin.v);
  1915.     ::SetPort(savePort);
  1916. }
  1918. /************************************************************************
  1919.  *  Method:
  1920.  *    CHXMacSite::_SetYSliderValues
  1921.  */
  1922. void
  1923. CHXMacSite::_SetYSliderValues(INT32 range, INT32 pageSize)
  1924. {
  1925.     HXxWindow* pWindow = GetWindow();
  1926.     if (!pWindow || !pWindow->window)
  1927.     {
  1928. return;
  1929.     }
  1930.     
  1931.     WindowPtr w = (WindowPtr)pWindow->window;
  1932.     
  1933.     Point oldOrigin;
  1934.     Rect portRect;
  1935.     ::GetPortBounds(::GetWindowPort(w), &portRect);
  1936.     oldOrigin.h = portRect.left;
  1937.     oldOrigin.v = portRect.top;
  1938.     
  1939.     SetOriginAndMaintainClipRgn(0,0);
  1940.     
  1941.     ::SetControl32BitMinimum(m_hVScrollBar, 0);
  1942.     ::SetControl32BitMaximum(m_hVScrollBar, range-pageSize);
  1943.     ::SetControlViewSize(m_hVScrollBar, pageSize);
  1944.     
  1945.     ::SetControl32BitValue(m_hVScrollBar, m_YSliderPos);
  1946.     
  1947.     m_nVertPageSize = pageSize / 2;
  1948.     
  1949.     SetOriginAndMaintainClipRgn(oldOrigin.h, oldOrigin.v);
  1950. }
  1952. /************************************************************************
  1953.  *  Method:
  1954.  *    CHXMacSite::_GetSystemSizeOfSliders
  1955.  */
  1956. void
  1957. CHXMacSite::_GetSystemSizeOfSliders(INT32* pWidth, INT32* pHeight)
  1958. {
  1959.     if (pWidth) *pWidth = SCROLL_BAR_WIDTH;
  1960.     if (pHeight) *pHeight = SCROLL_BAR_WIDTH;
  1961. }
  1963. /************************************************************************
  1964.  *  Method:
  1965.  *    CHXMacSite::_IsWindowVisible
  1966.  */
  1967. BOOL
  1968. CHXMacSite::_IsWindowVisible()
  1969. {
  1970.     return TRUE;
  1971. }
  1973. /************************************************************************
  1974.  *  Method:
  1975.  *    CHXMacSite::ShowMacControl
  1976.  */
  1977. void
  1978. CHXMacSite::ShowMacControl(ControlHandle theControl, BOOL bShow)
  1979. {
  1980.     if (theControl)
  1981.     {
  1982. if (bShow)
  1983. {
  1984.     ::ShowControl(theControl);
  1985. }
  1986. else
  1987. {
  1988.     ::HideControl(theControl);
  1989. }
  1990.     }
  1991. }
  1993. /************************************************************************
  1994.  *  Method:
  1995.  *    CHXMacSite::SetMacControlRectangle
  1996.  */
  1997. void
  1998. CHXMacSite::SetMacControlRectangle(ControlHandle theControl,
  1999. INT32 left, INT32 top, INT32 right, INT32 bottom )
  2000. {
  2001.     if (theControl)
  2002.     {
  2003. ::SizeControl(theControl, right-left, bottom-top);
  2004. ::MoveControl(theControl, left, top);
  2005.     }
  2006. }
  2008. void
  2009. CHXMacSite::SetMacControlRange(ControlHandle theControl, INT32 controlMax)
  2010. {
  2011.     if (theControl)
  2012.     {
  2013. // XXX bobclark
  2014. // Important note: The MacOS scroll bars only use 16-bit integers,
  2015. // while the Core uses 32-bit integers here. If 16 bits isn't enough,
  2016. // we'll have to do a lot more work by hand, like storing the "real"
  2017. // value in a separate variable, and scaling from 16-bit to 32-bit
  2018. // values whenever the scroll bar's thumb is dragged. For clicking on
  2019. // the scroll bar's arrows or paging around, we could compute that
  2020. // directly using the long but we'd need to scale it back to a short
  2021. // so the scroll bar would correctly reflect its approximation of the
  2022. // value.
  2023. // I don't think this will be an issue, since we're scrolling around
  2024. // a site, and a site that's more than 32000 pixels wide is ludicrous.
  2026. HX_ASSERT(controlMax >= 0 && controlMax < 32000);
  2028. SetControlMinimum(theControl, 0);
  2029. SetControlMaximum(theControl, (short)controlMax);
  2030.     }
  2031. }
  2034. /************************************************************************
  2035.  *  Method:
  2036.  *    CHXMacSite::_ShowXSlider
  2037.  */
  2038. void
  2039. CHXMacSite::_ShowXSlider(BOOL bShow)
  2040. {
  2041.     HXxWindow* pWindow = GetWindow();
  2042.     if (!pWindow || !pWindow->window)
  2043.     {
  2044. return;
  2045.     }
  2046.     WindowPtr w = (WindowPtr)pWindow->window;
  2047.     Point oldOrigin;
  2048.     Rect portRect;
  2049.     ::GetPortBounds( ::GetWindowPort(w), &portRect);
  2050.     oldOrigin.h = portRect.left;
  2051.     oldOrigin.v = portRect.top;
  2052.     
  2053.     SetOriginAndMaintainClipRgn(0,0);
  2054.     
  2055.     ShowMacControl(m_hHScrollBar, bShow);
  2056.     
  2057.     SetOriginAndMaintainClipRgn(oldOrigin.h, oldOrigin.v);
  2058. }
  2060. /************************************************************************
  2061.  *  Method:
  2062.  *    CHXMacSite::_MoveXSlider
  2063.  */
  2064. void
  2065. CHXMacSite::_MoveXSlider(INT32 left, INT32 top, INT32 right, INT32 bottom, BOOL bRedraw)
  2066. {
  2067.     // xxxbobclark do nothing right now
  2068. }
  2070. /************************************************************************
  2071.  *  Method:
  2072.  *    CHXMacSite::_ShowYSlider
  2073.  */
  2074. void
  2075. CHXMacSite::_ShowYSlider(BOOL bShow)
  2076. {
  2077.     HXxWindow* pWindow = GetWindow();
  2078.     if (!pWindow || !pWindow->window)
  2079.     {
  2080. return;
  2081.     }
  2082.     WindowPtr w = (WindowPtr)pWindow->window;
  2083.     Point oldOrigin;
  2084.     Rect portRect;
  2085.     ::GetPortBounds(::GetWindowPort(w), &portRect);
  2086.     oldOrigin.h = portRect.left;
  2087.     oldOrigin.v = portRect.top;
  2088.     
  2089.     SetOriginAndMaintainClipRgn(0,0);
  2090.     
  2091.     ShowMacControl(m_hVScrollBar, bShow);
  2092.     
  2093.     SetOriginAndMaintainClipRgn(oldOrigin.h, oldOrigin.v);
  2094. }
  2096. /************************************************************************
  2097.  *  Method:
  2098.  *    CHXMacSite::_MoveYSlider
  2099.  */
  2100. void
  2101. CHXMacSite::_MoveYSlider(INT32 left, INT32 top, INT32 right, INT32 bottom, BOOL bRedraw)
  2102. {
  2103.     // xxxbobclark don't do anything right now
  2104. }
  2106. /************************************************************************
  2107.  *  Method:
  2108.  *    CHXMacSite::_DoesXSliderExist
  2109.  */
  2110. BOOL
  2111. CHXMacSite::_DoesXSliderExist()
  2112. {
  2113.     if (m_hHScrollBar) return TRUE;
  2114.     return FALSE;
  2115. }
  2117. /************************************************************************
  2118.  *  Method:
  2119.  *    CHXMacSite::_GetContainingWindow
  2120.  */
  2121. void*
  2122. CHXMacSite::_GetContainingWindow()
  2123. {
  2124.     if (m_pParentSite) return m_pParentSite->_GetContainingWindow();
  2125.     return NULL;
  2126. }
  2128. /************************************************************************
  2129.  *  Method:
  2130.  *    CHXMacSite::_GetCursorPos
  2131.  */
  2132. void
  2133. CHXMacSite::_GetCursorPos(HXxPoint* pPoint)
  2134. {
  2135.     // this will return in global coordinates. (???)
  2137.     HX_ASSERT(_AtSystemTime());
  2138.     if (!_AtSystemTime()) return;
  2139.     
  2140.     HX_ASSERT(pPoint);
  2141.     if (!pPoint) return;
  2142.     
  2143.     Point pt;
  2144.     ::GetMouse(&pt);
  2145.     // pt is in local coordinates
  2146.     
  2147.     ::LocalToGlobal(&pt);
  2148.     
  2149.     pPoint->x = pt.h;
  2150.     pPoint->y = pt.v;
  2151. }
  2153. /************************************************************************
  2154.  *  Method:
  2155.  *    CHXMacSite::_MapPointToOSWindow
  2156.  */
  2157. void
  2158. CHXMacSite::_MapPointToOSWindow(HXxPoint* pPt, void** pWindowHandle)
  2159. {
  2160. }
  2162. /************************************************************************
  2163.  *  Method:
  2164.  *    CHXMacSite::_GetWindowWithCursor
  2165.  */
  2166. void*
  2167. CHXMacSite::_GetWindowWithCursor()
  2168. {
  2169.     return NULL;
  2170. }
  2172. /************************************************************************
  2173.  *  Method:
  2174.  *    CHXMacSite::_ReInitPrimarySurface
  2175.  */
  2176. void
  2177. CHXMacSite::_ReInitPrimarySurface()
  2178. {
  2179. }
  2181. /************************************************************************
  2182.  *  Method:
  2183.  *    CHXMacSite::_MoveWindow
  2184.  */
  2185. BOOL
  2186. CHXMacSite::_MoveWindow(void* window, INT32 X, INT32 Y, INT32 nWidth, INT32 nHeight, BOOL bRepaint)
  2187. {
  2188.     return TRUE;
  2189. }
  2191. /************************************************************************
  2192.  *  Method:
  2193.  *    CHXMacSite::_UpdateWindow
  2194.  */
  2195. BOOL
  2196. CHXMacSite::_UpdateWindow(void* hWnd)
  2197. {
  2198.     return TRUE;
  2199. }
  2201. /************************************************************************
  2202.  *  Method:
  2203.  *    CHXMacSite::_ShowWindow
  2204.  */
  2205. BOOL
  2206. CHXMacSite::_ShowWindow(void* hWnd, INT32 nCmdShow)
  2207. {
  2208.     return TRUE;
  2209. }
  2211. /************************************************************************
  2212.  *  Method:
  2213.  *    CHXMacSite::_SetWindowPos
  2214.  */
  2215. BOOL
  2216. CHXMacSite::_SetWindowPos(void* hWnd, void* hWndInsertAfter, INT32 X, INT32 Y, INT32 cx, INT32 cy, INT32 uFlags)
  2217. {
  2218.     return TRUE;
  2219. }
  2221. /************************************************************************
  2222.  *  Method:
  2223.  *    CHXMacSite::_SetWindowRgn
  2224.  */
  2225. BOOL
  2226. CHXMacSite::_SetWindowRgn(void* hWnd, HXREGION* hRgn, BOOL bRedraw)
  2227. {
  2228.     return TRUE;
  2229. }
  2231. /************************************************************************
  2232.  *  Method:
  2233.  *    CHXMacSite::_SetFocus
  2234.  */
  2235. void
  2236. CHXMacSite::_SetFocus(void* pWindow)
  2237. {
  2238. }
  2241. /************************************************************************
  2242.  *  Method:
  2243.  *    CHXMacSite::GetMacContentAreaOffset
  2244.  */
  2245. void
  2246. CHXMacSite::GetMacContentAreaOffset(REF(HXxPoint)offset)
  2247. {
  2248.     offset.x = m_topleft.x;
  2249.     offset.y = m_topleft.y;
  2250.     
  2251.     HXxWindow* pWindow = GetWindow();
  2252.     
  2253.     if (pWindow)
  2254.     {
  2255. offset.x += pWindow->x;
  2256. offset.y += pWindow->y;
  2257.     }
  2258.     
  2259.     return;
  2260. }
  2263. #pragma export on
  2265. extern "C" void MacSiteHandleAllEvents(HXxEvent* pEvent)
  2266. {
  2267.     CHXMacSite::_HandleAllOSEvents(pEvent);
  2268. }
  2270. #pragma export off
  2273. /************************************************************************
  2274.  *  Callback implementation
  2275.  */
  2277. /************************************************************************
  2278.  *  Method:
  2279.  *    CHXMacSite::MacSiteRedrawCallback ctor
  2280.  */
  2282. CHXMacSite::MacSiteRedrawCallback::MacSiteRedrawCallback(CHXMacSite* pMacSite)
  2283.  : m_lRefCount(0)
  2284.  , m_ulMacSiteRedrawCallbackPendingID(0)
  2285.  , m_pMacSite(pMacSite)
  2286. {
  2287. }
  2289. /************************************************************************
  2290.  *  Method:
  2291.  *    CHXMacSite::MacSiteRedrawCallback dtor
  2292.  */
  2294. CHXMacSite::MacSiteRedrawCallback::~MacSiteRedrawCallback()
  2295. {
  2296. }
  2298. /************************************************************************
  2299.  *  Method:
  2300.  *    CHXMacSite::MacSiteRedrawCallback::QueryInterface
  2301.  */
  2303. STDMETHODIMP
  2304. CHXMacSite::MacSiteRedrawCallback::QueryInterface(REFIID riid, void** ppvObj)
  2305. {
  2306.     if (IsEqualIID(riid, IID_IHXCallback))
  2307.     {
  2308. AddRef();
  2309. *ppvObj = (IHXCallback*)this;
  2310. return HXR_OK;
  2311.     }
  2312.     else if (IsEqualIID(riid, IID_IUnknown))
  2313.     {
  2314.         AddRef();
  2315.         *ppvObj = this;
  2316.         return HXR_OK;
  2317.     }
  2319.     *ppvObj = NULL;
  2320.     return HXR_NOINTERFACE;
  2321. }
  2323. /************************************************************************
  2324.  *  Method:
  2325.  *    CHXMacSite::MacSiteRedrawCallback::AddRef
  2326.  */
  2328. STDMETHODIMP_(ULONG32)
  2329. CHXMacSite::MacSiteRedrawCallback::AddRef()
  2330. {
  2331.     return InterlockedIncrement( &m_lRefCount );
  2332. }
  2334. /************************************************************************
  2335.  *  Method:
  2336.  *    CHXMacSite::MacSiteRedrawCallback::Release
  2337.  */
  2339. STDMETHODIMP_(ULONG32)
  2340. CHXMacSite::MacSiteRedrawCallback::Release()
  2341. {
  2342.     if ( InterlockedDecrement( &m_lRefCount ) > 0 )
  2343.     {
  2344. return m_lRefCount;
  2345.     }
  2346.     
  2347.     delete this;
  2348.     return 0;
  2349. }
  2351. /************************************************************************
  2352.  *  Method:
  2353.  *    CHXMacSite::MacSiteRedrawCallback::Func
  2354.  */
  2356. STDMETHODIMP
  2357. CHXMacSite::MacSiteRedrawCallback::Func()
  2358. {
  2359.     m_pMacSite->_TLSLock();
  2360.     
  2361.     m_ulMacSiteRedrawCallbackPendingID = NULL;
  2362.     m_pMacSite->ForceRedraw();
  2363.     
  2364.     m_pMacSite->_TLSUnlock();
  2365.     
  2366.     return HXR_OK;
  2367. }
  2370. #ifdef THREADS_SUPPORTED
  2372. #ifdef USE_CARBON_TIMER
  2373. /************************************************************************
  2374.  *  Method:
  2375.  *    CHXMacSite::Redraw(something)Timer
  2376.  */
  2378. /*static*/
  2379. #ifdef _MAC_MACHO
  2380. void CHXMacSite::RedrawCFTimer(CFRunLoopTimerRef, CHXMacSite* pMacSite)
  2381. #else
  2382. void CHXMacSite::RedrawCarbonTimer(EventLoopTimerRef, CHXMacSite* pMacSite)
  2383. #endif
  2384. {
  2385.     // XXXMEH
  2386.     MLOG_BLT(NULL,
  2387.              "%lut----macsite.cpp--- RedrawCarbonTimer()n",
  2388.              HX_GET_BETTERTICKCOUNT());
  2389.     HX_ASSERT( pMacSite );
  2391.     HX_ASSERT(IsMacInCooperativeThread());
  2393.     if (pMacSite->m_pIHXCoreMutex) pMacSite->m_pIHXCoreMutex->LockCoreMutex();
  2394.     
  2395.     // this huge block of code is adapted from the base site's implementation of
  2396.     // InternalScheduleUpgrade, where it needs to match up an IHXPlayer with this
  2397.     // site. In this case, we're protecting ourselves against rug-pulling, i.e.
  2398.     // if a stream has ended and stuff has been deleted, it's still possible (due
  2399.     // to the Carbon Timer's behavior of delaying redraws) that there's a pending
  2400.     // ForceRedraw() that wants to happen. If there's no player for this site, or
  2401.     // if the player is done, then we'll omit the blit.
  2402.     
  2403.     // On a one-gigahertz processor, this checking function is taking
  2404.     // between 20 and 30 microseconds; it may be worthwhile to save the
  2405.     // player in a member variable.
  2406.     
  2407.     bool bPlayerStillRunning = false;
  2408.     
  2409.     IHXPreferences* pPreferences = NULL;
  2410.     IHXBuffer* pBuffer = NULL;
  2411.     
  2412.     IHXClientEngine* pClientEngine = NULL;
  2413.     if (HXR_OK == pMacSite->m_pContext->QueryInterface(IID_IHXClientEngine, (void**)&pClientEngine))
  2414.     {
  2415.         UINT16 nPlayerCount = pClientEngine->GetPlayerCount();
  2416.         IUnknown* pUnknown = NULL;
  2417.         
  2418.         if (nPlayerCount == 1)
  2419.         {
  2420.             // wow, this was easy -- this is the only player then.
  2421.             pClientEngine->GetPlayer(0, pUnknown);
  2422.         }
  2423.         else
  2424.         {
  2425.             IHXSite* pThisSite = NULL;
  2426.             
  2427.             pMacSite->QueryInterface(IID_IHXSite, (void**)&pThisSite);
  2428.             HX_ASSERT(pThisSite);
  2429.             
  2430.             UINT16 index;
  2431.             for (index = 0; index < nPlayerCount; index++)
  2432.             {
  2433.                 IHXSiteManager2* pSiteMgr2 = NULL;
  2434.                 IUnknown* pUnknownPlayer = NULL;
  2435.                 
  2436.                 pClientEngine->GetPlayer(index, pUnknownPlayer);
  2437.                 HX_ASSERT(pUnknownPlayer);
  2438.                 
  2439.                 pUnknownPlayer->QueryInterface(IID_IHXSiteManager2, (void**)&pSiteMgr2);
  2440.                 if (pSiteMgr2)
  2441.                 {
  2442.                     UINT32 nNumSites;
  2443.                     pSiteMgr2->GetNumberOfSites(nNumSites);
  2444.                     UINT32 index2;
  2445.                     for (index2 = 0; index2 < nNumSites; index2++)
  2446.                     {
  2447.                         IHXSite* pIterationSite = NULL;
  2448.                         pSiteMgr2->GetSiteAt(index2, pIterationSite);
  2449.                         if (pThisSite == pIterationSite)
  2450.                         {
  2451.                             // it matches!
  2452.                             HX_ASSERT(pUnknown == NULL);
  2453.                             pUnknown = pUnknownPlayer;
  2454.                             pUnknown->AddRef();
  2455.                         }
  2456.                     }
  2457.                     HX_RELEASE(pSiteMgr2);
  2458.                 }
  2459.                 HX_RELEASE(pUnknownPlayer);
  2460.             }
  2461.             
  2462.             HX_RELEASE(pThisSite);
  2463.         }
  2464.         
  2465.         if (pUnknown)
  2466.         {
  2467.             IHXPlayer* pPlayer;
  2468.             
  2469.             pUnknown->QueryInterface(IID_IHXPlayer, (void**)&pPlayer);
  2470.             if (pPlayer)
  2471.             {
  2472.                 if (!pPlayer->IsDone())
  2473.                 {
  2474.                     bPlayerStillRunning = true;
  2475.                 }
  2476.                 HX_RELEASE(pPlayer);
  2477.             }
  2478.             HX_RELEASE(pUnknown);
  2479.         }
  2480.         
  2481.         HX_RELEASE(pClientEngine);
  2482.     }
  2483.     
  2484.     if (bPlayerStillRunning)
  2485.     {
  2486.         pMacSite->ForceRedraw();
  2487.     }
  2488.     
  2489.     if (pMacSite->m_pIHXCoreMutex) pMacSite->m_pIHXCoreMutex->UnlockCoreMutex();
  2490. }
  2491. #endif
  2492. #endif