home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / internet / scripting / spruuids / msgloop.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-08-12  |  13.8 KB  |  556 lines
  1. //---------------------------------------------------------------------------
  2. // MsgLoop.cpp
  3. //---------------------------------------------------------------------------
  4. // Implementation of message loop for application.  Includes implementation
  5. // of IOleComponentManager.
  6. //---------------------------------------------------------------------------
  7. // (C) Copyright 1995-1997 by Microsoft Corporation.  All rights reserved.
  8. //
  9. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF 
  10. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO 
  11. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A 
  12. // PARTICULAR PURPOSE.
  13. //---------------------------------------------------------------------------
  14.  
  15. #include "Main.h"
  16. #pragma hdrstop
  17. #include "MsgLoop.h"
  18.  
  19.  
  20. //---------------------------------------------------------------------------
  21. // DEBUG info
  22. //---------------------------------------------------------------------------
  23. SZTHISFILE
  24.  
  25.  
  26. //---------------------------------------------------------------------------
  27. //
  28. //---------------------------------------------------------------------------
  29. CMsgLoop::CMsgLoop
  30. (
  31.   HWND hwnd
  32. )
  33.   {
  34.   INIT_SIGNATURE(SIG_MsgLoop);
  35.  
  36.   for (int i=0; i<cCOMP; i++)
  37.     m_rgcomp[i].pcomp = NULL;
  38.  
  39.   m_icompActive  = icompNIL;
  40.   m_fInState     = FALSE;
  41.   m_icompState   = icompNIL;
  42.   m_uStateID     = 0;
  43.   m_fScrptReset  = FALSE;
  44.   m_fQuitting    = FALSE;
  45.   m_hwnd         = hwnd;
  46.   m_haccel       = NULL;     // Load accel table here
  47.   m_icompMsgLoop =icompNIL;
  48.  
  49.   m_cref        = 1;
  50.   m_cMsgLoop    = 0;
  51.   }
  52.  
  53.  
  54. //---------------------------------------------------------------------------
  55. //
  56. //---------------------------------------------------------------------------
  57. CMsgLoop::~CMsgLoop
  58. (
  59.   void
  60. )
  61.   {
  62.   CHECK_SIGNATURE(SIG_MsgLoop);
  63.  
  64.   for (int i=0; i<cCOMP; i++)
  65.     if (m_rgcomp[i].pcomp)
  66.       {
  67.       m_rgcomp[i].pcomp->Terminate();
  68.       RELEASEPTR(m_rgcomp[i].pcomp);
  69.       }
  70.  
  71.   DESTROY_SIGNATURE(SIG_MsgLoop);
  72.   }
  73.  
  74.  
  75. //***************************************************************************
  76. // IUnknown methods
  77. //***************************************************************************
  78.  
  79. //---------------------------------------------------------------------------
  80. //
  81. //---------------------------------------------------------------------------
  82. STDMETHODIMP CMsgLoop::QueryInterface
  83. (
  84.   REFIID   riid, 
  85.   void   **ppvObj
  86. )
  87.   {
  88.   *ppvObj = NULL;
  89.  
  90.   if (riid == IID_IUnknown)
  91.     *ppvObj = (LPVOID)(IUnknown *)(IOleComponentManager *)this;
  92.   else if (riid == IID_IOleComponentManager)
  93.     *ppvObj = (LPVOID)(IOleComponentManager *)this; 
  94.  
  95.   if (*ppvObj) 
  96.     {
  97.     this->AddRef();
  98.     return S_OK;
  99.     }
  100.   
  101.   return E_NOINTERFACE;
  102.   }
  103.  
  104.  
  105. //---------------------------------------------------------------------------
  106. //
  107. //---------------------------------------------------------------------------
  108. STDMETHODIMP_(ULONG) CMsgLoop::AddRef
  109. (
  110.   void
  111. )
  112.   {
  113.   CHECK_SIGNATURE(SIG_MsgLoop);
  114.   return ++m_cref;
  115.   }
  116.  
  117.  
  118. //---------------------------------------------------------------------------
  119. //
  120. //---------------------------------------------------------------------------
  121. STDMETHODIMP_(ULONG) CMsgLoop::Release
  122. (
  123.   void
  124. )
  125.   {
  126.   CHECK_SIGNATURE(SIG_MsgLoop);
  127.   if (--m_cref)
  128.     return m_cref;
  129.  
  130.   delete this;
  131.   return 0;
  132.   }
  133.  
  134.  
  135.  
  136. //***************************************************************************
  137. // IOleComponentManager Methods
  138. //***************************************************************************
  139.  
  140. //---------------------------------------------------------------------------
  141. //
  142. //---------------------------------------------------------------------------
  143. STDMETHODIMP CMsgLoop::QueryService
  144. (
  145.   REFGUID guidService, 
  146.   REFIID  iid, 
  147.   void  **ppvObjOut
  148. ) 
  149.   {
  150.   *ppvObjOut = NULL;
  151.   return E_NOINTERFACE;
  152.   }
  153.  
  154.  
  155. //---------------------------------------------------------------------------
  156. //
  157. //---------------------------------------------------------------------------
  158. STDMETHODIMP_(BOOL) CMsgLoop::FRegisterComponent
  159. (
  160.   IOleComponent   *piComponent, 
  161.   const CMGRRINFO *pcrinfo, 
  162.   DWORD           *pdwCompIDOut
  163. )
  164.   {
  165.   for (int i=0; i<cCOMP; i++)
  166.     if (!m_rgcomp[i].pcomp)
  167.       {
  168.       piComponent->AddRef();
  169.       m_rgcomp[i].pcomp = piComponent;
  170.       *pdwCompIDOut = i;
  171.       return TRUE;
  172.       }
  173.  
  174.   FAIL("Out of room!");
  175.   return FALSE;
  176.   }
  177.  
  178.  
  179. //---------------------------------------------------------------------------
  180. //
  181. //---------------------------------------------------------------------------
  182. STDMETHODIMP_(BOOL) CMsgLoop::FRevokeComponent
  183. (
  184.   DWORD icomp
  185. )
  186.   {
  187.   ASSERT(m_rgcomp[icomp].pcomp, "Bogus icomp");
  188.   RELEASEPTR(m_rgcomp[icomp].pcomp);
  189.   if (m_icompActive == icomp)
  190.     m_icompActive = icompNIL;
  191.   if (m_icompMsgLoop == icomp)
  192.     m_icompMsgLoop = icompNIL;
  193.   return TRUE;
  194.   }
  195.  
  196.  
  197. //---------------------------------------------------------------------------
  198. //
  199. //---------------------------------------------------------------------------
  200. STDMETHODIMP_(BOOL) CMsgLoop::FUpdateComponentRegistration
  201. ( 
  202.   DWORD            dwComponentID, 
  203.   const CMGRRINFO *pcrinfo
  204. )
  205.   {
  206.   // Don't track info anyway, so pretend it worked:
  207.   return TRUE;
  208.   }
  209.  
  210.  
  211. //---------------------------------------------------------------------------
  212. //
  213. //---------------------------------------------------------------------------
  214. STDMETHODIMP_(void) CMsgLoop::OnComponentActivate
  215. (
  216.   DWORD icomp
  217. )
  218.   {
  219.   ASSERT(m_rgcomp[icomp].pcomp, "Bad icomp");
  220.   m_icompActive = icomp;
  221.   return;
  222.   }
  223.  
  224.  
  225. //---------------------------------------------------------------------------
  226. //
  227. //---------------------------------------------------------------------------
  228. STDMETHODIMP_(BOOL) CMsgLoop::FSetTrackingComponent
  229. (
  230.   DWORD dwComponentID, 
  231.   BOOL  fTrack
  232. )
  233.   {
  234.   // UNDONE: Need to support
  235.   return FALSE;
  236.   }
  237.  
  238.  
  239. //---------------------------------------------------------------------------
  240. //
  241. //---------------------------------------------------------------------------
  242. STDMETHODIMP_(void) CMsgLoop::OnComponentEnterState
  243. (
  244.   DWORD icomp,
  245.   ULONG uStateID, 
  246.   ULONG uContext, 
  247.   ULONG cpicmExclude,
  248.   IOleComponentManager **rgpicmExclude,
  249.   DWORD dwReserved
  250. )
  251.   {
  252.   ASSERT(m_rgcomp[icomp].pcomp, "Bad icomp");
  253.   ASSERT(uStateID==cmgrstateModal,  "Not modal state");
  254.   ASSERT(!m_fInState, "Nested modal states");
  255.  
  256.   m_icompState = icomp;
  257.   m_fInState   = TRUE;
  258.   m_uStateID   = uStateID;
  259.   if (uStateID == cmgrstateModal)
  260.     EnableWindow(m_hwnd, FALSE);
  261.   }
  262.  
  263.  
  264. //---------------------------------------------------------------------------
  265. //
  266. //---------------------------------------------------------------------------
  267. STDMETHODIMP_(BOOL) CMsgLoop::FOnComponentExitState
  268. (
  269.   DWORD icomp,
  270.   ULONG uStateID,
  271.   ULONG uContext,
  272.   ULONG cpicmExclude,
  273.   IOleComponentManager **rgpicmExclude
  274. )
  275.   {
  276.   ASSERT(m_rgcomp[icomp].pcomp, "Bad icomp");
  277.   ASSERT(icomp==(DWORD)m_icompState, "icomp didn't own state");
  278.   ASSERT(uStateID==cmgrstateModal,  "Not modal state");
  279.   ASSERT(uStateID==m_uStateID, "non-matching modal states on pop");
  280.   ASSERT(m_fInState, "underflow of modal state");
  281.  
  282.   m_fInState   = FALSE;
  283.   m_icompState = icompNIL;
  284.   if (uStateID == cmgrstateModal)
  285.     EnableWindow(m_hwnd, TRUE);
  286.   return TRUE;
  287.   }
  288.  
  289.  
  290. //---------------------------------------------------------------------------
  291. //
  292. //---------------------------------------------------------------------------
  293. STDMETHODIMP_(BOOL) CMsgLoop::FInState
  294. (
  295.   ULONG uStateID,
  296.   void *pvoid
  297. )
  298.   {
  299.   return m_fInState && uStateID==m_uStateID;
  300.   }
  301.  
  302.  
  303. //---------------------------------------------------------------------------
  304. //
  305. //---------------------------------------------------------------------------
  306. STDMETHODIMP_(BOOL) CMsgLoop::FContinueIdle
  307. (
  308.   void
  309. )
  310.   {
  311.   return FALSE;
  312.   }
  313.  
  314.  
  315. //---------------------------------------------------------------------------
  316. //
  317. //---------------------------------------------------------------------------
  318. STDMETHODIMP_(BOOL) CMsgLoop::FPushMessageLoop
  319. (
  320.   DWORD icomp, 
  321.   ULONG uReason, 
  322.   void *pvLoopData
  323. )
  324.   {
  325.   MessageLoop(icomp, uReason, pvLoopData);
  326.   return TRUE;
  327.   }
  328.  
  329.  
  330. //---------------------------------------------------------------------------
  331. //
  332. //---------------------------------------------------------------------------
  333. STDMETHODIMP_(BOOL) CMsgLoop::FCreateSubComponentManager
  334. (
  335.   IUnknown *piunkOuter, 
  336.   IUnknown *piunkServProv,
  337.   REFIID    riid, 
  338.   void    **ppvObj
  339. )
  340.   {
  341.   ASSERT(!piunkOuter, "Don't support aggre. SubCompMgr");
  342.   HRESULT hr = this->QueryInterface(riid, ppvObj);
  343.   return !FAILED(hr);
  344.   }
  345.  
  346.  
  347. //---------------------------------------------------------------------------
  348. //
  349. //---------------------------------------------------------------------------
  350. STDMETHODIMP_(BOOL) CMsgLoop::FGetParentComponentManager
  351. (
  352.   IOleComponentManager **ppicm
  353. )
  354.   {
  355.   // UNDONE: Need to implement
  356.   return FALSE;
  357.   }
  358.  
  359.  
  360. //---------------------------------------------------------------------------
  361. //
  362. //---------------------------------------------------------------------------
  363. STDMETHODIMP_(BOOL) CMsgLoop::FGetActiveComponent
  364. (
  365.   DWORD           dwReserved,
  366.   IOleComponent **ppcompOut
  367. )
  368.   {
  369.   // Do we have an active component?
  370.   if (m_icompActive == icompNIL)
  371.     {
  372.     *ppcompOut = NULL;
  373.     return FALSE;
  374.     }
  375.  
  376.   // Yes, return it
  377.   *ppcompOut = m_rgcomp[m_icompActive].pcomp;
  378.   (*ppcompOut)->AddRef();       // for *ppcompOut
  379.   return TRUE;
  380.   }
  381.  
  382.  
  383.  
  384. //***************************************************************************
  385. // Message Loop Implementation
  386. //***************************************************************************
  387.  
  388. //---------------------------------------------------------------------------
  389. // This pushes a new message loop.
  390. //---------------------------------------------------------------------------
  391. void CMsgLoop::MessageLoop
  392. (
  393.   DWORD icomp,
  394.   ULONG uReason, 
  395.   void *pvLoopData
  396. )
  397.   {
  398.   BOOL  fExitLoop = FALSE;
  399.  
  400.   m_cMsgLoop++;
  401.  
  402.   while (!fExitLoop) 
  403.     fExitLoop = PumpMessage(icomp, uReason, pvLoopData);
  404.  
  405.   m_cMsgLoop--;
  406.  
  407.   if (!m_cMsgLoop)
  408.     m_fScrptReset = FALSE;
  409.   }
  410.  
  411.  
  412. //---------------------------------------------------------------------------
  413. // This processes one message.
  414. // Returns TRUE if it is time to exit the current message loop.
  415. //---------------------------------------------------------------------------
  416. BOOL CMsgLoop::PumpMessage
  417. (
  418.   DWORD icomp,
  419.   ULONG uReason, 
  420.   void *pvLoopData
  421. )
  422.   {
  423.   BOOL fExitLoop = FALSE;
  424.   BOOL fMsg;
  425.   MSG  msg;
  426.  
  427.   fMsg = PeekMessage(&msg, NULL, NULL, NULL, PM_REMOVE);
  428.   if (fMsg) 
  429.     {
  430.     if (msg.message == WM_QUIT)
  431.       {
  432.       // Since we're not really an app, re-post the WM_QUIT message, until
  433.       // we can pop any msgloops we've pushed.
  434.       if (m_cMsgLoop)
  435.            PostQuitMessage(msg.wParam);
  436.       return TRUE;
  437.       }
  438.     else
  439.       ProcessMessage(&msg);
  440.     }
  441.  
  442.   if (m_fScrptReset)
  443.     return TRUE;
  444.  
  445.   // A Component told us to push this message loop, and so we
  446.   // ask them whether it's time yet to exit the loop
  447.   fExitLoop = !m_rgcomp[icomp].pcomp->FContinueMessageLoop(uReason, pvLoopData);
  448.  
  449.   if (!fMsg && !fExitLoop) 
  450.     {
  451.     // There weren't any messages and we don't need to exit this message
  452.     // loop yet.  Therefore, now is the right time to do idle processing
  453.     DoIdleProcessing();
  454.     WaitMessage();
  455.     }
  456.  
  457.   return fExitLoop;
  458.   }
  459.  
  460.  
  461. //---------------------------------------------------------------------------
  462. // This processes one message.
  463. //---------------------------------------------------------------------------
  464. void CMsgLoop::ProcessMessage
  465. (
  466.   MSG  *pmsg
  467. )
  468.   {                            
  469.   // When a component is active give it a chance to translate
  470.   // its accelerators.
  471.   if (m_icompActive != icompNIL)
  472.     {
  473.     if (!m_rgcomp[m_icompActive].pcomp->FPreTranslateMessage(pmsg))
  474.       {
  475.       TranslateMessage(pmsg);        // Translates virtual key codes  
  476.       DispatchMessage(pmsg);        // Dispatches message to window 
  477.       }
  478.     } 
  479.   else 
  480.     {
  481.     if (!TranslateAccelerator(m_hwnd, m_haccel, pmsg))
  482.       {
  483.       TranslateMessage(pmsg); // Translates virtual key codes  
  484.       DispatchMessage(pmsg);  // Dispatches message to window 
  485.       }
  486.     }
  487.   }
  488.  
  489.  
  490. //---------------------------------------------------------------------------
  491. // This is called at idle time.
  492. //---------------------------------------------------------------------------
  493. void CMsgLoop::DoIdleProcessing
  494. (
  495.   void
  496. )
  497.   {
  498.   MSG  msg;
  499.   BOOL fContinue = TRUE;
  500.  
  501.   while (fContinue && !PeekMessage(&msg, NULL, NULL, NULL, PM_NOREMOVE))
  502.     {
  503.     fContinue = DoIdle();
  504.     }
  505.   }
  506.  
  507.  
  508. //---------------------------------------------------------------------------
  509. //
  510. //---------------------------------------------------------------------------
  511. BOOL CMsgLoop::DoIdle
  512. (
  513.   void
  514. )
  515.   {
  516.   int  i;
  517.   BOOL fDidWork = FALSE;
  518.  
  519.   // if we have periodic idle tasks that to be done, 
  520.   // do them and return TRUE.
  521.   for (i=0; i<cCOMP; i++)
  522.     {
  523.     if (m_rgcomp[i].pcomp)
  524.       if (m_rgcomp[i].pcomp->FDoIdle(cmgridlefPeriodic))
  525.         fDidWork = TRUE;
  526.     if (fDidWork)
  527.       return TRUE;
  528.     }
  529.     
  530.   // if any high priority idle tasks need to be done,
  531.   // do it, and return TRUE.
  532.   for (i=0; i<cCOMP; i++)
  533.     {
  534.     if (m_rgcomp[i].pcomp)
  535.       if (m_rgcomp[i].pcomp->FDoIdle(cmgridlefPriority))
  536.         fDidWork = TRUE;
  537.     if (fDidWork)
  538.       return TRUE;
  539.     }
  540.  
  541.   // if any lower priority idle tasks need to be done,
  542.   // do it, and return TRUE.
  543.   for (i=0; i<cCOMP; i++)
  544.     {
  545.     if (m_rgcomp[i].pcomp)
  546.       if (m_rgcomp[i].pcomp->FDoIdle(cmgridlefNonPeriodic))
  547.         fDidWork = TRUE;
  548.     if (fDidWork)
  549.       return TRUE;
  550.     }
  551.  
  552.   return FALSE;
  553.   }
  554.  
  555. //--- EOF -------------------------------------------------------------------
  556.