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

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

Symbian

开发平台：

C/C++

hxmisus.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. #include "hxcom.h"
  37. #include "hxtypes.h"
  38. #include "hxwintyp.h"
  39. #include "hxslist.h"
  40. #include "hxwin.h"
  41. #include "hxengin.h"
  42. #include "hxsite2.h"
  43. #include "ihxpckts.h"
  44. #include "hxvsurf.h"
  45. #include "hxmisus.h"
  47. #include "hxheap.h"
  48. #ifdef _DEBUG
  49. #undef HX_THIS_FILE
  50. static const char HX_THIS_FILE[] = __FILE__;
  51. #endif
  53. /************************************************************************
  54.  *  Method:
  55.  *    Constructor
  56.  */
  57. CHXMultiInstanceSiteUserSupplier::CHXMultiInstanceSiteUserSupplier()
  58.     : m_lRefCount(0)
  59.     , m_pSingleUser(NULL)
  60.     , m_bIsAttached(FALSE)
  61.     , m_pSurfaceBitmapInfo(NULL)
  62.     , m_bSetSizeHasBeenCalled(FALSE)
  63.     , m_bSetPositionHasBeenCalled(FALSE)
  64.     , m_bSetZOrderHasBeenCalled(FALSE)
  65.     , m_zorder(0)
  66.     , m_bIsInterrupSafe(FALSE)
  67. {
  68.     m_size.cx       = 0;
  69.     m_size.cy       = 0;
  70.     m_position.x    = 0;
  71.     m_position.y    = 0;
  72.     m_pSurfaceBitmapInfo = 0;
  73. }
  75. /************************************************************************
  76.  *  Method:
  77.  *    Destructor
  78.  */
  79. CHXMultiInstanceSiteUserSupplier::~CHXMultiInstanceSiteUserSupplier()
  80. {
  81.     CHXSimpleList::Iterator ndx = m_PassiveSiteWatchers.Begin();
  82.     for (; ndx != m_PassiveSiteWatchers.End(); ++ndx)
  83.     {
  84. IHXPassiveSiteWatcher* pWatcher =
  85.     (IHXPassiveSiteWatcher*)(*ndx);
  86. delete pWatcher;
  87.     }
  88.     m_PassiveSiteWatchers.RemoveAll();
  89.     HX_DELETE (m_pSurfaceBitmapInfo);
  90. }
  92. /************************************************************************
  93.  *  Method:
  94.  *    IUnknown::QueryInterface
  95.  */
  96. STDMETHODIMP 
  97. CHXMultiInstanceSiteUserSupplier::QueryInterface(REFIID riid, void** ppvObj)
  98. {
  99.     if (IsEqualIID(riid, IID_IHXVideoSurface2))
  100.     {
  101.         // All of our target site surfaces must support IHXVideoSurface2
  102.         // for this QI to succeed; this is required both for the proxy logic
  103.         // in this class as well as to signal to the renderer that it's using
  104.         // and old or 3rd party site. 
  105.         
  106.         CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  107.         if (i != m_SiteUsers.End())
  108.         {
  109.             CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
  110.             if (pSiteUser->m_pSite2)
  111.             {
  112.                 IHXVideoSurface* pFirstSurface;
  113.                 if (HXR_OK == pSiteUser->m_pSite2->GetVideoSurface(pFirstSurface))
  114.                 {
  115.                     IHXVideoSurface* pSecondSurface;
  116.                     if (HXR_OK == pFirstSurface->QueryInterface(riid, (void**) &pSecondSurface))
  117.                     {
  118.                         HX_RELEASE(pFirstSurface);
  119.                         HX_RELEASE(pSecondSurface);
  120.                         AddRef();
  121.                         *ppvObj = (IUnknown*)(IHXVideoSurface2*)this;
  122.                         return HXR_OK;
  123.                     }
  124.                     
  125.                     HX_RELEASE(pFirstSurface);
  126.                 }
  127.             }
  128.         }
  129.     }
  131.     QInterfaceList qiList[] =
  132.     {
  133.     { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXSite*)this },
  134.     { GET_IIDHANDLE(IID_IHXVideoSurface), (IHXVideoSurface*) this },
  135.     { GET_IIDHANDLE(IID_IHXSite), (IHXSite*) this },
  136.     { GET_IIDHANDLE(IID_IHXSite2), (IHXSite2*) this },
  137.     { GET_IIDHANDLE(IID_IHXSiteEnumerator), (IHXSiteEnumerator*) this },
  138.     { GET_IIDHANDLE(IID_IHXSiteUserSupplier), (IHXSiteUserSupplier*) this },
  139.     { GET_IIDHANDLE(IID_IHXMultiInstanceSiteUserSupplier), (IHXMultiInstanceSiteUserSupplier*) this },
  140.     { GET_IIDHANDLE(IID_IHXInterruptSafe), (IHXInterruptSafe*) this },
  141.     };
  143.     if (QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj) == HXR_OK)
  144.     {
  145.     return HXR_OK;
  146.     }
  147.     else if (IsEqualIID(riid, IID_IHXValues)) //XXXCXZ
  148.     {
  149. if (m_pSingleUser)
  150. {
  151.     return m_pSingleUser->QueryInterface(IID_IHXValues, ppvObj);
  152. }
  153.     }
  154.     else if (IsEqualIID(riid, IID_IHXSiteWindowless))
  155.     {
  156. // check if the underlying implementation is the new one!
  157. CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  158. if(i != m_SiteUsers.End())
  159. {
  160.     CHXMultiInstanceSiteUser* pSiteUser = 
  161. (CHXMultiInstanceSiteUser*)(*i);
  162.     if (pSiteUser->m_pSite)
  163.     {
  164. return pSiteUser->m_pSite->QueryInterface(riid, ppvObj);
  165.     }
  166. }
  167.     }
  168.     else if (IsEqualIID(riid, IID_IHXSubRectSite))
  169.     {
  170. //Check to see if this site support this new interface....
  171. CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  172. if(i != m_SiteUsers.End())
  173. {
  174.     CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
  175.     if(pSiteUser->m_pSite)
  176.     {
  177. return pSiteUser->m_pSite->QueryInterface(riid, ppvObj);
  178.     }
  179. }
  180.     }
  181.     else if (IsEqualIID(riid, IID_IHXKeyBoardFocus))
  182.     {
  183. CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  184. if(i != m_SiteUsers.End())
  185. {
  186.     CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
  187.     if(pSiteUser->m_pSite)
  188.     {
  189.                 // Return fhe first we find:
  190. if (SUCCEEDED(pSiteUser->m_pSite->QueryInterface(riid, ppvObj)))
  191.                 {
  192.                     return HXR_OK;
  193.                 }
  194.     }
  195. }
  196.     }
  198.     *ppvObj = NULL;
  199.     return HXR_NOINTERFACE;
  200. }
  202. /************************************************************************
  203.  *  Method:
  204.  *    IUnknown::AddRef
  205.  */
  206. STDMETHODIMP_(ULONG32) 
  207. CHXMultiInstanceSiteUserSupplier::AddRef()
  208. {
  209.     return InterlockedIncrement(&m_lRefCount);
  210. }
  212. /************************************************************************
  213.  *  Method:
  214.  *    IUnknown::Release
  215.  */
  216. STDMETHODIMP_(ULONG32) 
  217. CHXMultiInstanceSiteUserSupplier::Release()
  218. {
  219.     if (InterlockedDecrement(&m_lRefCount) > 0)
  220.     {
  221.         return m_lRefCount;
  222.     }
  224.     delete this;
  225.     return 0;
  226. }
  228. /************************************************************************
  229.  *  Method:
  230.  *    IHXSite::AttachUser
  231.  */
  232. STDMETHODIMP 
  233. CHXMultiInstanceSiteUserSupplier::AttachUser(IHXSiteUser* /*IN*/ pUser)
  234. {
  235.     return HXR_NOTIMPL;
  236. }
  238. /************************************************************************
  239.  *  Method:
  240.  *    IHXSite::DetachUser
  241.  */
  242. STDMETHODIMP 
  243. CHXMultiInstanceSiteUserSupplier::DetachUser()
  244. {
  245.     return HXR_NOTIMPL;
  246. }
  248. /************************************************************************
  249.  *  Method:
  250.  *    IHXSite::GetUser
  251.  */
  252. STDMETHODIMP 
  253. CHXMultiInstanceSiteUserSupplier::GetUser(REF(IHXSiteUser*) /*OUT*/ pUser)
  254. {
  255.     return HXR_NOTIMPL;
  256. }
  259. /************************************************************************
  260.  *  Method:
  261.  *    IHXSite::CreateChild
  262.  */
  263. STDMETHODIMP 
  264. CHXMultiInstanceSiteUserSupplier::CreateChild(REF(IHXSite*) /*OUT*/ pChildSite)
  265. {
  266.     return HXR_NOTIMPL;
  267. }
  269. /************************************************************************
  270.  *  Method:
  271.  *    IHXSite::DestroyChild
  272.  */
  273. STDMETHODIMP 
  274. CHXMultiInstanceSiteUserSupplier::DestroyChild(IHXSite* /*IN*/ pChildSite)
  275. {
  276.     return HXR_NOTIMPL;
  277. }
  279. /************************************************************************
  280.  *  Method:
  281.  *    IHXSite::SetSize
  282.  */
  283. STDMETHODIMP 
  284. CHXMultiInstanceSiteUserSupplier::SetSize(HXxSize size)
  285. {
  286.     m_bSetSizeHasBeenCalled = TRUE;
  287.     m_size = size;
  288.     CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  289.     for ( ; i != m_SiteUsers.End(); ++i)
  290.     {
  291. CHXMultiInstanceSiteUser* pSiteUser = 
  292.     (CHXMultiInstanceSiteUser*)(*i);
  293. pSiteUser->m_pSite->SetSize(size);
  294.     }
  296.     CHXSimpleList::Iterator ndx = m_PassiveSiteWatchers.Begin();
  297.     for (; ndx != m_PassiveSiteWatchers.End(); ++ndx)
  298.     {
  299. IHXPassiveSiteWatcher* pWatcher =
  300.     (IHXPassiveSiteWatcher*)(*ndx);
  301. pWatcher->SizeChanged(&size);
  302.     }
  303.     
  304.     return HXR_OK;
  305. }
  307. /************************************************************************
  308.  *  Method:
  309.  *    IHXSite::SetPosition
  310.  */
  311. STDMETHODIMP 
  312. CHXMultiInstanceSiteUserSupplier::SetPosition(HXxPoint position)
  313. {
  314.     m_bSetPositionHasBeenCalled = TRUE;
  315.     m_position = position;
  316.     CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  317.     for ( ; i != m_SiteUsers.End(); ++i)
  318.     {
  319. CHXMultiInstanceSiteUser* pSiteUser = 
  320.     (CHXMultiInstanceSiteUser*)(*i);
  321. pSiteUser->m_pSite->SetPosition(position);
  322.     }
  323.     
  324.     CHXSimpleList::Iterator ndx = m_PassiveSiteWatchers.Begin();
  325.     for (; ndx != m_PassiveSiteWatchers.End(); ++ndx)
  326.     {
  327. IHXPassiveSiteWatcher* pWatcher =
  328.     (IHXPassiveSiteWatcher*)(*ndx);
  329. pWatcher->PositionChanged(&position);
  330.     }
  331.     
  332.     return HXR_OK;
  333. }
  335. /************************************************************************
  336.  *  Method:
  337.  *    IHXSite::GetSize
  338.  */
  339. STDMETHODIMP 
  340. CHXMultiInstanceSiteUserSupplier::GetSize(REF(HXxSize) size)
  341. {
  342.     // We assume the first instance has the correct size and position.
  343.     CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  344.     if(i != m_SiteUsers.End())
  345.     {
  346. CHXMultiInstanceSiteUser* pSiteUser = 
  347.     (CHXMultiInstanceSiteUser*)(*i);
  348. return pSiteUser->m_pSite->GetSize(size);
  349.     }
  350.     // If there is no actual instance, then use the cached size.
  351.     size = m_size;
  352.     return HXR_OK;
  353. }
  355. /************************************************************************
  356.  *  Method:
  357.  *    IHXSite::GetPosition
  358.  */
  359. STDMETHODIMP 
  360. CHXMultiInstanceSiteUserSupplier::GetPosition(REF(HXxPoint) position)
  361. {
  362.     // We assume the first instance has the correct size and position.
  363.     CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  364.     if(i != m_SiteUsers.End())
  365.     {
  366. CHXMultiInstanceSiteUser* pSiteUser = 
  367.     (CHXMultiInstanceSiteUser*)(*i);
  368. return pSiteUser->m_pSite->GetPosition(position);
  369.     }
  370.     // If there is no actual instance, then use the cached position
  371.     position = m_position;
  372.     return HXR_OK;
  373. }
  375. /************************************************************************
  376.  *  Method:
  377.  *    IHXSite::DamageRect
  378.  */
  379. STDMETHODIMP 
  380. CHXMultiInstanceSiteUserSupplier::DamageRect(HXxRect rect)
  381. {
  382.     /*
  383.      * Coding this loop like this instead of using an iterator
  384.      * makes things slightly more thread safe. This fixes the known
  385.      * repro cases for bug 3787.
  386.      */
  387.     LISTPOSITION pos = m_SiteUsers.GetHeadPosition();
  388.     while(pos)
  389.     {
  390. CHXMultiInstanceSiteUser* pSiteUser = 
  391.     (CHXMultiInstanceSiteUser*)m_SiteUsers.GetNext(pos);
  393. if (pSiteUser)
  394.     pSiteUser->m_pSite->DamageRect(rect);
  395.     }
  396.    
  397.     return HXR_OK;
  398. }
  400. /************************************************************************
  401.  *  Method:
  402.  *    IHXSite::DamageRegion
  403.  */
  404. STDMETHODIMP 
  405. CHXMultiInstanceSiteUserSupplier::DamageRegion(HXxRegion region)
  406. {
  407.     /*
  408.      * Coding this loop like this instead of using an iterator
  409.      * makes things slightly more thread safe. This fixes the known
  410.      * repro cases for bug 3787.
  411.      */
  412.     LISTPOSITION pos = m_SiteUsers.GetHeadPosition();
  413.     while(pos)
  414.     {
  415. CHXMultiInstanceSiteUser* pSiteUser = 
  416.     (CHXMultiInstanceSiteUser*)m_SiteUsers.GetNext(pos);
  418. if (pSiteUser)
  419.     pSiteUser->m_pSite->DamageRegion(region);
  420.     }
  421.    
  422.     return HXR_OK;
  423. }
  425. /************************************************************************
  426.  *  Method:
  427.  *    IHXSite::ForceRedraw
  428.  */
  429. STDMETHODIMP 
  430. CHXMultiInstanceSiteUserSupplier::ForceRedraw()
  431. {
  432.     /*
  433.      * Coding this loop like this instead of using an iterator
  434.      * makes things slightly more thread safe. This fixes the known
  435.      * repro cases for bug 3787.
  436.      */
  437.     LISTPOSITION pos = m_SiteUsers.GetHeadPosition();
  438.     while(pos)
  439.     {
  440. CHXMultiInstanceSiteUser* pSiteUser = 
  441.     (CHXMultiInstanceSiteUser*)m_SiteUsers.GetNext(pos);
  443. if (pSiteUser)
  444.     pSiteUser->m_pSite->ForceRedraw();
  445.     }
  446.    
  447.     return HXR_OK;
  448. }
  450. /************************************************************************
  451.  *  Method:
  452.  *    IHXMultiInstanceSiteUserSupplier::SetSingleSiteUser
  453.  */
  454. STDMETHODIMP
  455. CHXMultiInstanceSiteUserSupplier::SetSingleSiteUser(IUnknown* pUnknown)
  456. {
  457.     if (HXR_OK != pUnknown->QueryInterface(IID_IHXSiteUser,(void**)&m_pSingleUser))
  458.     {
  459. return HXR_INVALID_PARAMETER;
  460.     }
  461.     return HXR_OK;
  462. }
  464. /************************************************************************
  465.  *  Method:
  466.  *    IHXMultiInstanceSiteUserSupplier::ReleaseSingleSiteUser
  467.  */
  468. STDMETHODIMP
  469. CHXMultiInstanceSiteUserSupplier::ReleaseSingleSiteUser()
  470. {
  471.     HX_RELEASE(m_pSingleUser);
  472.     return HXR_OK;
  473. }
  475. /************************************************************************
  476.  *  Method:
  477.  *    IHXSiteUserSupplier::CreateSiteUser
  478.  */
  479. STDMETHODIMP
  480. CHXMultiInstanceSiteUserSupplier::CreateSiteUser
  481. (
  482.     REF(IHXSiteUser*)/*OUT*/ pSiteUser
  483. )
  484. {
  485.     CHXMultiInstanceSiteUser* pMISU = new CHXMultiInstanceSiteUser(this);
  486.     if (!pMISU)
  487.     {
  488. return HXR_OUTOFMEMORY;
  489.     }
  491.     // This is our caller's ref.
  492.     pMISU->QueryInterface(IID_IHXSiteUser,(void**)&pSiteUser);
  494.     m_SiteUsers.AddTail(pSiteUser);
  496.     pSiteUser->AddRef(); // this is for the caller
  497.     
  498.     return HXR_OK;
  499. }
  501. /************************************************************************
  502.  *  Method:
  503.  *    IHXSiteUserSupplier::DestroySiteUser
  504.  */
  505. STDMETHODIMP
  506. CHXMultiInstanceSiteUserSupplier::DestroySiteUser
  507. (
  508.     IHXSiteUser* /*IN*/ pSiteUser
  509. )
  510. {
  511.     LISTPOSITION pos = m_SiteUsers.Find(pSiteUser);
  512.     if (!pos)
  513.     {
  514.         return HXR_INVALID_PARAMETER;
  515.     }
  516.     m_SiteUsers.RemoveAt(pos);
  517.     pSiteUser->Release();
  519.     // If this is the last of the multi-instance sites, then
  520.     // tell the real site user to detach.
  521.     if (m_SiteUsers.IsEmpty())
  522.     {
  523. AddRef();
  524. IHXSiteUser* pSingleUser = m_pSingleUser;
  525. pSingleUser->AddRef();
  526.         m_pSingleUser->DetachSite();
  527. pSingleUser->Release();
  528. m_bIsAttached = FALSE;
  529. Release();
  530.     }
  531.     return HXR_OK;
  532. }
  534. /************************************************************************
  535.  *  Method:
  536.  *    IHXSiteUserSupplier::NeedsWindowedSites
  537.  */
  538. STDMETHODIMP_(BOOL)
  539. CHXMultiInstanceSiteUserSupplier::NeedsWindowedSites()
  540. {
  541.     return FALSE;
  542. }
  544. /************************************************************************
  545.  *  Method:
  546.  *    IHXSite::AttachWatcher
  547.  */
  548. STDMETHODIMP 
  549. CHXMultiInstanceSiteUserSupplier::AttachWatcher(IHXSiteWatcher* /*IN*/ pWatcher)
  550. {
  551.     return HXR_NOTIMPL;
  552. }
  554. /************************************************************************
  555.  *  Method:
  556.  *    IHXSite::DetachWatcher
  557.  */
  558. STDMETHODIMP 
  559. CHXMultiInstanceSiteUserSupplier::DetachWatcher()
  560. {
  561.     return HXR_NOTIMPL;
  562. }
  564. /************************************************************************
  565.  *  Method:
  566.  *    IHXSite2::UpdateSiteWindow
  567.  */
  568. STDMETHODIMP
  569. CHXMultiInstanceSiteUserSupplier::UpdateSiteWindow(HXxWindow* /*IN*/ pWindow)
  570. {
  571.     CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  572.     for ( ; i != m_SiteUsers.End(); ++i)
  573.     {
  574. CHXMultiInstanceSiteUser* pSiteUser = 
  575.     (CHXMultiInstanceSiteUser*)(*i);
  576. if (pSiteUser->m_pSite2)
  577. {
  578.     pSiteUser->m_pSite2->UpdateSiteWindow(pWindow);
  579. }
  580.     }
  581.     
  582.     return HXR_OK;
  583. }
  585. /************************************************************************
  586.  *  Method:
  587.  *    IHXSite2::ShowSite
  588.  */
  589. STDMETHODIMP
  590. CHXMultiInstanceSiteUserSupplier::ShowSite(BOOL bShow)
  591. {
  592.     return HXR_NOTIMPL;
  593. }
  595. /************************************************************************
  596.  *  Method:
  597.  *    IHXSite2::IsSiteVisible
  598.  */
  599. STDMETHODIMP_(BOOL)
  600. CHXMultiInstanceSiteUserSupplier::IsSiteVisible()
  601. {
  602.     // Not implemented
  603.     HX_ASSERT(0);
  604.     return FALSE;
  605. }
  607. /************************************************************************
  608.  *  Method:
  609.  *    IHXSite2::SetZOrder
  610.  */
  611. STDMETHODIMP
  612. CHXMultiInstanceSiteUserSupplier::SetZOrder(INT32 lZOrder)
  613. {
  614.     m_bSetZOrderHasBeenCalled = TRUE;
  615.     m_zorder = lZOrder;
  616.     
  617.     CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  618.     for ( ; i != m_SiteUsers.End(); ++i)
  619.     {
  620. CHXMultiInstanceSiteUser* pSiteUser = 
  621.     (CHXMultiInstanceSiteUser*)(*i);
  622. if (pSiteUser->m_pSite2)
  623. {
  624.     pSiteUser->m_pSite2->SetZOrder(lZOrder);
  625. }
  626.     }
  627.     
  628.     return HXR_OK;
  629. }
  631. /************************************************************************
  632.  *  Method:
  633.  *    IHXSite2::GetZOrder
  634.  */
  635. STDMETHODIMP
  636. CHXMultiInstanceSiteUserSupplier::GetZOrder(REF(INT32) lZOrder)
  637. {
  638.     return HXR_NOTIMPL;
  639. }
  641. /************************************************************************
  642.  *  Method:
  643.  *    IHXSite2::MoveSiteToTop
  644.  */
  645. STDMETHODIMP
  646. CHXMultiInstanceSiteUserSupplier::MoveSiteToTop()
  647. {
  648.     CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  649.     for ( ; i != m_SiteUsers.End(); ++i)
  650.     {
  651. CHXMultiInstanceSiteUser* pSiteUser = 
  652.     (CHXMultiInstanceSiteUser*)(*i);
  653. if (pSiteUser->m_pSite2)
  654. {
  655.     pSiteUser->m_pSite2->MoveSiteToTop();
  656. }
  657.     }
  658.     
  659.     return HXR_OK;
  660. }
  662. #if 0 
  663. /************************************************************************
  664.  *  Method:
  665.  *    IHXSite2::GetVideoSurface
  666.  */
  667. STDMETHODIMP
  668. CHXMultiInstanceSiteUserSupplier::GetVideoSurface(REF(IHXVideoSurface*) pSurface)
  669. {
  670.     CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  671.     CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
  672.     if (pSiteUser->m_pSite2)
  673.     {
  674. return pSiteUser->m_pSite2->GetVideoSurface(pSurface);
  675.     }
  676.     
  677.     return HXR_FAIL;
  678. }
  679. #endif
  681. /************************************************************************
  682.  *  Method:
  683.  *    IHXSite2::GetVideoSurface
  684.  */
  685. STDMETHODIMP
  686. CHXMultiInstanceSiteUserSupplier::GetVideoSurface(REF(IHXVideoSurface*) pSurface)
  687. {
  688.     // check to see if we have a video surface in any of our 
  689.     // sites 
  690.     IHXVideoSurface* pTempSurface;
  692.     for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  693.  i!= m_SiteUsers.End(); ++i)
  694.     {
  695. CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
  696. if (pSiteUser->m_pSite2)
  697. {
  698.     if (HXR_OK == pSiteUser->m_pSite2->GetVideoSurface(pTempSurface))
  699.     {
  700. // so we have a video sufrface in one of our sites 
  701. // good enough return HXR_OK.
  702. HX_RELEASE(pTempSurface);
  703. QueryInterface(IID_IHXVideoSurface, (void**) &pSurface);
  704. return HXR_OK;
  705.     }
  706. }
  707.      }
  708.     
  709.     return HXR_FAIL;
  710. }
  712. /************************************************************************
  713.  *  Method:
  714.  *    IHXSite2::GetNumberOfChildSites
  715.  */
  716. STDMETHODIMP_(UINT32)
  717. CHXMultiInstanceSiteUserSupplier::GetNumberOfChildSites()
  718. {
  719.     UINT32 ulChildSites = 0;
  721.     CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  722.     for ( ; i != m_SiteUsers.End(); ++i)
  723.     {
  724. CHXMultiInstanceSiteUser* pSiteUser = 
  725.     (CHXMultiInstanceSiteUser*)(*i);
  726. ulChildSites += pSiteUser->m_pSite2->GetNumberOfChildSites();
  727.     }
  729.     return ulChildSites;
  730. }
  732. /************************************************************************
  733.  *  Method:
  734.  *    IHXSite2::AddPassiveSiteWatcher
  735.  */
  736. STDMETHODIMP
  737. CHXMultiInstanceSiteUserSupplier::AddPassiveSiteWatcher
  738. (
  739.     IHXPassiveSiteWatcher* pWatcher
  740. )
  741. {
  742.     HX_ASSERT(pWatcher);
  744.     pWatcher->AddRef();
  745.     m_PassiveSiteWatchers.AddTail(pWatcher);
  746.     return HXR_OK;
  747. }
  749. /************************************************************************
  750.  *  Method:
  751.  *    IHXSite2::DetachPassiveSiteWatcher
  752.  */
  753. STDMETHODIMP
  754. CHXMultiInstanceSiteUserSupplier::RemovePassiveSiteWatcher
  755. (
  756.     IHXPassiveSiteWatcher* pWatcher
  757. )
  758. {
  759.     LISTPOSITION pos = m_PassiveSiteWatchers.GetHeadPosition();
  760.     while(pos)
  761.     {
  762. IHXPassiveSiteWatcher* pThisWatcher = 
  763.     (IHXPassiveSiteWatcher*)m_PassiveSiteWatchers.GetAt(pos);
  764. if(pWatcher == pThisWatcher)
  765. {
  766.     pWatcher->Release();
  767.     m_PassiveSiteWatchers.RemoveAt(pos);
  768.     break;
  769. }
  770. m_PassiveSiteWatchers.GetNext(pos);
  771.     }
  772.     return HXR_OK;
  773. }
  775. /************************************************************************
  776.  *  Method:
  777.  *    IHXSite2::SetCursor
  778.  */
  779. STDMETHODIMP
  780. CHXMultiInstanceSiteUserSupplier::SetCursor
  781. (
  782.     HXxCursor cursor,
  783.     REF(HXxCursor) oldCursor
  784. )
  785. {
  786.     return HXR_NOTIMPL;
  787. }
  789. /*
  790.  * IHXSiteEnumerator methods 
  791.  */
  793. STDMETHODIMP 
  794. CHXMultiInstanceSiteUserSupplier::GetFirstSite  
  795. (
  796.     REF(IHXSite*) /* OUT */ pFirstSite,
  797.     REF(IHXSiteEnumerator::SitePosition) /* OUT */ nextPosition
  798. )
  799. {
  800.     nextPosition = m_SiteUsers.GetHeadPosition();  
  801.     if (nextPosition)
  802.     {
  803.         pFirstSite = ((CHXMultiInstanceSiteUser*) m_SiteUsers.GetNext(nextPosition))->m_pSite; 
  805.         if (pFirstSite)
  806.         {        
  807.             HX_ADDREF(pFirstSite);
  808.             return HXR_OK;
  809.         }
  810.     }
  812.     return HXR_FAIL;
  813. }
  815. STDMETHODIMP 
  816. CHXMultiInstanceSiteUserSupplier::GetNextSite   
  817. (
  818.     REF(IHXSite*) pNextSite,
  819.     REF(IHXSiteEnumerator::SitePosition) /* IN/OUT */ nextPosition
  820. )
  821. {
  822.     if (nextPosition)
  823.     {
  824.         pNextSite = ((CHXMultiInstanceSiteUser*) m_SiteUsers.GetNext(nextPosition))->m_pSite; 
  826.         if (pNextSite)
  827.         {
  828.             HX_ADDREF(pNextSite);
  829.             return HXR_OK;
  830.         }
  831.     }
  833.     return HXR_FAIL;
  834. }
  837. /************************************************************************
  838.  *  Method:
  839.  *    IHXVideoSurface::Blt
  840.  */
  841. STDMETHODIMP 
  842. CHXMultiInstanceSiteUserSupplier::Blt
  843. (UCHAR* /*IN*/ pImageBits, 
  844. HXBitmapInfoHeader*    /*IN*/ pBitmapInfo,
  845. REF(HXxRect) /*IN*/ rDestRect, 
  846. REF(HXxRect) /*IN*/ rSrcRect) 
  847. {           
  848.     HX_ASSERT(0);
  849.     return HXR_NOTIMPL;
  850. }
  852. /************************************************************************
  853.  *  Method:
  854.  *    IHXVideoSurface::BeginOptimizedBlt
  855.  */
  856. STDMETHODIMP
  857. CHXMultiInstanceSiteUserSupplier::BeginOptimizedBlt
  858. (
  859. HXBitmapInfoHeader*    /*IN*/ pBitmapInfo
  860. ) 
  861. {
  862.     if (!pBitmapInfo)
  863. return HXR_FAIL;
  865.     HX_DELETE(m_pSurfaceBitmapInfo);
  866.     m_pSurfaceBitmapInfo = new HXBitmapInfoHeader;
  867.     memcpy(m_pSurfaceBitmapInfo, pBitmapInfo, sizeof(HXBitmapInfoHeader)); /* Flawfinder: ignore */
  868.     
  869.     HX_RESULT retVal = HXR_FAIL;
  870.     IHXVideoSurface* pTempSurface;
  872.     for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  873.  i!= m_SiteUsers.End(); ++i)
  874.     {
  875. CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
  876. if (pSiteUser->m_pSite2)
  877. {
  878.     if (HXR_OK == pSiteUser->m_pSite2->GetVideoSurface(pTempSurface))
  879.     {
  880. // so we have a video sufrface in one of our sites 
  881. // good enough return HXR_OK.
  882. if (HXR_OK == pTempSurface->BeginOptimizedBlt(pBitmapInfo))
  883. {
  884.     retVal = HXR_OK;
  885. }
  886. HX_RELEASE(pTempSurface);
  887.     }
  888. }
  889.      }
  890.     return retVal;
  891. }
  893. /************************************************************************
  894.  *  Method:
  895.  *    IHXVideoSurface::OptimizedBlt
  896.  */
  897. STDMETHODIMP 
  898. CHXMultiInstanceSiteUserSupplier::OptimizedBlt
  899. (
  900. UCHAR* /*IN*/ pImageBits,
  901. REF(HXxRect) /*IN*/ rDestRect, 
  902. REF(HXxRect) /*IN*/ rSrcRect
  903. )
  904. {
  905.     HX_ASSERT(0);
  906.     return HXR_NOTIMPL;
  907. }
  909. /************************************************************************
  910.  *  Method:
  911.  *    IHXVideoSurface::EndOptimizedBlt
  912.  */
  913. STDMETHODIMP 
  914. CHXMultiInstanceSiteUserSupplier::EndOptimizedBlt ()
  915. {
  916.     HX_RESULT retVal = HXR_FAIL;
  917.     IHXVideoSurface* pTempSurface;
  919.     for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  920.  i!= m_SiteUsers.End(); ++i)
  921.     {
  922. CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
  923. if (pSiteUser->m_pSite2)
  924. {
  925.     if (HXR_OK == pSiteUser->m_pSite2->GetVideoSurface(pTempSurface))
  926.     {
  927. // so we have a video sufrface in one of our sites 
  928. // good enough return HXR_OK.
  929. if (HXR_OK == pTempSurface->EndOptimizedBlt())
  930. {
  931.     HX_RELEASE(pTempSurface);
  932.     retVal = HXR_OK;
  933.     break;
  934. }
  935. HX_RELEASE(pTempSurface);
  936.     }
  937. }
  938.      }
  939.     return retVal;
  940. }
  942. /************************************************************************
  943.  *  Method:
  944.  *    IHXVideoSurface::GetOptimizedFormat
  945.  */
  946. STDMETHODIMP 
  947. CHXMultiInstanceSiteUserSupplier::GetOptimizedFormat
  948. (
  949.     REF(HX_COMPRESSION_TYPE) /*OUT*/ ulType
  950. )
  951. {
  952.     if (m_SiteUsers.IsEmpty())
  953. return HXR_FAIL;
  955.     HX_RESULT retVal = HXR_FAIL;
  956.     IHXVideoSurface* pTempSurface;
  958.     for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  959.  i!= m_SiteUsers.End(); ++i)
  960.     {
  961. CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
  962. if (pSiteUser->m_pSite2)
  963. {
  964.     if (HXR_OK == pSiteUser->m_pSite2->GetVideoSurface(pTempSurface))
  965.     {
  966. // so we have a video sufrface in one of our sites 
  967. // good enough return HXR_OK.
  968. if (HXR_OK == pTempSurface->GetOptimizedFormat(ulType))
  969. {
  970.     retVal = HXR_OK;
  971. }
  972. HX_RELEASE(pTempSurface);
  973.     }
  974. }
  975.      }
  976.     return retVal;
  977. }
  980. /************************************************************************
  981.  *  Method:
  982.  *    IHXVideoSurface::GetPreferredFormat
  983.  */
  984. STDMETHODIMP 
  985. CHXMultiInstanceSiteUserSupplier::GetPreferredFormat
  986. (
  987. REF(HX_COMPRESSION_TYPE) /*OUT*/ ulType
  988. )
  989. {
  990.     if (m_SiteUsers.IsEmpty())
  991. return HXR_FAIL;
  993.     HX_RESULT retVal = HXR_FAIL;
  994.     IHXVideoSurface* pTempSurface;
  996.     for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  997.  i!= m_SiteUsers.End(); ++i)
  998.     {
  999. CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
  1000. if (pSiteUser->m_pSite2)
  1001. {
  1002.     if (HXR_OK == pSiteUser->m_pSite2->GetVideoSurface(pTempSurface))
  1003.     {
  1004. // so we have a video sufrface in one of our sites 
  1005. // good enough return HXR_OK.
  1006. if (HXR_OK == pTempSurface->GetPreferredFormat(ulType))
  1007. {
  1008.     HX_RELEASE(pTempSurface);
  1009.     retVal = HXR_OK;
  1010.     break;
  1011. }
  1012. HX_RELEASE(pTempSurface);
  1013.     }
  1014. }
  1015.      }
  1016.     return retVal;
  1017. }
  1020. /*
  1021.  * IHXVideoSurface2 methods 
  1022.  */
  1023. STDMETHODIMP 
  1024. CHXMultiInstanceSiteUserSupplier::SetProperties
  1025. (
  1026.     HXBitmapInfoHeader *bmi, REF(UINT32) ulNumBuffers, IHXRenderTimeLine *pClock
  1027. )
  1028. {
  1029.     HX_RESULT result = HXR_OK;
  1031.     for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  1032.  i!= m_SiteUsers.End(); ++i)
  1033.     {
  1034. CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
  1035. if (pSiteUser->m_pSite2)
  1036. {
  1037.             IHXVideoSurface* pVideoSurface;
  1038.     if (SUCCEEDED(pSiteUser->m_pSite2->GetVideoSurface(pVideoSurface)))
  1039.     {
  1040.                 IHXVideoSurface2* pVideoSurface2;
  1041.                 if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
  1042.                                                             (void**) &pVideoSurface2)))
  1043.                 {
  1044.                     // Propagate all failures:
  1045.                     HX_RESULT localResult = pVideoSurface2->SetProperties(bmi,
  1046.                                                                           ulNumBuffers,
  1047.                                                                           pClock);
  1048.                     if (SUCCEEDED(result))
  1049.                     {
  1050.                         result = localResult;    
  1051.                     }
  1052.                     
  1053.                     HX_RELEASE(pVideoSurface2);
  1054.                 }
  1055.                 HX_RELEASE(pVideoSurface);
  1056.             }
  1057.         }
  1058.     }
  1060.     return result;
  1061. }
  1064. STDMETHODIMP_(void) 
  1065. CHXMultiInstanceSiteUserSupplier::Flush()    
  1066. {
  1067.     for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  1068.  i!= m_SiteUsers.End(); ++i)
  1069.     {
  1070. CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
  1071. if (pSiteUser->m_pSite2)
  1072. {
  1073.             IHXVideoSurface* pVideoSurface;
  1074.     if (SUCCEEDED(pSiteUser->m_pSite2->GetVideoSurface(pVideoSurface)))
  1075.     {
  1076.                 IHXVideoSurface2* pVideoSurface2;
  1077.                 if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
  1078.                                                             (void**) &pVideoSurface2)))
  1079.                 {
  1080.                     pVideoSurface2->Flush();
  1081.                     HX_RELEASE(pVideoSurface2);
  1082.                 }
  1083.                 HX_RELEASE(pVideoSurface);
  1084.             }
  1085.         }
  1086.     }
  1087. }
  1089. STDMETHODIMP   
  1090. CHXMultiInstanceSiteUserSupplier::ReleaseVideoMem(VideoMemStruct* pVidMem)
  1091. {
  1092.     HX_RESULT result = HXR_FAIL;
  1094.     for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  1095.  i!= m_SiteUsers.End(); ++i)
  1096.     {
  1097. CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
  1098. if (pSiteUser->m_pSite2)
  1099. {
  1100.             IHXVideoSurface* pVideoSurface;
  1101.     if (SUCCEEDED(pSiteUser->m_pSite2->GetVideoSurface(pVideoSurface)))
  1102.     {
  1103.                 IHXVideoSurface2* pVideoSurface2;
  1104.                 if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
  1105.                                                             (void**) &pVideoSurface2)))
  1106.                 {
  1107.                     // We just need one success:
  1108.                     result = pVideoSurface2->ReleaseVideoMem(pVidMem);
  1110.                     HX_RELEASE(pVideoSurface2);
  1111.                     if (SUCCEEDED(result))
  1112.                     {
  1113.                         break;   
  1114.                     }
  1115.                 }
  1116.                 HX_RELEASE(pVideoSurface);
  1117.             }
  1118.         }
  1119.     }
  1121.     return result;
  1122. }
  1124.                                  
  1125. STDMETHODIMP   
  1126. CHXMultiInstanceSiteUserSupplier::ColorConvert
  1127. (
  1128.     INT32 cidIn, 
  1129.     HXxSize *pSrcSize,
  1130.     HXxRect *prSrcRect,
  1131.     SourceInputStruct *pInput,
  1132.     INT32 cidOut,
  1133.     UCHAR *pDestBuffer, 
  1134.     HXxSize *pDestSize, 
  1135.     HXxRect *prDestRect, 
  1136.     int nDestPitch
  1137. )
  1138. {
  1139.     HX_RESULT result = HXR_FAIL;
  1141.     for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  1142.  i!= m_SiteUsers.End(); ++i)
  1143.     {
  1144. CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
  1145. if (pSiteUser->m_pSite2)
  1146. {
  1147.             IHXVideoSurface* pVideoSurface;
  1148.     if (SUCCEEDED(pSiteUser->m_pSite2->GetVideoSurface(pVideoSurface)))
  1149.     {
  1150.                 IHXVideoSurface2* pVideoSurface2;
  1151.                 if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
  1152.                                                             (void**) &pVideoSurface2)))
  1153.                 {
  1154.                     // We just need one success:
  1155.                     result = pVideoSurface2->ColorConvert( cidIn,
  1156.                                                            pSrcSize,
  1157.                                                            prSrcRect,
  1158.                                                            pInput,
  1159.                                                            cidOut,
  1160.                                                            pDestBuffer,
  1161.                                                            pDestSize,
  1162.                                                            prDestRect,
  1163.                                                            nDestPitch
  1164.                                                            );
  1165.                     
  1166.                     HX_RELEASE(pVideoSurface2);
  1167.                     if (SUCCEEDED(result))
  1168.                     {
  1169.                         break;   
  1170.                     }
  1171.                 }
  1172.                 HX_RELEASE(pVideoSurface);
  1173.             }
  1174.         }
  1175.     }
  1177.     return result;
  1178. }
  1180.                                  
  1181. STDMETHODIMP   
  1182. CHXMultiInstanceSiteUserSupplier::GetVideoMem
  1183. (
  1184.     VideoMemStruct* pVidMem,
  1185.     UINT32 ulFlags
  1186. )
  1187. {
  1188.     HX_RESULT result = HXR_FAIL;
  1190.     for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  1191.  i!= m_SiteUsers.End(); ++i)
  1192.     {
  1193. CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
  1194. if (pSiteUser->m_pSite2)
  1195. {
  1196.             IHXVideoSurface* pVideoSurface;
  1197.     if (SUCCEEDED(pSiteUser->m_pSite2->GetVideoSurface(pVideoSurface)))
  1198.     {
  1199.                 IHXVideoSurface2* pVideoSurface2;
  1200.                 if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
  1201.                                                             (void**) &pVideoSurface2)))
  1202.                 {
  1203.                     // We just need one success:
  1204.                     result = pVideoSurface2->GetVideoMem(pVidMem, ulFlags);
  1206.                     HX_RELEASE(pVideoSurface2);
  1207.                     if (SUCCEEDED(result))
  1208.                     {
  1209.                         break;   
  1210.                     }
  1211.                 }
  1212.                 HX_RELEASE(pVideoSurface);
  1213.             }
  1214.         }
  1215.     }
  1217.     return result;
  1218. }
  1219.                                  
  1220. STDMETHODIMP   
  1221. CHXMultiInstanceSiteUserSupplier::Present
  1222. (
  1223.     VideoMemStruct* pVidMem,
  1224.     INT32 lTime,
  1225.     UINT32 ulFlags,
  1226.     HXxRect* prDestRect,
  1227.     HXxRect* prSrcRect
  1228. )
  1229. {
  1230.     HX_RESULT result = HXR_OK;
  1232.     for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  1233.  i!= m_SiteUsers.End(); ++i)
  1234.     {
  1235. CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
  1236. if (pSiteUser->m_pSite2)
  1237. {
  1238.             IHXVideoSurface* pVideoSurface;
  1239.     if (SUCCEEDED(pSiteUser->m_pSite2->GetVideoSurface(pVideoSurface)))
  1240.     {
  1241.                 IHXVideoSurface2* pVideoSurface2;
  1242.                 if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
  1243.                                                             (void**) &pVideoSurface2)))
  1244.                 {
  1245.                     // Propagate all failures:
  1246.                     HX_RESULT localResult = pVideoSurface2->Present(pVidMem,
  1247.                                                                     lTime,
  1248.                                                                     ulFlags,
  1249.                                                                     prDestRect,
  1250.                                                                     prSrcRect);
  1251.                     if (SUCCEEDED(result))
  1252.                     {
  1253.                         result = localResult;    
  1254.                     }
  1255.                     
  1256.                     HX_RELEASE(pVideoSurface2);
  1257.                 }
  1258.                 HX_RELEASE(pVideoSurface);
  1259.             }
  1260.         }
  1261.     }
  1263.     return result;
  1264. }
  1265.                                  
  1266. STDMETHODIMP   
  1267. CHXMultiInstanceSiteUserSupplier::PresentIfReady()
  1268. {
  1269.     HX_RESULT result = HXR_OK;
  1271.     for (CHXSimpleList::Iterator i = m_SiteUsers.Begin();
  1272.  i!= m_SiteUsers.End(); ++i)
  1273.     {
  1274. CHXMultiInstanceSiteUser* pSiteUser = (CHXMultiInstanceSiteUser*)(*i);
  1275. if (pSiteUser->m_pSite2)
  1276. {
  1277.             IHXVideoSurface* pVideoSurface;
  1278.     if (SUCCEEDED(pSiteUser->m_pSite2->GetVideoSurface(pVideoSurface)))
  1279.     {
  1280.                 IHXVideoSurface2* pVideoSurface2;
  1281.                 if (SUCCEEDED(pVideoSurface->QueryInterface(IID_IHXVideoSurface2,
  1282.                                                             (void**) &pVideoSurface2)))
  1283.                 {
  1284.                     // Propagate all failures:
  1285.                     HX_RESULT localResult = pVideoSurface2->PresentIfReady();
  1286.                     if (SUCCEEDED(result))
  1287.                     {
  1288.                         result = localResult;    
  1289.                     }
  1290.                     HX_RELEASE(pVideoSurface2);
  1291.                 }
  1292.                 HX_RELEASE(pVideoSurface);
  1293.             }
  1294.         }
  1295.     }     
  1297.     return result;
  1298. }
  1300. /*
  1301.  *  IHXInterruptSafe methods
  1302.  */
  1304. /************************************************************************
  1305.  * Method:
  1306.  *     IHXInterruptSafe::IsInterruptSafe
  1307.  * Purpose:
  1308.  *     This is the function that will be called to determine if
  1309.  *     interrupt time execution is supported.
  1310.  */
  1311. STDMETHODIMP_(BOOL)
  1312. CHXMultiInstanceSiteUserSupplier::IsInterruptSafe(void)
  1313. {
  1314.     return m_bIsInterrupSafe;
  1315. }
  1317. /************************************************************************
  1318.  *  Method:
  1319.  *    Constructor
  1320.  */
  1321. CHXMultiInstanceSiteUser::CHXMultiInstanceSiteUser
  1322. (
  1323.     CHXMultiInstanceSiteUserSupplier* pMISUS
  1324. )
  1325.     : m_lRefCount(0)
  1326.     , m_pMISUS(pMISUS)
  1327.     , m_pSite(NULL)
  1328.     , m_pSite2(NULL)
  1329. {
  1330. };
  1332. /************************************************************************
  1333.  *  Method:
  1334.  *    Destructor
  1335.  */
  1336. CHXMultiInstanceSiteUser::~CHXMultiInstanceSiteUser()
  1337. {
  1338. }
  1340. /************************************************************************
  1341.  *  Method:
  1342.  *    IUnknown::QueryInterface
  1343.  */
  1344. STDMETHODIMP 
  1345. CHXMultiInstanceSiteUser::QueryInterface(REFIID riid, void** ppvObj)
  1346. {
  1347.     if (IsEqualIID(riid, IID_IHXSiteUser))
  1348.     {
  1349. AddRef();
  1350. *ppvObj = (IHXSiteUser*)this;
  1351. return HXR_OK;
  1352.     }
  1353.     else if (IsEqualIID(riid, IID_IUnknown))
  1354.     {
  1355. AddRef();
  1356. *ppvObj = (IUnknown*)(IHXSiteUser*)this;
  1357. return HXR_OK;
  1358.     }
  1360.     *ppvObj = NULL;
  1361.     return HXR_NOINTERFACE;
  1362. }
  1364. /************************************************************************
  1365.  *  Method:
  1366.  *    IUnknown::AddRef
  1367.  */
  1368. STDMETHODIMP_(ULONG32) 
  1369. CHXMultiInstanceSiteUser::AddRef()
  1370. {
  1371.     return InterlockedIncrement(&m_lRefCount);
  1372. }
  1374. /************************************************************************
  1375.  *  Method:
  1376.  *    IUnknown::Release
  1377.  */
  1378. STDMETHODIMP_(ULONG32) 
  1379. CHXMultiInstanceSiteUser::Release()
  1380. {
  1381.     if (InterlockedDecrement(&m_lRefCount) > 0)
  1382.     {
  1383.         return m_lRefCount;
  1384.     }
  1386.     delete this;
  1387.     return 0;
  1388. }
  1390. /************************************************************************
  1391.  *  Method:
  1392.  *    IHXSiteUser::AttachSite
  1393.  */
  1394. STDMETHODIMP 
  1395. CHXMultiInstanceSiteUser::AttachSite(IHXSite* /*IN*/ pSite)
  1396. {
  1397.     if (m_pSite) return HXR_UNEXPECTED;
  1398.     if (!pSite)  return HXR_INVALID_PARAMETER;
  1399.     m_pSite = pSite;
  1400.     m_pSite->AddRef();
  1403.     IHXSite2* pSite2 = NULL;
  1404.     m_pSite->QueryInterface(IID_IHXSite2, (void**)&pSite2);
  1405.     if (pSite2)
  1406.     {
  1407. m_pSite2 = pSite2;
  1408.     }
  1410.     if (!m_pMISUS->m_bIsAttached)
  1411.     {
  1412. IHXInterruptSafe* pInterrupSafe = NULL;
  1414. if (m_pSite->QueryInterface(IID_IHXInterruptSafe, 
  1415.     (void**) &pInterrupSafe) == HXR_OK)
  1416. {
  1417.     m_pMISUS->m_bIsInterrupSafe = pInterrupSafe->IsInterruptSafe();
  1418.     pInterrupSafe->Release();
  1419. }
  1421. m_pMISUS->m_pSingleUser->AttachSite((IHXSite*)m_pMISUS);
  1422. m_pMISUS->m_bIsAttached = TRUE;
  1423.     }
  1425.     if (m_pMISUS->m_bSetSizeHasBeenCalled)
  1426.     {
  1427. m_pSite->SetSize(m_pMISUS->m_size);
  1428.     }
  1429.     if (m_pMISUS->m_bSetPositionHasBeenCalled)
  1430.     {
  1431. m_pSite->SetPosition(m_pMISUS->m_position);
  1432.     }
  1433.     if (m_pMISUS->m_bSetZOrderHasBeenCalled)
  1434.     {
  1435. m_pSite2->SetZOrder(m_pMISUS->m_zorder);
  1436.     }
  1439.     HXBitmapInfoHeader* pHeader = m_pMISUS->GetBitmapInfoHeader();
  1440.     if (pHeader && m_pSite2)
  1441.     {
  1442. IHXVideoSurface* pTempSurface;
  1443. if (HXR_OK == m_pSite2->GetVideoSurface(pTempSurface))
  1444. {
  1445.     // so we have a video sufrface in one of our sites 
  1446.     // good enough return HXR_OK.
  1447.     pTempSurface->BeginOptimizedBlt(pHeader);
  1448.     HX_RELEASE(pTempSurface);
  1449. }
  1450.     }
  1452.     return HXR_OK;
  1453. }
  1455. /************************************************************************
  1456.  *  Method:
  1457.  *    IHXSiteUser::DetachSite
  1458.  */
  1459. STDMETHODIMP 
  1460. CHXMultiInstanceSiteUser::DetachSite()
  1461. {
  1462.     HX_ASSERT(m_pSite);
  1463.     HX_ASSERT(m_pMISUS);
  1465.     m_pMISUS->DestroySiteUser((IHXSiteUser*)this);
  1467.     HX_RELEASE(m_pSite);
  1468.     HX_RELEASE(m_pSite2);
  1470.     return HXR_OK;
  1471. }
  1473. /************************************************************************
  1474.  *  Method:
  1475.  *    IHXSiteUser::HandleEvent
  1476.  */
  1477. STDMETHODIMP 
  1478. CHXMultiInstanceSiteUser::HandleEvent(HXxEvent* /*IN*/ pEvent)
  1479. {
  1480.     if (m_pMISUS)
  1481.     {
  1482. if (m_pMISUS->m_pSingleUser)
  1483. {
  1484.     return m_pMISUS->m_pSingleUser->HandleEvent(pEvent);
  1485. }
  1486.     }
  1487.     return HXR_NOTIMPL;
  1488. }
  1490. /************************************************************************
  1491.  *  Method:
  1492.  *    IHXSiteUser::NeedsWindowedSites
  1493.  */
  1494. STDMETHODIMP_(BOOL)
  1495. CHXMultiInstanceSiteUser::NeedsWindowedSites()
  1496. {
  1497.     return FALSE;
  1498. }