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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
macsite.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：64k
源码类别：

Symbian

开发平台：

Visual C++

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