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