Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
sswnd.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 95k
Category:

Windows Kernel

Development Platform:

Visual C++

sswnd.cpp：Code Content
  1. ////////////////////////////////////////////////////////////////////////////
  2. // SSWND.CPP
  3. //
  4. // Implementation of CScreenSaverWindow
  5. //
  6. // History:
  7. //
  8. // Author   Date        Description
  9. // ------   ----        -----------
  10. // jaym     08/26/96    Created
  11. // jaym     01/24/97    Added password verification
  12. // jaym     04/15/97    Toolbar UI updates
  13. // jaym     05/05/97    Removed Toolbar
  14. // jaym     05/19/97    Re-added Toolbar
  15. /////////////////////////////////////////////////////////////////////////////
  16. #include "precomp.h"
  17. #include <regstr.h>
  18. #include "regini.h"
  19. #include "resource.h"
  20. #include "sswnd.h"
  22. #define TF_DEBUGQI          0
  23. #define TF_DEBUGQS          0
  24. #define TF_DEBUGREFCOUNT    0
  25. #define TF_NAVIGATION       0
  26. #define TF_NOTIFY           0
  27. #define TF_TIMER            0
  28. #define TF_FUNCENTRY        0
  29. #define TF_CLOSE            TF_ALWAYS
  31. #define WM_LOADSCREENSAVER  (WM_USER+550)
  33. /////////////////////////////////////////////////////////////////////////////
  34. // Global variables
  35. /////////////////////////////////////////////////////////////////////////////
  36. BOOL                g_bPasswordEnabled;
  37. extern BOOL         g_bPlatformNT;
  38. extern TCHAR        g_szRegSubKey[];
  39. extern IMalloc *    g_pMalloc;
  40. extern IMMASSOCPROC g_pfnIMMProc;
  42. /////////////////////////////////////////////////////////////////////////////
  43. // Module variables
  44. /////////////////////////////////////////////////////////////////////////////
  45. static CScreenSaverWindow * s_pThis = NULL;
  46. static HHOOK                s_hKeyboardHook = NULL;
  47. static HHOOK                s_hMouseHook = NULL;
  49. #pragma data_seg(DATASEG_READONLY)
  50. static const TCHAR      s_szScreenSaverKey[] = REGSTR_PATH_SCREENSAVE;
  51. static const TCHAR      s_szPasswordActiveValue[] = REGSTR_VALUE_USESCRPASSWORD;
  52. static const TCHAR      s_szPasswordActiveOnNTValue[] = TEXT("ScreenSaverIsSecure");
  53. static const TCHAR      s_szPasswordValue[] = REGSTR_VALUE_SCRPASSWORD;
  54. static const TCHAR      s_szPasswordDLL[] = TEXT("PASSWORD.CPL");
  55. static const TCHAR      s_szPasswordFnName[] = TEXT("VerifyScreenSavePwd");
  56.     // Password
  58. static const TCHAR      s_szRegLastURL[]        = TEXT("LastURL");
  59. static const TCHAR      s_szRegLastNavURL[]     = TEXT("LastNavURL");
  60. static const TCHAR      s_szSETermEvent[]       = TEXT("ActSaverSEEvent");
  61. static const TCHAR      s_szTrayUIWindow[]      = TEXT("MS_WebcheckMonitor");
  62. static const TCHAR      s_szRES[]               = TEXT("res://");
  63. static const TCHAR      s_szSSEmptyFile[]       = TEXT("/ssempty.htm");
  64. static const OLECHAR    s_szYes[]               = OLESTR("YES");
  65. static const OLECHAR    s_szNo[]                = OLESTR("NO");
  66. static const OLECHAR    s_szDefTransition[]     = OLESTR("revealTrans(Duration=5.0, Transition=15)");
  67.     // Misc.
  68. #pragma data_seg()
  70. /////////////////////////////////////////////////////////////////////////////
  71. // Design constants
  72. /////////////////////////////////////////////////////////////////////////////
  73. #define MOUSEMOVE_THRESHOLD         10  // In pixels
  74.     // Number of pixels that the mouse must move to determine a
  75.     // 'real' mouse move event (for closing the Screen Saver).
  77. #define ID_CHANNELCHANGE_TIMER      0x0100
  78.     // Channel change/update timer ID
  80. #define ID_CONTROLS_TIMER           0x0101
  81.     // Scrollbar/Toolbar show/hide timer ID
  83. #define ID_CLICKCHECK_TIMER         0x0102
  84.     // Hotlink click check timer ID
  86. #define ID_RESTART_TIMER            0x0103
  87.     // Restart timer ID
  89. #define TIME_CONTROLS_TIMEOUT       3000    // ms (3 seconds)
  90.     // Scrollbar/Toolbar show/hide timeout
  92. #define TIME_CLICKCHECK_TIMEOUT     1000    // ms (1 second)
  93.     // Hotlink click check timeout
  95. #define TIME_NAVIGATE_TIMEOUT       10000   // ms (10 seconds)
  96.     // WebBrowser Navigate timeout
  98. #define CX_TOOLBAR                  51
  99. #define CY_TOOLBAR                  29
  100.     // Toolbar dimensions
  102. /////////////////////////////////////////////////////////////////////////////
  103. // CScreenSaverWindow
  104. /////////////////////////////////////////////////////////////////////////////
  105. CScreenSaverWindow::CScreenSaverWindow
  106. (
  107. )
  108. {
  109.     m_cRef = 0;
  111.     m_pToolbar = NULL;
  113.     m_bModelessEnabled = TRUE;
  114.     m_bMouseClicked = FALSE;
  115.     m_bScrollbarVisible = TRUE;
  117.     m_pScreenSaver = NULL;
  118.     m_pSSConfig = NULL;
  120.     m_idChangeTimer = 0;
  121.     m_idControlsTimer = 0;
  122.     m_idClickCheckTimer = 0;
  123.     m_idReloadTimer = 0;
  125.     m_pPIDLList = NULL;
  126.     m_pidlDefault = NULL;
  127.     m_lCurrChannel = CURRENT_CHANNEL_NONE;
  129.     m_pUnkBrowser = NULL;
  130.     m_pWebBrowser = NULL;
  131.     m_pOleObject = NULL;
  132.     m_pHlinkFrame = NULL;
  134.     m_pHTMLDocument = NULL;
  136.     m_dwWebBrowserEvents = 0L;
  137.     m_dwWebBrowserEvents2 = 0L;
  138.     m_dwHTMLDocumentEvents = 0L;
  140.     m_pBindStatusCallback = NULL;
  142.     m_hPasswordDLL = NULL;
  143.     m_pfnVerifyPassword = NULL;
  145.     m_hPrevBrowserIMC = 0;
  147.     m_lVerifingPassword = FALSE;
  148. }
  150. CScreenSaverWindow::~CScreenSaverWindow
  151. (
  152. )
  153. {
  154.     // All clean-up is done in OnDestroy and OnNCDestroy.
  155. }
  157. //
  158. // Helper routine to check appropriate registry value to see if screensaver
  159. // is password protected.
  160. //
  161. BOOL IsScreenSaverPasswordProtected()
  162. {
  163.     BOOL bRetValue = FALSE;
  164.     HKEY hKey;
  166.     if (RegOpenKey( HKEY_CURRENT_USER,
  167.                     s_szScreenSaverKey,
  168.                     &hKey) == ERROR_SUCCESS)
  169.     {
  170.         //
  171.         // Registry key string is different on Win95 & NT !!!
  172.         //
  173.         if (g_bPlatformNT)
  174.         {
  175.             CHAR buf[4];
  176.             DWORD dwSize = sizeof(buf);
  178.             if (RegQueryValueEx(hKey, s_szPasswordActiveOnNTValue,
  179.                                 NULL,
  180.                                 NULL,
  181.                                 (BYTE *)buf,
  182.                                 &dwSize) == ERROR_SUCCESS)
  183.             {
  184.                 //
  185.                 // check if "1" is returned in buf
  186.                 //
  187.                 if (dwSize == 2 && buf[0] == '1')
  188.                 {
  189.                     bRetValue = TRUE;
  190.                 }
  191.             }
  192.         }
  193.         else
  194.         {
  195.             DWORD dwVal;
  196.             DWORD dwSize = sizeof(DWORD);
  198.             if  (
  199.                 (RegQueryValueEx(   hKey,
  200.                                     s_szPasswordActiveValue,
  201.                                     NULL,
  202.                                     NULL,
  203.                                     (BYTE *)&dwVal,
  204.                                     &dwSize) == ERROR_SUCCESS)
  205.                 &&
  206.                 (dwVal != 0)
  207.                 )
  208.             {
  209.                 bRetValue = TRUE;
  210.             }
  211.         }
  212.         RegCloseKey(hKey);
  213.     }
  215.     return bRetValue;
  216. }
  220. /////////////////////////////////////////////////////////////////////////////
  221. // CScreenSaverWindow::Create
  222. /////////////////////////////////////////////////////////////////////////////
  223. BOOL CScreenSaverWindow::Create
  224. (
  225.     const RECT &    rect,
  226.     HWND            hwndParent,
  227.     IScreenSaver *  pScreenSaver
  228. )
  229. {
  230.     HRESULT hrResult;
  232.     ASSERT(pScreenSaver != NULL);
  233.     TraceMsg(TF_ALWAYS, "CScreenSaverWindow::Create(hwndParent=%x)", hwndParent);
  235.     //
  236.     // Set the g_bPasswordEnabled flag
  237.     //
  238.     g_bPasswordEnabled = IsScreenSaverPasswordProtected();
  240.     for (;;)
  241.     {
  242.         // Save this pointer for Hook functions.
  243.         s_pThis = this;
  245.         // Save IScreenSaver interface pointer.
  246.         m_pScreenSaver = pScreenSaver;
  247.         m_pScreenSaver->AddRef();
  249.         // Get the Configuration interface pointer.
  250.         if (FAILED(hrResult = m_pScreenSaver->QueryInterface(IID_IScreenSaverConfig,
  251.                                                              (void **)&m_pSSConfig)))
  252.             break;
  254.         DWORD dwFeatureFlags;
  255.         EVAL(SUCCEEDED(m_pSSConfig->get_Features(&dwFeatureFlags)));
  257.         // Create the actual window.
  258.         if (!CWindow::CreateEx( NULL,
  259.                                 ((dwFeatureFlags & FEATURE_NOT_TOPMOST)
  260.                                     ? 0
  261.                                     : (WS_EX_TOOLWINDOW | WS_EX_TOPMOST)),
  262.                                 WS_POPUP,
  263.                                 rect,
  264.                                 hwndParent,
  265.                                 0))
  266.         {
  267.             hrResult = E_OUTOFMEMORY;
  268.             break;
  269.         }
  271.         TraceMsg(TF_ALWAYS, "CScreenSaverWindow::Create(m_hWnd=%x)", m_hWnd );
  273.         // If we aren't on NT, load the password verification DLL.
  274.         if (!g_bPlatformNT)
  275.             LoadPasswordDLL();
  277.         // Create PIDL for default HTML page
  278.         char szModuleName[MAX_PATH];
  279.         GetModuleFileName(_pModule->GetModuleInstance(), szModuleName, MAX_PATH);
  281.         CString strURLDefault;
  282.         strURLDefault = s_szRES;
  283.         strURLDefault += PathFindFileName(szModuleName);
  284.         strURLDefault += s_szSSEmptyFile;
  286.         EVAL(CreatePIDLFromPath(strURLDefault, &m_pidlDefault));
  288.         // Create the toolbar.
  289.         RECT rectToolbar;
  290.         rectToolbar.left    = rect.right - CX_TOOLBAR;
  291.         rectToolbar.top     = 0;
  292.         rectToolbar.right   = rectToolbar.left + CX_TOOLBAR;
  293.         rectToolbar.bottom  = rectToolbar.top + CY_TOOLBAR;
  295.         m_pToolbar = new CToolbarWindow;
  297.         if (NULL == m_pToolbar)
  298.         {
  299.             hrResult = E_OUTOFMEMORY;
  300.             break;
  301.         }
  303.         if (!m_pToolbar->Create(rectToolbar, this))
  304.         {
  305.             delete m_pToolbar;
  306.             m_pToolbar = NULL;
  308.             hrResult = E_OUTOFMEMORY;
  309.             break;
  310.         }
  312.         // Initialize the channel view list.
  313.         InitChannelList();
  315.         //  TODO: Darrenmi add online/offline registration here.
  317.         // Initialize the web browser.
  318.         if (!CreateWebBrowser(rect))
  319.         {
  320.             CString strCaption;
  321.             CString strText;
  323.             // Display error message.
  324.             strCaption.LoadString(IDS_SCREENSAVER_DESC);
  325.             strText.LoadString(IDS_ERROR_REQUIREMENTSNOTMET);
  326.             MessageBox(hwndParent, strText, strCaption, MB_OK);
  328.             hrResult = E_OUTOFMEMORY;
  329.             break;
  330.         }
  332.         // Setup the Keyboard and Mouse hooks.
  333.         SetHooks();
  335.         // Show the first channel.
  336.         DisplayCurrentChannel();
  338.         // Start the reload timer.
  339.         if (!g_bPlatformNT)
  340.         {
  341.             DWORD dwRestartTime;
  342.             EVAL(SUCCEEDED(m_pSSConfig->get_RestartTime(&dwRestartTime)));
  343.             EVAL((m_idReloadTimer = SetTimer(   ID_RESTART_TIMER,
  344.                                                 dwRestartTime,
  345.                                                 NULL)) != 0);
  346.         }
  348.         hrResult = S_OK;
  349.         break;
  350.     }
  352.     return SUCCEEDED(hrResult);
  353. }
  355. /////////////////////////////////////////////////////////////////////////////
  356. // CScreenSaverWindow::ShowControls
  357. /////////////////////////////////////////////////////////////////////////////
  358. void CScreenSaverWindow::ShowControls
  359. (
  360.     BOOL bShow
  361. )
  362. {
  363.     TraceMsg(   TF_FUNCENTRY,
  364.                 "ShowControls(%d): m_bScrollbarVisible = %d, Toolbar = %d",
  365.                 bShow, m_bScrollbarVisible, m_pToolbar->IsWindowVisible());
  367.     // Kill the current 'controls timer' and restart if needed.
  368.     if (m_idControlsTimer != 0)
  369.     {
  370.         EVAL(KillTimer(m_idControlsTimer));
  371.         m_idControlsTimer = 0;
  372.     }
  374.     // Screen saver does not need the IME.                
  375.     if (g_pfnIMMProc != NULL)
  376.     {
  377.         if (m_hPrevBrowserIMC != 0)
  378.         {
  379.             g_pfnIMMProc(m_hwndContainer, m_hPrevBrowserIMC);
  380.             m_hPrevBrowserIMC = 0;
  381.         }
  383.         ASSERT(m_hwndContainer != NULL)
  384.         m_hPrevBrowserIMC = g_pfnIMMProc(m_hwndContainer, (HIMC)NULL);
  385.     }
  387.     IHTMLBodyElement * pHTMLBodyElement = NULL;
  388.     BOOL               bLongContent = FALSE;
  390.     RECT rectClient;
  391.     GetClientRect(&rectClient);
  393.     // Check to see if the content is long enough to warrant scrollbars.
  394.     if  (
  395.         SUCCEEDED(GetHTMLBodyElement(&pHTMLBodyElement))
  396.         &&
  397.         (pHTMLBodyElement != NULL)
  398.         )
  399.     {
  400.         IHTMLTextContainer * pTxtEdit = NULL;
  402.         if  (
  403.             (SUCCEEDED(pHTMLBodyElement->QueryInterface(IID_IHTMLTextContainer,
  404.                                                         (void **)&pTxtEdit)))
  405.             &&
  406.             (pTxtEdit != NULL)
  407.             )
  408.         {
  409.             long lHeight;
  410.             EVAL(SUCCEEDED(pTxtEdit->get_scrollHeight(&lHeight)));
  412.             bLongContent = (lHeight > (rectClient.bottom - rectClient.top));
  414.             pTxtEdit->Release();
  415.         }
  416.     }
  418.     // Don't show scrollbar if we don't need them.
  419.     if (pHTMLBodyElement != NULL)
  420.     {
  421.         if (m_bScrollbarVisible != bShow)
  422.         {
  423.             BSTR bstrScroll = SysAllocString(((bShow && bLongContent)? s_szYes : s_szNo));
  425.             if (bstrScroll)
  426.             {
  427.                 pHTMLBodyElement->put_scroll(bstrScroll);
  428.                 SysFreeString(bstrScroll);
  429.                 m_bScrollbarVisible = bShow;
  430.             }
  431.         }
  433.         pHTMLBodyElement->Release();
  434.     }
  436.     // Show the toolbar, too.
  437.     if ((m_pToolbar != NULL) && (m_pToolbar->IsWindowVisible() != bShow))
  438.     {
  439.         RECT rectToolbar;
  441.         m_pToolbar->GetWindowRect(&rectToolbar);
  443.         // Position toolbar appropriately, depending
  444.         // on visibility of the scrollbar.
  445.         if (bLongContent)
  446.         {
  447.             if (rectToolbar.right == rectClient.right)
  448.             {
  449.                 OffsetRect(&rectToolbar, -GetSystemMetrics(SM_CXVSCROLL), 0);
  451.                 m_pToolbar->SetWindowPos(   NULL,
  452.                                             &rectToolbar,
  453.                                             SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOREDRAW | SWP_NOSIZE);
  454.             }
  455.         }
  456.         else
  457.         {
  458.             if (rectToolbar.right != rectClient.right)
  459.             {
  460.                 OffsetRect(&rectToolbar, GetSystemMetrics(SM_CXVSCROLL), 0);
  462.                 m_pToolbar->SetWindowPos(   NULL,
  463.                                             &rectToolbar,
  464.                                             SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOREDRAW | SWP_NOSIZE);
  465.             }
  466.         }
  468.         m_pToolbar->ShowToolbar(bShow);
  469.     }
  471.     if  (
  472.         m_bScrollbarVisible
  473.         ||
  474.         ((m_pToolbar != NULL) && m_pToolbar->IsWindowVisible())
  475.         )
  476.     {
  477.         EVAL((m_idControlsTimer = SetTimer( ID_CONTROLS_TIMER,
  478.                                             TIME_CONTROLS_TIMEOUT,
  479.                                             NULL)) != 0);
  480.     }
  482.     // REVIEW: Should use UIActivate? [jaym]
  483.     POINT pt = { 0 };
  484.     m_hwndContainer = WindowFromPoint(pt);
  485.     SetFocus(m_hwndContainer);
  486. }
  489. /////////////////////////////////////////////////////////////////////////////
  490. // CScreenSaverWindow::ShowPropertiesDlg
  491. /////////////////////////////////////////////////////////////////////////////
  492. void CScreenSaverWindow::ShowPropertiesDlg
  493. (
  494.     HWND hwndParent
  495. )
  496. {
  497.     // Save the 'current' channel.
  498.     SaveState();            
  500.     EnableModeless(FALSE);
  501.     m_pSSConfig->ShowDialog(hwndParent);
  502.     EnableModeless(TRUE);
  504.     // Reinitialize the internal channel list.
  505.     InitChannelList();
  507.     // Show the first channel in the new list.
  508.     DisplayCurrentChannel();
  509. }
  511. /////////////////////////////////////////////////////////////////////////////
  512. // CScreenSaverWindow::OnCreate
  513. /////////////////////////////////////////////////////////////////////////////
  514. BOOL CScreenSaverWindow::OnCreate
  515. (
  516.     CREATESTRUCT * pcs
  517. )
  518. {
  519.     return TRUE;
  520. }
  522. /////////////////////////////////////////////////////////////////////////////
  523. // CScreenSaverWindow::OnDestroy
  524. /////////////////////////////////////////////////////////////////////////////
  525. void CScreenSaverWindow::OnDestroy
  526. (
  527. )
  528. {
  529.     TraceMsg(TF_CLOSE, "CScreenSaverWindow::OnDestroy() BEGIN");
  531.     ReleaseHooks();
  533.     if (m_idChangeTimer != 0)
  534.         EVAL(KillTimer(m_idChangeTimer));
  536.     if (m_idControlsTimer != 0)
  537.         EVAL(KillTimer(m_idControlsTimer));
  539.     if (m_idClickCheckTimer != 0)
  540.         EVAL(KillTimer(m_idClickCheckTimer));
  542.     if (m_idReloadTimer != 0)
  543.         EVAL(KillTimer(m_idReloadTimer));
  545.     if (m_pToolbar != NULL)
  546.         delete m_pToolbar;
  548.     if (m_hPrevBrowserIMC != 0)
  549.     {
  550.         ASSERT(m_hwndContainer != NULL);
  551.         g_pfnIMMProc(m_hwndContainer, m_hPrevBrowserIMC);
  552.     }
  554.     //  TODO: Darrenmi add online/offline deregistration here.
  556.     ConnectToConnectionPoint(   SAFECAST(this, IDispatch *),
  557.                                 DIID_DWebBrowserEvents,
  558.                                 FALSE,
  559.                                 m_pUnkBrowser,
  560.                                 &m_dwWebBrowserEvents,
  561.                                 NULL);
  563.     ConnectToConnectionPoint(   SAFECAST(this, IDispatch *),
  564.                                 DIID_DWebBrowserEvents2,
  565.                                 FALSE,
  566.                                 m_pUnkBrowser,
  567.                                 &m_dwWebBrowserEvents2,
  568.                                 NULL);
  570.     if (m_pHTMLDocument != NULL)
  571.     {
  572.         // Disconnect current connection to HTMLDocumentEvents
  573.         ConnectToConnectionPoint(   SAFECAST(this, IDispatch *),
  574.                                     DIID_HTMLDocumentEvents,
  575.                                     FALSE,
  576.                                     m_pHTMLDocument,
  577.                                     &m_dwHTMLDocumentEvents,
  578.                                     NULL);
  579.         m_pHTMLDocument->Release();
  580.     }
  582.     OleSetContainedObject((IUnknown *)m_pOleObject, FALSE);
  584.     if (m_pHlinkFrame != NULL)
  585.         m_pHlinkFrame->Release();
  587.     if (m_pOleObject != NULL)
  588.     {
  589.         m_pOleObject->DoVerb(   OLEIVERB_HIDE,
  590.                                 NULL,
  591.                                 SAFECAST(this, IOleClientSite *),
  592.                                 0,
  593.                                 m_hWnd,
  594.                                 NULL);
  596.         m_pOleObject->SetClientSite(NULL);
  597.         m_pOleObject->Close(OLECLOSE_NOSAVE);
  599.         m_pOleObject->Release();
  600.     }
  602.     if (m_pWebBrowser != NULL)
  603.     {
  604.         m_pWebBrowser->Stop();
  605.         m_pWebBrowser->Release();
  606.     }
  608.     if (m_pBindStatusCallback != NULL)
  609.         EVAL(m_pBindStatusCallback->Release() == 0);
  611.     if (m_hPasswordDLL != NULL)
  612.         UnloadPasswordDLL();
  614.     if (m_pPIDLList != NULL)
  615.         delete m_pPIDLList;
  617.     if (m_pidlDefault != NULL)
  618.         g_pMalloc->Free(m_pidlDefault);
  620.     if (m_pUnkBrowser != NULL)
  621.         m_pUnkBrowser->Release();
  623.     if (m_pSSConfig != NULL)
  624.         m_pSSConfig->Release();
  626.     m_pScreenSaver->put_Running(FALSE);
  628.     if (m_pScreenSaver != NULL)
  629.         m_pScreenSaver->Release();
  631.     CWindow::OnDestroy();
  633.     PostQuitMessage(0);
  635.     TraceMsg(TF_CLOSE, "CScreenSaverWindow::OnDestroy() END");
  636. }
  638. /////////////////////////////////////////////////////////////////////////////
  639. // CScreenSaverWindow::OnEraseBkgnd
  640. /////////////////////////////////////////////////////////////////////////////
  641. BOOL CScreenSaverWindow::OnEraseBkgnd
  642. (
  643.     HDC hDC
  644. )
  645. {
  646.     return TRUE;
  647. }
  649. /////////////////////////////////////////////////////////////////////////////
  650. // CScreenSaverWindow::OnTimer
  651. /////////////////////////////////////////////////////////////////////////////
  652. void CScreenSaverWindow::OnTimer
  653. (
  654.     UINT nIDTimer
  655. )
  656. {
  657.     if  (
  658.         // Ignore if there is a dialog up or we are disabled.
  659.         !m_bModelessEnabled
  660.         ||
  661.         // Ignore if the user is selecting or scrolling.
  662.         (GetAsyncKeyState((GetSystemMetrics(SM_SWAPBUTTON) ? VK_RBUTTON : VK_LBUTTON)) & 0x8000)
  663.         )
  664.     {
  665.         return;
  666.     }
  668.     switch (nIDTimer)
  669.     {
  670.         case ID_CONTROLS_TIMER:
  671.         {
  672.             TraceMsg(TF_TIMER, "CScreenSaverWindow::OnTimer(ID_CONTROLS_TIMER)");
  674.             ShowControls(FALSE);
  675.             break;
  676.         }
  678.         case ID_CHANNELCHANGE_TIMER:
  679.         {
  680.             TraceMsg(TF_TIMER, "CScreenSaverWindow::OnTimer(ID_CHANNELCHANGE_TIMER)");
  682.             OnChannelChangeTimer();
  683.             break;
  684.         }
  686.         case ID_CLICKCHECK_TIMER:
  687.         {
  688.             TraceMsg(TF_TIMER, "CScreenSaverWindow::OnTimer(ID_CLICKCHECK_TIMER)");
  690.             ASSERT(m_idClickCheckTimer != 0);
  691.             ASSERT(m_bMouseClicked);
  693.             EVAL(KillTimer(m_idClickCheckTimer));
  694.             m_idClickCheckTimer = 0;
  696.             Quit();
  698.             break;
  699.         }
  701.         case ID_RESTART_TIMER:
  702.         {
  703.             HWND hwndTrayUI;
  705.             TraceMsg(TF_TIMER, "CScreenSaverWindow::OnTimer(ID_RELOAD_TIMER)");
  707.             // Send message which will be handled in
  708.             // WebCheck to restart the screen saver.
  709.             if ((hwndTrayUI = FindWindow(s_szTrayUIWindow, s_szTrayUIWindow)) != NULL)
  710.             {
  711.                 ::PostMessage(hwndTrayUI, WM_LOADSCREENSAVER, 0, 0);
  713.                 EVAL(KillTimer(m_idReloadTimer));
  714.                 m_idReloadTimer = 0;
  716.                 Quit(TRUE);
  717.             }
  719.             break;
  720.         }
  722.         default:
  723.             ASSERT(FALSE);
  724.     }
  725. }
  727. /////////////////////////////////////////////////////////////////////////////
  728. // CScreenSaverWindow::OnUserMessage
  729. /////////////////////////////////////////////////////////////////////////////
  730. LRESULT CScreenSaverWindow::OnUserMessage
  731. (
  732.     HWND    hWnd,
  733.     UINT    uMsg,
  734.     WPARAM  wParam,
  735.     LPARAM  lParam
  736. )
  737. {
  738.     switch (uMsg)
  739.     {
  740.         case WM_ABORTNAVIGATE:
  741.             return NavigateToDefault();
  743.         case WM_DEATHTOSAVER:
  744.             DestroyWindow(m_hWnd);
  745.             break;
  746.             
  747.         default:
  748.             break;
  749.     }
  751.     return -1;
  752. }
  754. ////////////////////////////////////////////////////////////////////////////
  755. //
  756. //
  757. #define PARAM_PROCESSED     0
  758. #define PARAM_HEADERS       1
  759. #define PARAM_POST_DATA     2
  760. #define PARAM_FRAME_NAME    3
  761. #define PARAM_FLAGS         4
  762. #define PARAM_URL           5
  763. //
  764. //
  765. //
  766. ////////////////////////////////////////////////////////////////////////////
  769. /////////////////////////////////////////////////////////////////////////////
  770. // CScreenSaverWindow::OnBeforeNavigate
  771. /////////////////////////////////////////////////////////////////////////////
  772. #define NUM_PARAM_NEWWINDOW 6
  776. HRESULT CScreenSaverWindow::OnNewWindow
  777. (
  778.     DISPPARAMS *    pDispParams,
  779.     VARIANT *       pVarResult
  780. )
  781. {
  782.     HRESULT hrResult;
  784.     for (;;)
  785.     {
  786.         if (pDispParams == NULL)
  787.         {
  788.             hrResult = DISP_E_PARAMNOTOPTIONAL;
  789.             break;
  790.         }
  792.         if (pDispParams->cArgs != NUM_PARAM_NEWWINDOW)
  793.         {
  794.             hrResult = DISP_E_BADPARAMCOUNT;
  795.             break;
  796.         }
  799.             // Check for password.
  800.         if (VerifyPassword())
  801.         {
  802.             CString strNavigateURL;
  804.             ASSERT(pDispParams->rgvarg[PARAM_URL].vt == VT_BSTR);
  805.             strNavigateURL = pDispParams->rgvarg[PARAM_URL].bstrVal;
  807.             TraceMsg(TF_NAVIGATION, "Navigate URL = '%s'rn", (LPCTSTR)strNavigateURL);
  809.             if (LaunchBrowser(strNavigateURL))
  810.             {
  811.                 // Save our state and quit the Screen Saver
  812.                 // if we successfully launched the browser.
  813.                 TraceMsg(TF_CLOSE, "Attempting to close screen saver");
  815.                 Quit(TRUE);
  816.             }
  817.             else
  818.                 MessageBeep(MB_ICONEXCLAMATION);
  819.         }
  821.         // Set the cancel flag to TRUE to disallow
  822.         // shdocvw from launching a new window
  823.         ASSERT(pDispParams->rgvarg[PARAM_PROCESSED].vt == (VT_BYREF | VT_BOOL));
  824.         *(pDispParams->rgvarg[PARAM_PROCESSED].pboolVal) = VARIANT_TRUE;
  826.         hrResult = S_OK;
  827.         break;
  828.     }
  830.     return hrResult;
  831. }
  836. /////////////////////////////////////////////////////////////////////////////
  837. // CScreenSaverWindow::OnBeforeNavigate
  838. /////////////////////////////////////////////////////////////////////////////
  839. #define NUM_PARAM_BEFORENAV 6
  841. #define PARAM_PROCESSED     0
  842. #define PARAM_HEADERS       1
  843. #define PARAM_POST_DATA     2
  844. #define PARAM_FRAME_NAME    3
  845. #define PARAM_FLAGS         4
  846. #define PARAM_URL           5
  848. HRESULT CScreenSaverWindow::OnBeforeNavigate
  849. (
  850.     DISPPARAMS *    pDispParams,
  851.     VARIANT *       pVarResult
  852. )
  853. {
  854.     HRESULT hrResult;
  856.     for (;;)
  857.     {
  858.         if (pDispParams == NULL)
  859.         {
  860.             hrResult = DISP_E_PARAMNOTOPTIONAL;
  861.             break;
  862.         }
  864.         if (pDispParams->cArgs != NUM_PARAM_BEFORENAV)
  865.         {
  866.             hrResult = DISP_E_BADPARAMCOUNT;
  867.             break;
  868.         }
  870.         DWORD dwFeatureFlags;
  871.         EVAL(SUCCEEDED(m_pSSConfig->get_Features(&dwFeatureFlags)));
  873.         // We'll skip everything until a mouse click happens
  874.         if (m_bMouseClicked && !(dwFeatureFlags & FEATURE_IGNORE_MOUSE_CLICKS))
  875.         {
  876.             ASSERT(m_idClickCheckTimer != 0);
  878.             EVAL(KillTimer(m_idClickCheckTimer));
  879.             m_idClickCheckTimer = 0;
  881.             // Check for password.
  882.             if (VerifyPassword())
  883.             {
  884.                 CString strNavigateURL;
  886.                 ASSERT(pDispParams->rgvarg[PARAM_URL].vt == VT_BSTR);
  887.                 strNavigateURL = pDispParams->rgvarg[PARAM_URL].bstrVal;
  889.                 TraceMsg(TF_NAVIGATION, "Navigate URL = '%s'rn", (LPCTSTR)strNavigateURL);
  891.                 if (LaunchBrowser(strNavigateURL))
  892.                 {
  893.                     // Save our state and quit the Screen Saver
  894.                     // if we successfully launched the browser.
  895.                     TraceMsg(TF_CLOSE, "Attempting to close screen saver");
  897.                     Quit(TRUE);
  898.                 }
  899.                 else
  900.                     MessageBeep(MB_ICONEXCLAMATION);
  901.             }
  903.             // Set the cancel flag to TRUE to disallow
  904.             // navigation in the Screen Saver itself.
  905.             ASSERT(pDispParams->rgvarg[PARAM_PROCESSED].vt == (VT_BYREF | VT_BOOL));
  906.             *(pDispParams->rgvarg[PARAM_PROCESSED].pboolVal) = VARIANT_TRUE;
  907.         }
  909.         hrResult = S_OK;
  910.         break;
  911.     }
  913.     return hrResult;
  914. }
  916. /////////////////////////////////////////////////////////////////////////////
  917. // CScreenSaverWindow::OnDocumentComplete
  918. /////////////////////////////////////////////////////////////////////////////
  919. HRESULT CScreenSaverWindow::OnDocumentComplete
  920. (
  921.     BSTR bstrURL
  922. )
  923. {
  924.     if (m_pHTMLDocument != NULL)
  925.     {
  926.         // Disconnect current connection to HTMLDocumentEvents
  927.         ConnectToConnectionPoint(   SAFECAST(this, IDispatch *),
  928.                                     DIID_HTMLDocumentEvents,
  929.                                     FALSE,
  930.                                     m_pHTMLDocument,
  931.                                     &m_dwHTMLDocumentEvents,
  932.                                     NULL);
  933.         m_pHTMLDocument->Release();
  934.         m_pHTMLDocument = NULL;
  935.     }
  937.     // Connect to new document HTMLDocumentEvents connection
  938.     if  (
  939.         SUCCEEDED(m_pWebBrowser->get_Document(&m_pHTMLDocument))
  940.         &&
  941.         (m_pHTMLDocument != NULL)
  942.         )
  943.     {
  944.         ConnectToConnectionPoint(   SAFECAST(this, IDispatch *),
  945.                                     DIID_HTMLDocumentEvents,
  946.                                     TRUE,
  947.                                     m_pHTMLDocument,
  948.                                     &m_dwHTMLDocumentEvents,
  949.                                     NULL);
  950.     }
  951.     else
  952.         TraceMsg(TF_NAVIGATION, "OnDocumentComplete: Unable to get_Document()!");
  954.     // Set the current URL property.
  955.     SUCCEEDED(m_pScreenSaver->put_CurrentURL(bstrURL));
  957. #ifdef _DEBUG
  958.     CString strURL = bstrURL;
  959.     TraceMsg(TF_NAVIGATION, "OnDocumentComplete: Current URL is "%s"", (LPCTSTR)strURL);
  960. #endif  // _DEBUG
  962.     // Hide the scrollbar and any other controls
  963.     ShowControls(FALSE);
  965.     // Start the channel change timer again.
  966.     ResetChangeTimer();
  968.     return S_OK;
  969. }
  971. /////////////////////////////////////////////////////////////////////////////
  972. // CScreenSaverWindow::OnTitleChange
  973. /////////////////////////////////////////////////////////////////////////////
  974. HRESULT CScreenSaverWindow::OnTitleChange
  975. (
  976.     BSTR bstrTitle
  977. )
  978. {
  979.     TraceMsg(TF_FUNCENTRY, "OnTitleChange()");
  981.     CString strTitle = bstrTitle;
  982.     SetWindowText(strTitle);
  984.     return S_OK;
  985. }
  987. /////////////////////////////////////////////////////////////////////////////
  988. // CScreenSaverWindow::CreateWebBrowser
  989. /////////////////////////////////////////////////////////////////////////////
  990. BOOL CScreenSaverWindow::CreateWebBrowser
  991. (
  992.     const RECT & rect
  993. )
  994. {
  995.     HRESULT hrResult;
  997.     ASSERT(m_hWnd);
  999.     for (;;)
  1000.     {
  1001.         CLSID clsidBrowser;
  1003.         if  (
  1004.             FAILED(CLSIDFromProgID(OLESTR("Shell.Explorer"), &clsidBrowser))
  1005.             ||
  1006.             FAILED(hrResult = CoCreateInstance( clsidBrowser,
  1007.                                                 NULL,
  1008.                                                 CLSCTX_INPROC_SERVER
  1009.                                                     | CLSCTX_LOCAL_SERVER,
  1010.                                                 IID_IUnknown,
  1011.                                                 (void **)&m_pUnkBrowser))
  1012.             )
  1013.         {
  1014.             TraceMsg(TF_ERROR, "Failed to create Web Browser object.");
  1015.             break;
  1016.         }
  1018.         if (FAILED(hrResult = m_pUnkBrowser->QueryInterface(IID_IWebBrowser2,
  1019.                                                             (void **)&m_pWebBrowser)))
  1020.         {
  1021.             TraceMsg(TF_ERROR, "Web browser doesn't support IWebBrowser2!");
  1022.             break;
  1023.         }
  1025.         if  (
  1026.             FAILED(hrResult = m_pUnkBrowser->QueryInterface(IID_IOleObject, (void **)&m_pOleObject))
  1027.             ||
  1028.             FAILED(hrResult = m_pOleObject->SetClientSite(SAFECAST(this, IOleClientSite *)))
  1029.             )
  1030.         {
  1031.             TraceMsg(TF_ERROR, "Failure attempting to setup IOleObject!");
  1032.             break;
  1033.         }
  1035.         IPersistStreamInit * pPersistStreamInit;
  1036.         if (SUCCEEDED(hrResult = m_pOleObject->QueryInterface(IID_IPersistStreamInit, (void **)&pPersistStreamInit)))
  1037.         {
  1038.             pPersistStreamInit->InitNew();
  1039.             pPersistStreamInit->Release();
  1040.         }
  1042.         OleSetContainedObject((IUnknown *)m_pOleObject, TRUE);
  1044.         ConnectToConnectionPoint(   SAFECAST(this, IDispatch *),
  1045.                                     DIID_DWebBrowserEvents,
  1046.                                     TRUE,
  1047.                                     m_pUnkBrowser,
  1048.                                     &m_dwWebBrowserEvents,
  1049.                                     NULL);
  1051.         ConnectToConnectionPoint(   SAFECAST(this, IDispatch *),
  1052.                                     DIID_DWebBrowserEvents2,
  1053.                                     TRUE,
  1054.                                     m_pUnkBrowser,
  1055.                                     &m_dwWebBrowserEvents2,
  1056.                                     NULL);
  1058.         // Make sure we are known as the browser
  1059.         EVAL(SUCCEEDED(m_pWebBrowser->put_RegisterAsBrowser(VARIANT_TRUE)));
  1061.         // We don't need to handle drops in the screen saver.
  1062.         EVAL(SUCCEEDED(m_pWebBrowser->put_RegisterAsDropTarget(VARIANT_FALSE)));
  1064.         // Make sure no dialogs are displayed for error conditions.
  1065.         EVAL(SUCCEEDED(m_pWebBrowser->put_Silent(VARIANT_TRUE)));
  1067.         // Make sure we get benefits of running theater mode.
  1068.         // (in particular the flat scrollbar)
  1069.         EVAL(SUCCEEDED(m_pWebBrowser->put_TheaterMode(VARIANT_TRUE)));
  1071.         // Get the Target frame and don't allow,
  1072.         // resizing, and turn off the 3D border.
  1073.         ITargetEmbedding * pTargetEmbedding;
  1074.         if (SUCCEEDED(hrResult = m_pUnkBrowser->QueryInterface( IID_ITargetEmbedding,
  1075.                                                                 (void **)&pTargetEmbedding)))
  1076.         {
  1077.             ITargetFrame * pTargetFrame;
  1079.             // Save the ITargetFrame interface pointer.
  1080.             if (SUCCEEDED(hrResult = pTargetEmbedding->GetTargetFrame(&pTargetFrame)))
  1081.             {
  1082.                 DWORD dwFrameOpts;
  1083.                 if (SUCCEEDED(pTargetFrame->GetFrameOptions(&dwFrameOpts)))
  1084.                 {
  1085.                     dwFrameOpts |= (FRAMEOPTIONS_NORESIZE
  1086.                                         | FRAMEOPTIONS_NO3DBORDER);
  1088.                     EVAL(SUCCEEDED(pTargetFrame->SetFrameOptions(dwFrameOpts)));
  1089.                 }
  1091.                 // Save the HLINK frame for navigation and setup purposes.
  1092.                 hrResult = pTargetFrame->QueryInterface(IID_IHlinkFrame,
  1093.                                                         (void **)&m_pHlinkFrame);
  1095.                 pTargetFrame->Release();
  1096.             }
  1098.             pTargetEmbedding->Release();
  1099.         }
  1101.         if (FAILED(hrResult))
  1102.         {
  1103.             TraceMsg(TF_ERROR, "Error attempting to initialize TargetEmbedding.");
  1104.             break;
  1105.         }
  1107.         // Make sure we are running in the current mode.
  1108.         DWORD dwFlags;
  1109.         VARIANT_BOOL bOffline = (InternetGetConnectedState(&dwFlags, 0)
  1110.                                     ? VARIANT_FALSE
  1111.                                     : VARIANT_TRUE);
  1113. #ifdef _DEBUG
  1114.         TraceMsg(TF_NAVIGATION, "Currently %s", ((bOffline == VARIANT_TRUE)
  1115.                                                     ? TEXT("OFFLINE")
  1116.                                                     : TEXT("ONLINE")));
  1117. #endif  // _DEBUG
  1119.         EVAL(SUCCEEDED(m_pWebBrowser->put_Offline(bOffline)));
  1121.         m_pBindStatusCallback = new CSSNavigateBSC( SAFECAST(this, CScreenSaverWindow *),
  1122.                                                     TIME_NAVIGATE_TIMEOUT);
  1124.         if (NULL == m_pBindStatusCallback)
  1125.         {
  1126.             hrResult = E_OUTOFMEMORY;
  1127.             break;
  1128.         }
  1130.         // Display the Web Browser OC.
  1131.         ShowWindow(SW_SHOWNORMAL);
  1132.         m_pOleObject->DoVerb(   OLEIVERB_SHOW,
  1133.                                 NULL,
  1134.                                 SAFECAST(this, IOleClientSite *),
  1135.                                 0,
  1136.                                 m_hWnd,
  1137.                                 &rect);
  1139.         break;
  1140.     }
  1142.     return SUCCEEDED(hrResult);
  1143. }
  1145. /////////////////////////////////////////////////////////////////////////////
  1146. // CScreenSaverWindow::GetHTMLBodyElement
  1147. /////////////////////////////////////////////////////////////////////////////
  1148. HRESULT CScreenSaverWindow::GetHTMLBodyElement
  1149. (
  1150.     IHTMLBodyElement ** ppHTMLBodyElement
  1151. )
  1152. {
  1153.     IDispatch *         pDispatch = NULL;
  1154.     IHTMLDocument2 *    pHTMLDocument = NULL;
  1155.     IHTMLElement *      pHTMLElement = NULL;
  1156.     HRESULT             hrResult;
  1158.     for (;;)
  1159.     {
  1160.         *ppHTMLBodyElement = NULL;
  1162.         if  (
  1163.             FAILED(m_pWebBrowser->get_Document(&pDispatch))
  1164.             ||
  1165.             (pDispatch == NULL)
  1166.             )
  1167.         {
  1168.             hrResult = E_FAIL;
  1169.             break;
  1170.         }
  1172.         if (FAILED(hrResult = pDispatch->QueryInterface( IID_IHTMLDocument2,
  1173.                                                          (void **)&pHTMLDocument)))
  1174.         {
  1175.             break;
  1176.         }
  1178.         if  (
  1179.             SUCCEEDED(hrResult = pHTMLDocument->get_body(&pHTMLElement))
  1180.             &&
  1181.             (pHTMLElement != NULL)
  1182.             )
  1183.         {
  1184.             hrResult = pHTMLElement->QueryInterface(IID_IHTMLBodyElement,
  1185.                                                     (void **)ppHTMLBodyElement);
  1186.         }
  1188.         break;
  1189.     }
  1191.     if (pHTMLElement != NULL)
  1192.         pHTMLElement->Release();
  1194.     if (pHTMLDocument != NULL)
  1195.         pHTMLDocument->Release();
  1197.     if (pDispatch != NULL)
  1198.         pDispatch->Release();
  1200.     return hrResult;
  1201. }
  1203. /////////////////////////////////////////////////////////////////////////////
  1204. // CScreenSaverWindow::DisplayCurrentChannel
  1205. /////////////////////////////////////////////////////////////////////////////
  1206. HRESULT CScreenSaverWindow::DisplayCurrentChannel
  1207. (
  1208. )
  1209. {
  1210.     HRESULT hrResult;
  1212.     if (m_lCurrChannel == CURRENT_CHANNEL_NONE)
  1213.         hrResult = DisplayNextChannel();
  1214.     else
  1215.     {
  1216.         if (FAILED(hrResult = DisplayChannel(m_lCurrChannel)))
  1217.         {
  1218.             TraceMsg(TF_NAVIGATION, "Unable to display channel, trying next one.");
  1219.             hrResult = DisplayNextChannel();
  1220.         }
  1221.     }
  1223.     // If everything blows up, show the default page.
  1224.     if (FAILED(hrResult))
  1225.     {
  1226.         TraceMsg(TF_NAVIGATION, "No channels are able to display. Using default.");
  1227.         hrResult = NavigateToDefault();
  1228.     }
  1230.     return hrResult;
  1231. }
  1233. /////////////////////////////////////////////////////////////////////////////
  1234. // CScreenSaverWindow::DisplayNextChannel
  1235. /////////////////////////////////////////////////////////////////////////////
  1236. HRESULT CScreenSaverWindow::DisplayNextChannel
  1237. (
  1238. )
  1239. {
  1240.     long    lStartChannel = m_lCurrChannel;
  1241.     long    lNextChannel = m_lCurrChannel;
  1242.     HRESULT hrResult;
  1244.     for (;;)
  1245.     {
  1246.         lNextChannel = FindNextChannel(lNextChannel);
  1248.         // Bail if we have gone all the way around the list.
  1249.         if (lNextChannel == lStartChannel)
  1250.         {
  1251.             TraceMsg(TF_NAVIGATION, "No new channel available...Continuing current channel.");
  1253.             hrResult = E_FAIL;
  1254.             break;
  1255.         }
  1257.         if (lNextChannel == CURRENT_CHANNEL_NONE)
  1258.             continue;
  1260.         // Continue until we loop around or have navigated successfully.
  1261.         if (SUCCEEDED(hrResult = DisplayChannel(lNextChannel)))
  1262.             break;
  1263.     }
  1265.     return hrResult;
  1266. }
  1268. /////////////////////////////////////////////////////////////////////////////
  1269. // CScreenSaverWindow::DisplayChannel
  1270. /////////////////////////////////////////////////////////////////////////////
  1271. HRESULT CScreenSaverWindow::DisplayChannel
  1272. (
  1273.     long lChannel
  1274. )
  1275. {
  1276.     LPITEMIDLIST pidlChannel = m_pPIDLList->Item(lChannel);
  1278.     ASSERT(pidlChannel != NULL);
  1280.     m_bMouseClicked = FALSE;
  1282.     HRESULT hrResult = NavigateToPIDL(pidlChannel);
  1284.     m_lCurrChannel = lChannel;
  1286.     return hrResult;
  1287. }
  1289. /////////////////////////////////////////////////////////////////////////////
  1290. // CScreenSaverWindow::NavigateToPIDL
  1291. /////////////////////////////////////////////////////////////////////////////
  1292. HRESULT CScreenSaverWindow::NavigateToPIDL
  1293. (
  1294.     LPITEMIDLIST pidl
  1295. )
  1296. {
  1297.     HRESULT hrResult = E_FAIL;
  1299.     for (;;)
  1300.     {
  1301.         CString strURL;
  1302.         TCHAR * pszURL = strURL.GetBuffer(INTERNET_MAX_URL_LENGTH);
  1303.         BOOL bResult = GetPIDLDisplayName(  NULL,
  1304.                                             pidl,
  1305.                                             pszURL,
  1306.                                             INTERNET_MAX_URL_LENGTH,
  1307.                                             SHGDN_FORPARSING);
  1308.         strURL.ReleaseBuffer();
  1310.         if (!bResult)
  1311.             break;
  1313.         BSTR bstrURL;
  1314.         if ((bstrURL = strURL.AllocSysString()) != NULL)
  1315.         {
  1316.             EVAL(SUCCEEDED(hrResult = NavigateToBSTR(bstrURL)));
  1317.             SysFreeString(bstrURL);
  1318.         }
  1320.         break;
  1321.     }
  1323.     return hrResult;
  1324. }
  1326. /////////////////////////////////////////////////////////////////////////////
  1327. // CScreenSaverWindow::NavigateToBSTR
  1328. /////////////////////////////////////////////////////////////////////////////
  1329. HRESULT CScreenSaverWindow::NavigateToBSTR
  1330. (
  1331.     BSTR bstrURL
  1332. )
  1333. {
  1335.     IMoniker *  pURLMoniker = NULL;
  1336.     IBindCtx *  pBindCtx = NULL;
  1337.     IHlink *    pHlink = NULL;
  1338.     HRESULT     hrResult;
  1340.     for (;;)
  1341.     {
  1342.         if (bstrURL == NULL)
  1343.         {
  1344.             hrResult = E_INVALIDARG;
  1345.             break;
  1346.         }
  1348.         DWORD dwFeatureFlags;
  1349.         EVAL(SUCCEEDED(m_pSSConfig->get_Features(&dwFeatureFlags)));
  1350.         if (dwFeatureFlags & FEATURE_USE_CACHED_CONTENT_FIRST)
  1351.         {
  1352.             if (FAILED(hrResult = SetConnectedState(bstrURL)))
  1353.                 break;
  1354.         }
  1355.         else
  1356.         {
  1357.             if (FAILED(hrResult = IsURLAvailable(bstrURL)))
  1358.                 break;
  1359.         }
  1361.         if  (
  1362.             FAILED(hrResult = CreateURLMoniker(NULL, bstrURL, &pURLMoniker))
  1363.             ||
  1364.             FAILED(hrResult = CreateBindCtx(0, &pBindCtx))
  1365.             ||
  1366.             FAILED(hrResult = HlinkCreateFromMoniker(   pURLMoniker,
  1367.                                                         NULL,
  1368.                                                         NULL,
  1369.                                                         NULL,
  1370.                                                         0,
  1371.                                                         NULL,
  1372.                                                         IID_IHlink,
  1373.                                                         (void **)&pHlink))
  1374.             ||
  1375.             FAILED(hrResult = m_pHlinkFrame->Navigate(  HLNF_CREATENOHISTORY,
  1376.                                                         pBindCtx,
  1377.                                                         SAFECAST(m_pBindStatusCallback, IBindStatusCallback *),
  1378.                                                         pHlink))
  1379.             )
  1380.         {
  1381.             break;
  1382.         }
  1384. #ifdef _DEBUG
  1385.         VARIANT_BOOL bOffline;
  1386.         EVAL(SUCCEEDED(m_pWebBrowser->get_Offline(&bOffline)));
  1388.         CString strURL = bstrURL;
  1390.         TraceMsg(TF_NAVIGATION, "%s: Started navigation to '%s'", (bOffline ? TEXT("OFFLINE") : TEXT("ONLINE")), (LPCTSTR)strURL);
  1391. #endif  // _DEBUG
  1393.         break;
  1394.     }
  1396.     // Cleanup
  1397.     if (pHlink != NULL)
  1398.         pHlink->Release();
  1400.     if (pBindCtx != NULL)
  1401.         pBindCtx->Release();
  1403.     if (pURLMoniker != NULL)
  1404.         pURLMoniker->Release();
  1406.     return hrResult;
  1407. }
  1409. /////////////////////////////////////////////////////////////////////////////
  1410. // CScreenSaverWindow::NavigateToDefault
  1411. /////////////////////////////////////////////////////////////////////////////
  1412. HRESULT CScreenSaverWindow::NavigateToDefault
  1413. (
  1414. )
  1415. {
  1416.     HRESULT hrResult = E_FAIL;
  1418.     for (;;)
  1419.     {
  1420.         BSTR bstrCurrentURL;
  1422.         if  (
  1423.             FAILED(m_pScreenSaver->get_CurrentURL(&bstrCurrentURL))
  1424.             ||
  1425.             (bstrCurrentURL == NULL)
  1426.             )
  1427.         {
  1428.             break;
  1429.         }
  1431.         CString strDefaultURL;
  1432.         TCHAR * pszURL = strDefaultURL.GetBuffer(INTERNET_MAX_URL_LENGTH);
  1433.         EVAL(GetPIDLDisplayName(NULL, m_pidlDefault, pszURL, INTERNET_MAX_URL_LENGTH, SHGDN_FORPARSING));
  1434.         strDefaultURL.ReleaseBuffer();
  1436.         CString strCurrentURL = bstrCurrentURL;
  1438.         if (StrCmpI(strCurrentURL, strDefaultURL) == 0)
  1439.         {
  1440.             ResetChangeTimer();
  1441.             hrResult = S_OK;
  1442.         }
  1444.         SysFreeString(bstrCurrentURL);
  1446.         break;
  1447.     }
  1449.     if (FAILED(hrResult))
  1450.         hrResult = NavigateToPIDL(m_pidlDefault);
  1452.     return hrResult;
  1453. }
  1455. /////////////////////////////////////////////////////////////////////////////
  1456. // CScreenSaverWindow::SetConnectedState
  1457. /////////////////////////////////////////////////////////////////////////////
  1458. HRESULT CScreenSaverWindow::SetConnectedState
  1459. (
  1460.     BSTR bstrURL
  1461. )
  1462. {
  1463.     if (bstrURL == NULL)
  1464.         return E_INVALIDARG;
  1466.     CString strURL = bstrURL;
  1467.     if ((LPTSTR)strURL == NULL)
  1468.         return E_OUTOFMEMORY;
  1470.     // Check for 'res://' URL
  1471.     BOOL bResURL = (StrCmpNI(strURL, s_szRES, lstrlen(s_szRES)) == 0);
  1473.     long lMode;
  1474.     EVAL(SUCCEEDED(m_pScreenSaver->get_Mode(&lMode)));
  1476.     HRESULT hrResult;
  1478.     // Check the cache for the URL first. Assume /u URLs want to hit the net.
  1479.     if  (
  1480.         (lMode != SSMODE_SINGLEURL)
  1481.         &&
  1482.         // Ignore cache check for 'res://' URLs
  1483.         !bResURL
  1484.         &&
  1485.         GetUrlCacheEntryInfoEx(strURL, NULL, NULL, NULL, NULL, NULL, 0)
  1486.         )
  1487.     {
  1488.         // Go offline and use cache content.
  1489.         TraceMsg(TF_NAVIGATION, "Going offline");
  1490.         EVAL(SUCCEEDED(m_pWebBrowser->put_Offline(VARIANT_TRUE)));
  1491.         hrResult = S_OK;
  1492.     }
  1493.     else
  1494.     {
  1495.         DWORD dwConnectState;
  1497.         // Try the internet if we have a direct connection. Ignore dialup.
  1498.         if  (
  1499.             InternetGetConnectedState(&dwConnectState, 0)
  1500.             &&
  1501.             (
  1502.                 (dwConnectState & INTERNET_CONNECTION_LAN)
  1503.                 ||
  1504.                 (dwConnectState & INTERNET_CONNECTION_PROXY)
  1505.             )
  1506.             )
  1507.         {
  1508.             if (!bResURL)
  1509.             {
  1510.                 TraceMsg(   TF_NAVIGATION,
  1511.                             "Content for '%s' not in cache! Going online",
  1512.                             (LPCTSTR)strURL);
  1514.                 EVAL(SUCCEEDED(m_pWebBrowser->put_Offline(VARIANT_FALSE)));
  1515.             }
  1516.             else
  1517.             {
  1518.                 TraceMsg(TF_NAVIGATION, "Going offline for res:// URL");
  1520.                 // Go offline for res:// URLs they should be local.
  1521.                 EVAL(SUCCEEDED(m_pWebBrowser->put_Offline(VARIANT_TRUE)));
  1522.             }
  1524.             hrResult = S_OK;
  1525.         }
  1526.         else
  1527.             hrResult = E_FAIL;
  1528.     }
  1530.     return hrResult;
  1531. }
  1533. /////////////////////////////////////////////////////////////////////////////
  1534. // CScreenSaverWindow::IsURLAvailable
  1535. /////////////////////////////////////////////////////////////////////////////
  1536. HRESULT CScreenSaverWindow::IsURLAvailable
  1537. (
  1538.     BSTR bstrURL
  1539. )
  1540. {
  1541.     if (bstrURL == NULL)
  1542.         return E_INVALIDARG;
  1544.     CString strURL = bstrURL;
  1545.     if ((LPTSTR)strURL == NULL)
  1546.         return E_OUTOFMEMORY;
  1548.     HRESULT hrResult = S_OK;
  1550.     for (;;)
  1551.     {
  1552.         // Ignore cache check for 'res://' URLs
  1553.         if (StrCmpNI(strURL, s_szRES, lstrlen(s_szRES)) == 0)
  1554.             break;
  1555.         
  1556.         long lMode;
  1557.         EVAL(SUCCEEDED(m_pScreenSaver->get_Mode(&lMode)));
  1559.         DWORD dwConnectState;
  1560.               
  1561.         if  (
  1562.             // Assume /u URLs want to hit the net.
  1563.             (lMode == SSMODE_SINGLEURL)
  1564.             ||
  1565.             // If we are online it should be available, too.
  1566.             InternetGetConnectedState(&dwConnectState, 0)
  1567.             )
  1568.         {
  1569.             TraceMsg(TF_NAVIGATION, "Going ONLINE for internet content");
  1571.             EVAL(SUCCEEDED(m_pWebBrowser->put_Offline(VARIANT_FALSE)));
  1572.             break;
  1573.         }
  1575.         // Check the cache for the URL if it is there, go offline.
  1576.         if (GetUrlCacheEntryInfoEx(strURL, NULL, NULL, NULL, NULL, NULL, 0))
  1577.         {
  1578.             TraceMsg(TF_NAVIGATION, "Going OFFLINE for cached content");
  1580.             EVAL(SUCCEEDED(m_pWebBrowser->put_Offline(VARIANT_TRUE)));
  1581.             break;
  1582.         }
  1584.         hrResult = E_FAIL;
  1585.         break;
  1586.     }
  1588.     return hrResult;
  1589. }
  1591. /////////////////////////////////////////////////////////////////////////////
  1592. // CScreenSaverWindow::ResetChangeTimer
  1593. /////////////////////////////////////////////////////////////////////////////
  1594. void CScreenSaverWindow::ResetChangeTimer
  1595. (
  1596.     BOOL bExtendedTime
  1597. )
  1598. {
  1599.     if (m_idChangeTimer != 0)
  1600.     {
  1601.         EVAL(KillTimer(m_idChangeTimer));
  1602.         m_idChangeTimer = 0;
  1603.     }
  1605.     int iChannelTime;
  1606.     EVAL(SUCCEEDED(m_pSSConfig->get_ChannelTime(&iChannelTime)));
  1608.     EVAL((m_idChangeTimer = SetTimer(   ID_CHANNELCHANGE_TIMER,
  1609.                                         (iChannelTime * 1000)
  1610.                                             + (bExtendedTime ? TIME_NAVIGATE_TIMEOUT : 0),
  1611.                                         NULL)) != 0);
  1612. }
  1614. /////////////////////////////////////////////////////////////////////////////
  1615. // CScreenSaverWindow::FindNextChannel
  1616. /////////////////////////////////////////////////////////////////////////////
  1617. long CScreenSaverWindow::FindNextChannel
  1618. (
  1619.     long lChannelStart
  1620. )
  1621. {
  1622.     if (m_pPIDLList->Count() > 0)
  1623.     {
  1624.         if (lChannelStart == CURRENT_CHANNEL_NONE)
  1625.             lChannelStart = 0;
  1626.         else
  1627.         {
  1628.             lChannelStart++;
  1629.             if (lChannelStart >= m_pPIDLList->Count())
  1630.                 lChannelStart = CURRENT_CHANNEL_NONE;
  1631.         }
  1632.     }
  1634.     return lChannelStart;
  1635. }
  1637. /////////////////////////////////////////////////////////////////////////////
  1638. // CScreenSaverWindow::LaunchBrowser
  1639. /////////////////////////////////////////////////////////////////////////////
  1640. BOOL CScreenSaverWindow::LaunchBrowser
  1641. (
  1642.     CString & strURL
  1643. )
  1644. {
  1645.     BOOL bResult = FALSE;
  1647.     for (;;)
  1648.     {
  1649.         PARSEDURL pu = { 0 };
  1650.         pu.cbSize = sizeof(PARSEDURL);
  1651.         if (FAILED(ParseURL(strURL, &pu)))
  1652.             break;
  1654.         if  (
  1655.             (pu.nScheme == URL_SCHEME_INVALID)
  1656.             ||
  1657.             (pu.nScheme == URL_SCHEME_UNKNOWN)
  1658.             ||
  1659.             (pu.nScheme == URL_SCHEME_VBSCRIPT)
  1660.             ||
  1661.             (pu.nScheme == URL_SCHEME_JAVASCRIPT)
  1662.             )
  1663.         {
  1664.             // Don't allow navigation to scripts.
  1665.             // They may need page context.
  1666.             TraceMsg(TF_NAVIGATION, "Ignoring %s -- Can't launch", (LPCTSTR)strURL);
  1667.             break;
  1668.         }
  1670.         //
  1671.         // If we are running on NT and password protection is enabled then
  1672.         // we disable launching browsers. This is because there is no way
  1673.         // to detect on the other side that the password verification succeeded
  1674.         //
  1675.         if (g_bPlatformNT && g_bPasswordEnabled)
  1676.         {
  1677.             bResult = TRUE;
  1678.             break;
  1679.         }
  1681.         if (pu.nScheme == URL_SCHEME_FILE)
  1682.         {
  1683.             // Make sure that URL is completely escaped.
  1684.             char * szURL = strURL.GetBuffer(INTERNET_MAX_URL_LENGTH);
  1685.             DWORD cchSize = INTERNET_MAX_URL_LENGTH;
  1686.             UrlEscape(szURL, szURL, &cchSize, 0);
  1687.             strURL.ReleaseBuffer();
  1688.         } 
  1690.         if (g_bPlatformNT)
  1691.         {
  1692.             // Write URL to registry and trigger event.
  1693.             WriteRegValue(  HKEY_CURRENT_USER,
  1694.                             g_szRegSubKey,
  1695.                             s_szRegLastNavURL,
  1696.                             REG_SZ,
  1697.                             (LPBYTE)(char *)strURL,
  1698.                             strURL.GetLength());
  1700.             HANDLE hTermEvent;
  1701.             if ((hTermEvent = OpenEvent(EVENT_MODIFY_STATE,
  1702.                                         FALSE,
  1703.                                         s_szSETermEvent)) != NULL)
  1704.             {
  1705.                 bResult = SetEvent(hTermEvent);
  1706.                 CloseHandle(hTermEvent);
  1707.             }
  1708.         }
  1709.         else
  1710.         {
  1711.             BSTR bstrURL = strURL.AllocSysString();
  1712.             if (bstrURL != NULL)
  1713.             {
  1714.                 bResult = SUCCEEDED(HlinkNavigateString(NULL, bstrURL));
  1715.                 SysFreeString(bstrURL);
  1716.             }
  1717.         }
  1719.         break;
  1720.     }
  1722.     return bResult;
  1723. }
  1725. /////////////////////////////////////////////////////////////////////////////
  1726. // CScreenSaverWindow::UserIsInteractive
  1727. /////////////////////////////////////////////////////////////////////////////
  1728. BOOL CScreenSaverWindow::UserIsInteractive
  1729. (
  1730. )
  1731. {
  1732.     if (g_bPlatformNT)
  1733.         return TRUE;
  1735.     // REVIEW: This is a big hack. We need to
  1736.     // find a better way to do this [jaym]
  1737.     HWND hwndCurr = ::GetWindow(m_hWnd, GW_HWNDFIRST);
  1738.     while (hwndCurr != NULL)
  1739.     {
  1740.         if (::GetWindowTextLength(hwndCurr) > 0)
  1741.         {
  1742.             TCHAR szWindowText[40];
  1743.             ::GetWindowText(hwndCurr, szWindowText, ARRAYSIZE(szWindowText));
  1745.             TraceMsg(TF_ALWAYS, "Window '%s'", szWindowText);
  1747.             if (StrCmpI(szWindowText, TEXT("DDE Server Window")) == 0)
  1748.                 return TRUE;
  1749.         }
  1751.         hwndCurr = ::GetWindow(hwndCurr, GW_HWNDNEXT);
  1752.     }
  1754.     TraceMsg(TF_ALWAYS, "USER IS NOT INTERACTIVE!");
  1756.     return FALSE;
  1757. }
  1759. /////////////////////////////////////////////////////////////////////////////
  1760. // CScreenSaverWindow::OnChannelChangeTimer
  1761. /////////////////////////////////////////////////////////////////////////////
  1762. void CScreenSaverWindow::OnChannelChangeTimer
  1763. (
  1764. )
  1765. {
  1766.     ASSERT(m_idChangeTimer != 0);
  1768.     EVAL(KillTimer(m_idChangeTimer));
  1769.     m_idChangeTimer = 0;
  1771.     if (FAILED(DisplayNextChannel()))
  1772.         ResetChangeTimer();
  1773.     else
  1774.     {
  1775.         // Just in case we don't get OnDocumentComplete()...
  1776.         ResetChangeTimer(TRUE);
  1777.     }
  1778. }
  1780. /////////////////////////////////////////////////////////////////////////////
  1781. // CScreenSaverWindow::VerifyPassword
  1782. /////////////////////////////////////////////////////////////////////////////
  1783. BOOL CScreenSaverWindow::VerifyPassword
  1784. (
  1785. )
  1786. {
  1787.     BOOL fOK = FALSE;
  1789.     //  Check to see if we are already in here.  If m_lVerifyingPassword
  1790.     //  is zero on entry then it will be set to 1 and the return from
  1791.     //  InterlockedExchange will be 0.  When we are done we call
  1792.     //  InterlockedExchange to reset the value to 0.
  1793.     if (InterlockedExchange(&m_lVerifingPassword, TRUE) == FALSE)
  1794.     {
  1795.         EnableModeless(FALSE);
  1796.         if (g_bPlatformNT)
  1797.         {
  1798.             // REVIEW: Verify password for NT users. Or, alternatively
  1799.             // figure out how to lock the workstation before the screensaver
  1800.             // activates.
  1802.             // LogonUser
  1804.             fOK = TRUE;
  1805.         }
  1806.         else
  1807.         {
  1808.             // Also disable the browser window
  1809.             HWND hBrowserWnd = NULL;
  1810.             ASSERT(m_pWebBrowser);
  1811.             if(m_pWebBrowser)
  1812.             {
  1813.                 IOleWindow *pOleWindow = NULL;
  1814.                 if(SUCCEEDED(m_pWebBrowser->QueryInterface(IID_IOleWindow, (void**)&pOleWindow)))
  1815.                 {
  1816.                     ASSERT(pOleWindow);
  1817.                     pOleWindow->GetWindow(&hBrowserWnd);
  1818.                     pOleWindow->Release();
  1819.                 }
  1821.             }
  1822.             if (m_pfnVerifyPassword != NULL)
  1823.                 fOK = m_pfnVerifyPassword(hBrowserWnd ? hBrowserWnd : m_hWnd);
  1824.             else
  1825.             {
  1826.                 // Passwords disabled or unable to load
  1827.                 // handler DLL always allow exit.
  1828.                 fOK = TRUE;
  1829.             }
  1830.         }
  1832.         EnableModeless(TRUE);
  1833.         InterlockedExchange(&m_lVerifingPassword, FALSE);
  1834.     }
  1836.     return fOK;
  1837. }
  1839. /////////////////////////////////////////////////////////////////////////////
  1840. // CScreenSaverWindow::InitChannelList
  1841. /////////////////////////////////////////////////////////////////////////////
  1842. void CScreenSaverWindow::InitChannelList
  1843. (
  1844. )
  1845. {
  1846.     if (m_pPIDLList == NULL)
  1847.         m_pPIDLList = new CPIDLList;
  1849.     if (m_pPIDLList == NULL)
  1850.         return;
  1852.     if (UserIsInteractive())
  1853.     {
  1854.         long lMode;
  1856.         EVAL(SUCCEEDED(m_pScreenSaver->get_Mode(&lMode)));
  1857.         if (lMode == SSMODE_SINGLEURL)
  1858.         {
  1859.             BSTR bstrURL;
  1861.             if  (
  1862.                 SUCCEEDED(m_pScreenSaver->get_CurrentURL(&bstrURL))
  1863.                 &&
  1864.                 (bstrURL != NULL)
  1865.                 &&
  1866.                 (SysStringLen(bstrURL) != 0)
  1867.                 )
  1868.             {
  1869.                 CString strURL = bstrURL;
  1870.                 m_pPIDLList->Add(strURL);
  1871.             }
  1873.             SysFreeString(bstrURL);
  1874.         }
  1875.         else
  1876.         {
  1877.             DWORD dwFeatureFlags;
  1878.             EVAL(SUCCEEDED(m_pSSConfig->get_Features(&dwFeatureFlags)));
  1879.             m_pPIDLList->Build(m_pSSConfig, (dwFeatureFlags & FEATURE_USE_CDF_TOPLEVEL_URL));
  1880.         }
  1881.     }
  1882.     else
  1883.         TraceMsg(TF_WARNING, "USER IS NOT LOGGED ON!");
  1885.     // If there are no current Screen Saver channels, show the
  1886.     // info. HTML message about setting up Screen Saver channels.
  1887.     if (m_pPIDLList->Count() == 0)
  1888.     {
  1889.         TraceMsg(TF_NAVIGATION, "No URLs in list -- adding default HTML");
  1890.         EVAL(m_pPIDLList->Add(CopyPIDL(m_pidlDefault)));
  1891.     }
  1892.     else
  1893.     {
  1894.         ASSERT(m_pPIDLList->Count() > 0);
  1896.         LoadState();
  1897.     }
  1899.     TraceMsg(TF_NAVIGATION, "%d URLs in list", m_pPIDLList->Count());
  1900. }
  1902. /////////////////////////////////////////////////////////////////////////////
  1903. // CScreenSaverWindow::LoadState
  1904. /////////////////////////////////////////////////////////////////////////////
  1905. void CScreenSaverWindow::LoadState
  1906. (
  1907. )
  1908. {
  1909.     CString strLastURL;
  1911.     ASSERT(m_pPIDLList != NULL);
  1913.     if (m_pPIDLList->Count() > 0)
  1914.     {
  1915.         char * pszLastURL = strLastURL.GetBuffer(INTERNET_MAX_URL_LENGTH);
  1916.         ReadRegString(  HKEY_CURRENT_USER,
  1917.                         g_szRegSubKey,
  1918.                         s_szRegLastURL,
  1919.                         TEXT(""),
  1920.                         pszLastURL,
  1921.                         INTERNET_MAX_URL_LENGTH);
  1922.         strLastURL.ReleaseBuffer();
  1924.         if (strLastURL.GetLength() > 0)
  1925.         {
  1926.             LPITEMIDLIST pidl;
  1928.             if (CreatePIDLFromPath(strLastURL, &pidl) && pidl)
  1929.             {
  1930.                 m_lCurrChannel = m_pPIDLList->Find(pidl);
  1931.                 g_pMalloc->Free(pidl);
  1932.             }
  1933.         }
  1934.     }
  1935. }
  1937. /////////////////////////////////////////////////////////////////////////////
  1938. // CScreenSaverWindow::SaveState
  1939. /////////////////////////////////////////////////////////////////////////////
  1940. void CScreenSaverWindow::SaveState
  1941. (
  1942. )
  1943. {
  1944.     CString strLastURL;
  1946.     // Save the current URL being displayed.    
  1947.     if  (
  1948.         (m_pPIDLList != NULL)
  1949.         &&
  1950.         (m_lCurrChannel != CURRENT_CHANNEL_NONE)
  1951.         )
  1952.     {
  1953.         LPITEMIDLIST pidl = m_pPIDLList->Item(m_lCurrChannel);
  1955.         char * pszLastURL = strLastURL.GetBuffer(INTERNET_MAX_URL_LENGTH);
  1956.         EVAL(GetPIDLDisplayName(NULL,
  1957.                                 pidl,
  1958.                                 pszLastURL,
  1959.                                 INTERNET_MAX_URL_LENGTH,
  1960.                                 SHGDN_FORPARSING));
  1961.         strLastURL.ReleaseBuffer();
  1962.     }
  1964.     WriteRegValue(  HKEY_CURRENT_USER,
  1965.                     g_szRegSubKey,
  1966.                     s_szRegLastURL,
  1967.                     REG_SZ,
  1968.                     (LPBYTE)(char *)strLastURL,
  1969.                     strLastURL.GetLength());
  1970. }
  1972. /////////////////////////////////////////////////////////////////////////////
  1973. // CScreenSaverWindow::LoadPasswordDLL
  1974. /////////////////////////////////////////////////////////////////////////////
  1975. void CScreenSaverWindow::LoadPasswordDLL
  1976. (
  1977. )
  1978. {
  1979.     if (m_hPasswordDLL != NULL)
  1980.         UnloadPasswordDLL();
  1982.     // Look to see if password turned on, otherwise
  1983.     // don't bother to load password handler DLL.
  1984.     if (g_bPasswordEnabled)
  1985.     {
  1986.         // Try to load the DLL that contains password proc.
  1987.         if ((m_hPasswordDLL = LoadLibrary(s_szPasswordDLL)) != NULL)
  1988.         {
  1989.             m_pfnVerifyPassword =
  1990.                 (VERIFYPWDPROC)GetProcAddress(  m_hPasswordDLL,
  1991.                                                 s_szPasswordFnName);
  1993.             if (m_pfnVerifyPassword == NULL)
  1994.                 UnloadPasswordDLL();
  1995.         }
  1996.     }
  1997. }
  1999. /////////////////////////////////////////////////////////////////////////////
  2000. // CScreenSaverWindow::UnloadPasswordDLL
  2001. /////////////////////////////////////////////////////////////////////////////
  2002. void CScreenSaverWindow::UnloadPasswordDLL
  2003. (
  2004. )
  2005. {
  2006.     if (m_hPasswordDLL != NULL)
  2007.     {
  2008.         FreeLibrary(m_hPasswordDLL);
  2010.         m_hPasswordDLL = NULL;
  2011.         m_pfnVerifyPassword = NULL;
  2012.     }
  2013. }
  2015. /////////////////////////////////////////////////////////////////////////////
  2016. // CScreenSaverWindow::SetHooks
  2017. /////////////////////////////////////////////////////////////////////////////
  2018. void CScreenSaverWindow::SetHooks
  2019. (
  2020. )
  2021. {
  2022.     ASSERT(s_hKeyboardHook == NULL);
  2023.     ASSERT(s_hMouseHook == NULL);
  2025.     s_hKeyboardHook = SetWindowsHookEx( WH_KEYBOARD,
  2026.                                         KeyboardHookProc,
  2027.                                         _pModule->GetModuleInstance(),
  2028.                                         GetCurrentThreadId());
  2030.     s_hMouseHook = SetWindowsHookEx(    WH_MOUSE,
  2031.                                         MouseHookProc,
  2032.                                         _pModule->GetModuleInstance(),
  2033.                                         GetCurrentThreadId());
  2035.     ASSERT(s_hKeyboardHook != NULL);
  2036.     ASSERT(s_hMouseHook != NULL);
  2037. }
  2039. /////////////////////////////////////////////////////////////////////////////
  2040. // KeyboardHookProc
  2041. /////////////////////////////////////////////////////////////////////////////
  2042. LRESULT CALLBACK KeyboardHookProc
  2043. (
  2044.     int     nCode,
  2045.     WPARAM  wParam,
  2046.     LPARAM  lParam
  2047. )
  2048. {
  2049.     if  (
  2050.         (nCode != HC_NOREMOVE)
  2051.         &&
  2052.         (s_pThis->ModelessEnabled())
  2053.         )
  2054.     {
  2055.         // Make sure the user is keyboarding in the Screen Saver.
  2056.         if  (s_pThis->m_hWnd != GetForegroundWindow())
  2057.         {
  2058.             // Ignore
  2059.             ;
  2060.         }
  2061.         else
  2062.         {
  2063.             switch (wParam)
  2064.             {
  2065.                 // Ignore if the user is pressing ALT
  2066.                 case VK_MENU:
  2068.                 // Ignore IMM messages (just in case!)
  2069.                 case VK_PROCESSKEY:
  2070.                     break;
  2072.                 // Check for scrolling
  2073.                 case VK_PRIOR:
  2074.                 case VK_NEXT:
  2075.                 case VK_END:
  2076.                 case VK_HOME:
  2077.                 case VK_LEFT:
  2078.                 case VK_UP:
  2079.                 case VK_RIGHT:
  2080.                 case VK_DOWN:
  2081.                 {
  2082.                     static BOOL bUp = TRUE;
  2084.                     if (bUp)
  2085.                         s_pThis->ShowControls(TRUE);
  2087.                     bUp = !bUp;
  2088.                     break;
  2089.                 }
  2091.                 // Hotkey to go to next channel.
  2092.                 case VK_ADD:
  2093.                 {
  2094.                     s_pThis->OnChannelChangeTimer();
  2095.                     break;
  2096.                 }
  2098.                 default:
  2099.                 {
  2100.                     // Ignore F-keys for easier debugging.
  2101.                     if ((wParam >= VK_F1) && (wParam <= VK_F12))
  2102.                     {
  2103.                         DWORD dwFeatureFlags;
  2104.                         s_pThis->GetFeatures(&dwFeatureFlags);
  2106.                         if (dwFeatureFlags & FEATURE_IGNORE_FKEYS)
  2107.                             break;
  2108.                     }
  2110.                     s_pThis->Quit();
  2111.                     break;
  2112.                 }
  2113.             }
  2114.         }
  2115.     }
  2117.     return CallNextHookEx(s_hKeyboardHook, nCode, wParam, lParam);
  2118. }
  2120. /////////////////////////////////////////////////////////////////////////////
  2121. // MouseHookProc
  2122. /////////////////////////////////////////////////////////////////////////////
  2123. LRESULT CALLBACK MouseHookProc
  2124. (
  2125.     int     nCode,
  2126.     WPARAM  wParam,
  2127.     LPARAM  lParam
  2128. )
  2129. {
  2130.     if  (
  2131.         (nCode != HC_NOREMOVE)
  2132.         &&
  2133.         (s_pThis->ModelessEnabled())
  2134.         &&
  2135.         // Make sure the user is mousing in the Screen Saver window.
  2136.         (s_pThis->m_hWnd == GetForegroundWindow())
  2137.     )
  2138.     {
  2139.         switch (wParam)
  2140.         {
  2141.             case WM_NCRBUTTONDOWN:
  2142.             case WM_RBUTTONDOWN:
  2143.             case WM_NCMBUTTONDOWN:
  2144.             case WM_MBUTTONDOWN:
  2145.             {
  2146.                 DWORD dwFeatureFlags;
  2147.                 s_pThis->GetFeatures(&dwFeatureFlags);
  2149.                 if (!(dwFeatureFlags & FEATURE_IGNORE_MOUSE_CLICKS))
  2150.                     s_pThis->Quit();
  2152.                 break;
  2153.             }
  2155.             case WM_MOUSEMOVE:
  2156.             {
  2157.                 static  BOOL    bMouseMoved = FALSE;
  2158.                 static  POINT   ptLast;
  2160.                 TraceMsg(TF_ALWAYS, "MouseHookProc(WM_MOUSEMOVE)");
  2162.                 // Check to see if the mouse pointer really moved.
  2163.                 if (!bMouseMoved)
  2164.                 {
  2165.                     GetCursorPos(&ptLast);
  2166.                     bMouseMoved = TRUE;
  2167.                 }
  2168.                 else
  2169.                 {
  2170.                     POINT ptCursor;
  2171.                     POINT ptCheck;
  2173.                     GetCursorPos(&ptCheck);
  2175.                     if (ptCursor.x = ptCheck.x - ptLast.x)
  2176.                     {
  2177.                         if (ptCursor.x < 0)
  2178.                             ptCursor.x *= -1;
  2179.                     }
  2181.                     if (ptCursor.y = ptCheck.y - ptLast.y)
  2182.                     {
  2183.                         if (ptCursor.y < 0)
  2184.                             ptCursor.y *= -1;
  2185.                     }
  2187.                     if ((ptCursor.x + ptCursor.y) > MOUSEMOVE_THRESHOLD)
  2188.                     {
  2189.                         // Make sure the user is pressing ALT
  2190.                         // if we are in ALT+mouse mode.
  2191.                         if  (
  2192.                             s_pThis->ALTMouseMode()
  2193.                             &&
  2194.                             !(GetAsyncKeyState(VK_MENU) & 0x8000)
  2195.                             )
  2196.                         {
  2197.                             s_pThis->Quit();
  2198.                         }
  2199.                         else
  2200.                         {
  2201.                             // Display the scrollbar while the
  2202.                             // user is moving the mouse pointer
  2203.                             s_pThis->ShowControls(TRUE);
  2204.                         }
  2206.                         ptLast = ptCheck;
  2207.                     }
  2208.                 }
  2210.                 break;
  2211.             }
  2213.             default:
  2214.                 break;
  2215.         }
  2216.     }
  2218.     return CallNextHookEx(s_hMouseHook, nCode, wParam, lParam);
  2219. }
  2221. /////////////////////////////////////////////////////////////////////////////
  2222. // CScreenSaverWindow::ReleaseHooks
  2223. /////////////////////////////////////////////////////////////////////////////
  2224. void CScreenSaverWindow::ReleaseHooks
  2225. (
  2226. )
  2227. {
  2228.     if (s_hKeyboardHook != NULL)
  2229.     {
  2230.         EVAL(UnhookWindowsHookEx(s_hKeyboardHook));
  2231.         s_hKeyboardHook = NULL;
  2232.     }
  2234.     if (s_hMouseHook != NULL)
  2235.     {
  2236.         EVAL(UnhookWindowsHookEx(s_hMouseHook));
  2237.         s_hMouseHook = NULL;
  2238.     }
  2239. }
  2241. /////////////////////////////////////////////////////////////////////////////
  2242. // Interfaces
  2243. /////////////////////////////////////////////////////////////////////////////
  2245. /////////////////////////////////////////////////////////////////////////////
  2246. // IUnknown interface
  2247. /////////////////////////////////////////////////////////////////////////////
  2248. /////////////////////////////////////////////////////////////////////////////
  2249. // CScreenSaverWindow::AddRef
  2250. /////////////////////////////////////////////////////////////////////////////
  2251. ULONG CScreenSaverWindow::AddRef
  2252. (
  2253. ) 
  2254. {
  2255.     m_cRef++;
  2257.     TraceMsg(TF_DEBUGREFCOUNT, "CScreenSaverWindow::AddRef,  m_cRef = %d", m_cRef);
  2259.     return m_cRef;
  2260. }
  2262. /////////////////////////////////////////////////////////////////////////////
  2263. // CScreenSaverWindow::Release
  2264. /////////////////////////////////////////////////////////////////////////////
  2265. ULONG CScreenSaverWindow::Release
  2266. (
  2267. )
  2268. {
  2269.     m_cRef--;
  2271.     TraceMsg(TF_DEBUGREFCOUNT, "CScreenSaverWindow::Release, m_cRef = %d", m_cRef);
  2273.     if (m_cRef < 0)
  2274.     {
  2275.         ASSERT(FALSE);
  2276.         return 0;
  2277.     }
  2279.     return m_cRef;
  2280. }
  2282. /////////////////////////////////////////////////////////////////////////////
  2283. // CScreenSaverWindow::QueryInterface
  2284. /////////////////////////////////////////////////////////////////////////////
  2285. HRESULT CScreenSaverWindow::QueryInterface
  2286. (
  2287.     REFIID      riid,
  2288.     LPVOID *    ppvObj
  2289. )
  2290. {
  2291.     IUnknown * pUnk;
  2293.     *ppvObj = NULL;
  2295.     if (InlineIsEqualGUID(riid, IID_IUnknown))
  2296.         pUnk = SAFECAST(this, IDispatch *);
  2297. #if 0
  2298.     else if (InlineIsEqualGUID(riid, IID_IServiceProvider))
  2299.         pUnk = SAFECAST(this, IServiceProvider *);
  2300. #endif
  2301.     else if (InlineIsEqualGUID(riid, IID_IOleClientSite))
  2302.         pUnk = SAFECAST(this, IOleClientSite *);
  2303.     else if (InlineIsEqualGUID(riid, IID_IOleInPlaceSite))
  2304.         pUnk = SAFECAST(this, IOleInPlaceSite *);
  2305.     else if (InlineIsEqualGUID(riid, IID_IOleInPlaceFrame))
  2306.         pUnk = SAFECAST(this, IOleInPlaceFrame *);
  2307.     else if (InlineIsEqualGUID(riid, IID_IOleContainer))
  2308.         pUnk = SAFECAST(this , IOleContainer *);
  2309.     else if (InlineIsEqualGUID(riid, IID_IOleCommandTarget))
  2310.         pUnk = SAFECAST(this, IOleCommandTarget *);
  2311.     else if (InlineIsEqualGUID(riid, IID_IBindStatusCallback))
  2312.         pUnk = SAFECAST(m_pBindStatusCallback, IBindStatusCallback *);
  2313.     else if (
  2314.             InlineIsEqualGUID(riid, IID_IDispatch)
  2315.             ||
  2316.             InlineIsEqualGUID(riid, DIID_DWebBrowserEvents)
  2317.             ||
  2318.             InlineIsEqualGUID(riid, DIID_HTMLDocumentEvents)
  2319.             )
  2320.     {
  2321.         pUnk = SAFECAST(this, IDispatch *);
  2322.     }
  2323.     else
  2324.     {
  2325. #ifdef _DEBUG
  2326.         TCHAR szName[128];
  2327.         TraceMsg(   TF_DEBUGQI,
  2328.                     "CScreenSaverWindow::QueryInterface(%s) -- FAILED",
  2329.                     DebugIIDName(riid, szName));
  2330. #endif  // _DEBUG
  2332.         return E_NOINTERFACE;
  2333.     }
  2335.     pUnk->AddRef();
  2336.     *ppvObj = (void *)pUnk;
  2338.     return S_OK;
  2339. }
  2341. /////////////////////////////////////////////////////////////////////////////
  2342. // IServiceProvider interface
  2343. /////////////////////////////////////////////////////////////////////////////
  2344. /////////////////////////////////////////////////////////////////////////////
  2345. // CScreenSaverWindow::QueryService
  2346. /////////////////////////////////////////////////////////////////////////////
  2347. HRESULT CScreenSaverWindow::QueryService
  2348. (
  2349.     REFGUID guidService,
  2350.     REFIID  riid,
  2351.     void ** ppvObj
  2352. )
  2353. {
  2354.     IUnknown *  pUnk;
  2355.     HRESULT     hrResult = S_OK;
  2357.     *ppvObj = NULL;
  2359.     if (InlineIsEqualGUID(guidService, SID_STopLevelBrowser))
  2360.     {
  2361.         if (InlineIsEqualGUID(riid, IID_IServiceProvider))
  2362.             pUnk = SAFECAST(this, IServiceProvider *);
  2363.         else if (InlineIsEqualGUID(riid, IID_IOleCommandTarget))
  2364.             pUnk = SAFECAST(this, IOleCommandTarget *);
  2365.         else
  2366.             hrResult = E_NOINTERFACE;
  2367.     }
  2368.     else if (InlineIsEqualGUID(guidService, IID_IHlinkFrame))
  2369.     {
  2370.         if (InlineIsEqualGUID(riid, IID_IBindStatusCallback))
  2371.             pUnk = SAFECAST(m_pBindStatusCallback, IBindStatusCallback *);
  2372.     }
  2373.     else
  2374.         hrResult = E_NOINTERFACE;
  2376.     if (SUCCEEDED(hrResult))
  2377.     {
  2378.         pUnk->AddRef();
  2379.         *ppvObj = (void *)pUnk;
  2380.     }
  2381. #ifdef _DEBUG
  2382.     else
  2383.     {
  2384.         TCHAR szServiceName[128];
  2385.         DebugCLSIDName(guidService, szServiceName);
  2387.         TCHAR szRIIDName[128];
  2388.         DebugCLSIDName(riid, szRIIDName);
  2390.         TraceMsg(   TF_DEBUGQS,
  2391.                     "CScreenSaverWindow::QueryService(%s, %s) - FAILED",
  2392.                     szServiceName,
  2393.                     szRIIDName);
  2394.     }
  2395. #endif  // _DEBUG
  2397.     return hrResult;
  2398. }
  2401. /////////////////////////////////////////////////////////////////////////////
  2402. // IOleClientSite interface
  2403. /////////////////////////////////////////////////////////////////////////////
  2404. /////////////////////////////////////////////////////////////////////////////
  2405. // CScreenSaverWindow::SaveObject
  2406. /////////////////////////////////////////////////////////////////////////////
  2407. STDMETHODIMP CScreenSaverWindow::SaveObject
  2408. (
  2409. )
  2410. {
  2411.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::SaveObject()");
  2412.     return S_OK;
  2413. }
  2415. /////////////////////////////////////////////////////////////////////////////
  2416. // CScreenSaverWindow::GetMoniker
  2417. /////////////////////////////////////////////////////////////////////////////
  2418. STDMETHODIMP CScreenSaverWindow::GetMoniker
  2419. (
  2420.     DWORD       dwAssign,
  2421.     DWORD       dwWhichMoniker,
  2422.     IMoniker ** ppmk
  2423. )
  2424. {
  2425.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::GetMoniker()");
  2426.     return E_INVALIDARG;
  2427. }
  2429. /////////////////////////////////////////////////////////////////////////////
  2430. // CScreenSaverWindow::GetContainer
  2431. /////////////////////////////////////////////////////////////////////////////
  2432. STDMETHODIMP CScreenSaverWindow::GetContainer
  2433. (
  2434.     IOleContainer ** ppContainer
  2435. )
  2436. {
  2437.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::GetContainer()");
  2439.     *ppContainer = SAFECAST(this, IOleContainer *);
  2440.     (*ppContainer)->AddRef();
  2442.     return S_OK;
  2443. }
  2445. /////////////////////////////////////////////////////////////////////////////
  2446. // CScreenSaverWindow::ShowObject
  2447. /////////////////////////////////////////////////////////////////////////////
  2448. STDMETHODIMP CScreenSaverWindow::ShowObject
  2449. (
  2450. )
  2451. {
  2452.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::ShowObject()");
  2453.     return E_NOTIMPL;
  2454. }
  2456. /////////////////////////////////////////////////////////////////////////////
  2457. // CScreenSaverWindow::OnShowWindow
  2458. /////////////////////////////////////////////////////////////////////////////
  2459. STDMETHODIMP CScreenSaverWindow::OnShowWindow
  2460. (
  2461.     BOOL fShow
  2462. )
  2463. {
  2464.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::OnShowWindow()");
  2465.     return E_NOTIMPL;
  2466. }
  2468. /////////////////////////////////////////////////////////////////////////////
  2469. // CScreenSaverWindow::RequestNewObjectLayout
  2470. /////////////////////////////////////////////////////////////////////////////
  2471. STDMETHODIMP CScreenSaverWindow::RequestNewObjectLayout
  2472. (
  2473. )
  2474. {
  2475.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::RequestNewObjectLayout()");
  2476.     return E_NOTIMPL;
  2477. }
  2479. /////////////////////////////////////////////////////////////////////////////
  2480. // IOleWindow interface
  2481. /////////////////////////////////////////////////////////////////////////////
  2482. /////////////////////////////////////////////////////////////////////////////
  2483. // CScreenSaverWindow::GetWindow
  2484. /////////////////////////////////////////////////////////////////////////////
  2485. HRESULT CScreenSaverWindow::GetWindow
  2486. (
  2487.     HWND * phWnd
  2488. )
  2489. {
  2490.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::GetWindow()");
  2492.     ASSERT(m_hWnd != NULL);
  2494.     *phWnd = m_hWnd;
  2495.     return S_OK;
  2496. }
  2498. /////////////////////////////////////////////////////////////////////////////
  2499. // CScreenSaverWindow::ContextSensitiveHelp
  2500. /////////////////////////////////////////////////////////////////////////////
  2501. HRESULT CScreenSaverWindow::ContextSensitiveHelp
  2502. (
  2503.     BOOL fEnterMode
  2504. )
  2505. {
  2506.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::ContextSensitiveHelp()");
  2507.     return E_NOTIMPL;
  2508. }
  2510. /////////////////////////////////////////////////////////////////////////////
  2511. // IOleInPlaceSite
  2512. /////////////////////////////////////////////////////////////////////////////
  2513. /////////////////////////////////////////////////////////////////////////////
  2514. // CScreenSaverWindow::CanInPlaceActivate
  2515. /////////////////////////////////////////////////////////////////////////////
  2516. HRESULT CScreenSaverWindow::CanInPlaceActivate
  2517. (
  2518. )
  2519. {
  2520.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::CanInPlaceActivate()");
  2521.     return S_OK;
  2522. }
  2524. /////////////////////////////////////////////////////////////////////////////
  2525. // CScreenSaverWindow::OnInPlaceActivate
  2526. /////////////////////////////////////////////////////////////////////////////
  2527. HRESULT CScreenSaverWindow::OnInPlaceActivate
  2528. (
  2529. )
  2530. {
  2531.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::OnInPlaceActivate()");
  2532.     return S_OK;
  2533. }
  2535. /////////////////////////////////////////////////////////////////////////////
  2536. // CScreenSaverWindow::OnUIActivate
  2537. /////////////////////////////////////////////////////////////////////////////
  2538. HRESULT CScreenSaverWindow::OnUIActivate
  2539. (
  2540. )
  2541. {
  2542.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::OnUIActivate()");
  2543.     return S_OK;
  2544. }
  2546. /////////////////////////////////////////////////////////////////////////////
  2547. // CScreenSaverWindow::GetWindowContext
  2548. /////////////////////////////////////////////////////////////////////////////
  2549. HRESULT CScreenSaverWindow::GetWindowContext
  2550. (
  2551.     IOleInPlaceFrame **     ppFrame,
  2552.     IOleInPlaceUIWindow **  ppDoc,
  2553.     LPRECT                  lprcPosRect,
  2554.     LPRECT                  lprcClipRect,
  2555.     LPOLEINPLACEFRAMEINFO   lpFrameInfo
  2556. )
  2557. {
  2558.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::GetWindowContext()");
  2560.     *ppFrame = (IOleInPlaceFrame *)this;
  2561.     (*ppFrame)->AddRef();
  2563.     // NULL means same ptr as ppFrame.
  2564.     *ppDoc = NULL;
  2566.     GetClientRect(lprcClipRect);
  2567.     *lprcPosRect = *lprcClipRect;
  2569.     lpFrameInfo->cb = sizeof(OLEINPLACEFRAMEINFO);
  2570.     lpFrameInfo->fMDIApp = FALSE;
  2571.     lpFrameInfo->hwndFrame = m_hWnd;
  2572.     lpFrameInfo->haccel = 0;
  2573.     lpFrameInfo->cAccelEntries = 0;
  2575.     return S_OK;
  2576. }
  2578. /////////////////////////////////////////////////////////////////////////////
  2579. // CScreenSaverWindow::Scroll
  2580. /////////////////////////////////////////////////////////////////////////////
  2581. HRESULT CScreenSaverWindow::Scroll
  2582. (
  2583.     SIZE scrollExtent
  2584. )
  2585. {
  2586.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::Scroll()");
  2587.     return E_NOTIMPL;
  2588. }
  2590. /////////////////////////////////////////////////////////////////////////////
  2591. // CScreenSaverWindow::OnUIDeactivate
  2592. /////////////////////////////////////////////////////////////////////////////
  2593. HRESULT CScreenSaverWindow::OnUIDeactivate
  2594. (
  2595.     BOOL fUndoable
  2596. )
  2597. {
  2598.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::OnUIDeactivate()");
  2599.     return S_OK;
  2600. }
  2602. /////////////////////////////////////////////////////////////////////////////
  2603. // CScreenSaverWindow::OnInPlaceDeactivate
  2604. /////////////////////////////////////////////////////////////////////////////
  2605. HRESULT CScreenSaverWindow::OnInPlaceDeactivate
  2606. (
  2607. )
  2608. {
  2609.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::OnInPlaceDeactivate()");
  2610.     return S_OK;
  2611. }
  2613. /////////////////////////////////////////////////////////////////////////////
  2614. // CScreenSaverWindow::DiscardUndoState
  2615. /////////////////////////////////////////////////////////////////////////////
  2616. HRESULT CScreenSaverWindow::DiscardUndoState
  2617. (
  2618. )
  2619. {
  2620.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::DiscardUndoState()");
  2621.     return S_OK;
  2622. }
  2624. /////////////////////////////////////////////////////////////////////////////
  2625. // CScreenSaverWindow::DeactivateAndUndo
  2626. /////////////////////////////////////////////////////////////////////////////
  2627. HRESULT CScreenSaverWindow::DeactivateAndUndo
  2628. (
  2629. )
  2630. {
  2631.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::DeactivateAndUndo()");
  2632.     return S_OK;
  2633. }
  2635. /////////////////////////////////////////////////////////////////////////////
  2636. // CScreenSaverWindow::OnPosRectChange
  2637. /////////////////////////////////////////////////////////////////////////////
  2638. HRESULT CScreenSaverWindow::OnPosRectChange
  2639. (
  2640.     LPCRECT lprcPosRect
  2641. )
  2642. {
  2643.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::OnPosRectChange()");
  2644.     return E_NOTIMPL;
  2645. }
  2647. /////////////////////////////////////////////////////////////////////////////
  2648. // IOleInPlaceUIWindow interface
  2649. /////////////////////////////////////////////////////////////////////////////
  2650. /////////////////////////////////////////////////////////////////////////////
  2651. // CScreenSaverWindow::GetBorder
  2652. /////////////////////////////////////////////////////////////////////////////
  2653. HRESULT CScreenSaverWindow::GetBorder
  2654. (
  2655.     LPRECT lprectBorder
  2656. )
  2657. {
  2658.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::GetBorder()");
  2660.     GetClientRect(lprectBorder);
  2661.     return S_OK;
  2662. }
  2664. /////////////////////////////////////////////////////////////////////////////
  2665. // CScreenSaverWindow::RequestBorderSpace
  2666. /////////////////////////////////////////////////////////////////////////////
  2667. HRESULT CScreenSaverWindow::RequestBorderSpace
  2668. (
  2669.     LPCBORDERWIDTHS pbw
  2670. )
  2671. {
  2672.     RECT    rcClient;
  2673.     HRESULT hres = S_OK;
  2675.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::RequestBorderSpace()");
  2677.     GetClientRect(&rcClient);
  2678.     if (pbw->left + pbw->right > rcClient.right/2)
  2679.         hres = INPLACE_E_NOTOOLSPACE;
  2680.     else if (pbw->top + pbw->bottom > rcClient.bottom/2)
  2681.         hres = INPLACE_E_NOTOOLSPACE;
  2683.     return hres;
  2684. }
  2686. /////////////////////////////////////////////////////////////////////////////
  2687. // CScreenSaverWindow::SetBorderSpace
  2688. /////////////////////////////////////////////////////////////////////////////
  2689. HRESULT CScreenSaverWindow::SetBorderSpace
  2690. (
  2691.     LPCBORDERWIDTHS pbw
  2692. )
  2693. {
  2694.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::SetBorderSpace()");
  2695.     return S_OK;
  2696. }
  2698. /////////////////////////////////////////////////////////////////////////////
  2699. // CScreenSaverWindow::SetActiveObject
  2700. /////////////////////////////////////////////////////////////////////////////
  2701. HRESULT CScreenSaverWindow::SetActiveObject
  2702. (
  2703.     IOleInPlaceActiveObject *   pActiveObject,
  2704.     LPCOLESTR                   pszObjName
  2705. )
  2706. {
  2707.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::SetActiveObject()");
  2708.     return S_OK;
  2709. }
  2711. /////////////////////////////////////////////////////////////////////////////
  2712. // IOleInPlaceFrame interface
  2713. /////////////////////////////////////////////////////////////////////////////
  2714. /////////////////////////////////////////////////////////////////////////////
  2715. // CScreenSaverWindow::InsertMenus
  2716. /////////////////////////////////////////////////////////////////////////////
  2717. HRESULT CScreenSaverWindow::InsertMenus
  2718. (
  2719.     HMENU                   hmenuShared,
  2720.     LPOLEMENUGROUPWIDTHS    lpMenuWidths
  2721. )
  2722. {
  2723.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::InsertMenus()");
  2724.     return S_OK;
  2725. }
  2727. /////////////////////////////////////////////////////////////////////////////
  2728. // CScreenSaverWindow::SetMenu
  2729. /////////////////////////////////////////////////////////////////////////////
  2730. HRESULT CScreenSaverWindow::SetMenu
  2731. (
  2732.     HMENU       hmenuShared,
  2733.     HOLEMENU    holemenu,
  2734.     HWND        hwndActiveObject
  2735. )
  2736. {
  2737.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::SetMenu()");
  2738.     return S_OK;
  2739. }
  2741. /////////////////////////////////////////////////////////////////////////////
  2742. // CScreenSaverWindow::RemoveMenus
  2743. /////////////////////////////////////////////////////////////////////////////
  2744. HRESULT CScreenSaverWindow::RemoveMenus
  2745. (
  2746.     HMENU hmenuShared
  2747. )
  2748. {
  2749.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::RemoveMenus()");
  2750.     return S_OK;
  2751. }
  2753. /////////////////////////////////////////////////////////////////////////////
  2754. // CScreenSaverWindow::SetStatusText
  2755. /////////////////////////////////////////////////////////////////////////////
  2756. HRESULT CScreenSaverWindow::SetStatusText
  2757. (
  2758.     LPCOLESTR pszStatusText
  2759. )
  2760. {
  2761.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::SetStatusText()");
  2762.     return S_OK;
  2763. }
  2765. /////////////////////////////////////////////////////////////////////////////
  2766. // CScreenSaverWindow::EnableModeless
  2767. /////////////////////////////////////////////////////////////////////////////
  2768. HRESULT CScreenSaverWindow::EnableModeless
  2769. (
  2770.     BOOL fEnable
  2771. )
  2772. {
  2773. #ifdef _DEBUG
  2774.     TraceMsg(   TF_FUNCENTRY,
  2775.                 "CScreenSaverWindow::EnableModeless(%s)rn",
  2776.                 (fEnable ? TEXT("TRUE") : TEXT("FALSE")));
  2777. #endif  // _DEBUG
  2779.     m_bModelessEnabled = fEnable;
  2780.     EnableWindow(m_bModelessEnabled);
  2782.     if  (
  2783.         (m_pToolbar != NULL)
  2784.         &&
  2785.         IsWindow(m_pToolbar->m_hWnd)
  2786.         )
  2787.     {
  2788.         m_pToolbar->EnableWindow(m_bModelessEnabled);
  2789.     }
  2791.     return S_OK;
  2792. }
  2794. /////////////////////////////////////////////////////////////////////////////
  2795. // CScreenSaverWindow::TranslateAccelerator
  2796. /////////////////////////////////////////////////////////////////////////////
  2797. HRESULT CScreenSaverWindow::TranslateAccelerator
  2798. (
  2799.     LPMSG   lpmsg,
  2800.     WORD    wID
  2801. )
  2802. {
  2803.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::TranslateAccelerator()");
  2804.     return S_OK;
  2805. }
  2808. /////////////////////////////////////////////////////////////////////////////
  2809. // IOleContainer interface
  2810. /////////////////////////////////////////////////////////////////////////////
  2811. /////////////////////////////////////////////////////////////////////////////
  2812. // CScreenSaverWindow::ParseDisplayName
  2813. /////////////////////////////////////////////////////////////////////////////
  2814. HRESULT CScreenSaverWindow::ParseDisplayName
  2815. (
  2816.     IBindCtx *  pbc,
  2817.     LPOLESTR    pszDisplayName,
  2818.     ULONG *     pchEaten,
  2819.     IMoniker ** ppmkOut
  2820. )
  2821. {
  2822.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::ParseDisplayName()");
  2823.     return E_NOTIMPL;
  2824. }
  2826. /////////////////////////////////////////////////////////////////////////////
  2827. // CScreenSaverWindow::EnumObjects
  2828. /////////////////////////////////////////////////////////////////////////////
  2829. HRESULT CScreenSaverWindow::EnumObjects
  2830. (
  2831.     DWORD           grfFlags,
  2832.     IEnumUnknown ** ppenum
  2833. )
  2834. {
  2835.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::EnumObjects()");
  2836.     return E_NOTIMPL;
  2837. }
  2839. /////////////////////////////////////////////////////////////////////////////
  2840. // CScreenSaverWindow::LockContainer
  2841. /////////////////////////////////////////////////////////////////////////////
  2842. HRESULT CScreenSaverWindow::LockContainer
  2843. (
  2844.     BOOL fLock
  2845. )
  2846. {
  2847.     TraceMsg(TF_FUNCENTRY, "CScreenSaverWindow::LockContianer(%d)", fLock);
  2848.     return S_OK;
  2849. }
  2852. /////////////////////////////////////////////////////////////////////////////
  2853. // IOleCommandTarget interface
  2854. /////////////////////////////////////////////////////////////////////////////
  2855. /////////////////////////////////////////////////////////////////////////////
  2856. // CScreenSaverWindow::QueryStatus
  2857. /////////////////////////////////////////////////////////////////////////////
  2858. HRESULT CScreenSaverWindow::QueryStatus
  2859. (
  2860.     const GUID *    pguidCmdGroup,
  2861.     ULONG           cCmds,
  2862.     OLECMD          prgCmds[],
  2863.     OLECMDTEXT *    pCmdText
  2864. )
  2865. {
  2866.     if (prgCmds == NULL)
  2867.         return E_POINTER;
  2869.     return S_OK;
  2870. }
  2872. /////////////////////////////////////////////////////////////////////////////
  2873. // CScreenSaverWindow::Exec
  2874. /////////////////////////////////////////////////////////////////////////////
  2875. HRESULT CScreenSaverWindow::Exec
  2876. (
  2877.     const GUID *    pguidCmdGroup,
  2878.     DWORD           nCmdID,
  2879.     DWORD           nCmdExecOpt,
  2880.     VARIANTARG *    pvaIn,
  2881.     VARIANTARG *    pvaOut
  2882. )
  2883. {
  2884.     if (pguidCmdGroup == NULL)
  2885.         return OLECMDERR_E_NOTSUPPORTED;
  2887.     if (!InlineIsEqualGUID(*pguidCmdGroup, CGID_ShellDocView))
  2888.         return OLECMDERR_E_UNKNOWNGROUP;
  2890.     HRESULT hrResult;
  2892.     switch (nCmdID)
  2893.     {
  2894.         case SHDVID_GETTRANSITION:
  2895.         {
  2896.             // Make sure the feature is enabled
  2897.             DWORD dwFeatureFlags;
  2898.             EVAL(SUCCEEDED(m_pSSConfig->get_Features(&dwFeatureFlags)));
  2899.             if (!(dwFeatureFlags & FEATURE_DEFAULT_TRANSITIONS))
  2900.             {
  2901.                 hrResult = OLECMDERR_E_NOTSUPPORTED;
  2902.                 break;
  2903.             }
  2905.             switch (nCmdExecOpt)
  2906.             {
  2907.                 case OLECMDEXECOPT_DODEFAULT:
  2908.                 {
  2909.                     // Validate In/Out args.
  2910.                     if ((pvaIn == NULL) || (pvaOut == NULL))
  2911.                         return E_UNEXPECTED;
  2913.                     V_VT(&pvaOut[0]) = VT_I4;
  2914.                     V_I4(&pvaOut[0]) = 0;
  2916.                     V_VT(&pvaOut[1]) = VT_BSTR;
  2917.                     V_BSTR(&pvaOut[1]) = SysAllocString(s_szDefTransition);
  2919.                     if (NULL == V_BSTR(&pvaOut[1]))
  2920.                         hrResult = E_OUTOFMEMORY;
  2921.                     else
  2922.                         hrResult = S_OK;
  2923.                     break;
  2924.                 }
  2926.                 case OLECMDEXECOPT_SHOWHELP:
  2927.                 {
  2928.                     hrResult = OLECMDERR_E_NOHELP;
  2929.                     break;
  2930.                 }
  2932.                 default:
  2933.                 {
  2934.                     hrResult = OLECMDERR_E_NOTSUPPORTED;
  2935.                     break;
  2936.                 }
  2937.             }
  2939.             break;
  2940.         }
  2942.         default:
  2943.         {
  2944.             hrResult = OLECMDERR_E_NOTSUPPORTED;
  2945.             break;
  2946.         }
  2947.     }
  2949.     return hrResult;
  2950. }
  2953. /////////////////////////////////////////////////////////////////////////////
  2954. // IDispatch interface
  2955. /////////////////////////////////////////////////////////////////////////////
  2956. /////////////////////////////////////////////////////////////////////////////
  2957. // CScreenSaverWindow::GetTypeInfoCount
  2958. /////////////////////////////////////////////////////////////////////////////
  2959. STDMETHODIMP CScreenSaverWindow::GetTypeInfoCount
  2960. (
  2961.     UINT * pctInfo
  2962. )
  2963. {
  2964.     *pctInfo = NULL;
  2966.     return E_NOTIMPL;
  2967. }
  2969. /////////////////////////////////////////////////////////////////////////////
  2970. // CScreenSaverWindow::GetTypeInfo
  2971. /////////////////////////////////////////////////////////////////////////////
  2972. STDMETHODIMP CScreenSaverWindow::GetTypeInfo
  2973. (
  2974.     UINT            itinfo,
  2975.     LCID            lcid,
  2976.     ITypeInfo **    pptInfo
  2977. )
  2978. {
  2979.     *pptInfo = NULL;
  2981.     return E_NOTIMPL;
  2982. }
  2984. /////////////////////////////////////////////////////////////////////////////
  2985. // CScreenSaverWindow::GetIDsOfNames
  2986. /////////////////////////////////////////////////////////////////////////////
  2987. STDMETHODIMP CScreenSaverWindow::GetIDsOfNames
  2988. (
  2989.     REFIID      riid,
  2990.     OLECHAR **  rgszNames,
  2991.     UINT        cNames,
  2992.     LCID        lcid,
  2993.     DISPID *    rgDispID
  2994. )
  2995. {
  2996.     *rgszNames = NULL;
  2997.     *rgDispID = NULL;
  2999.     return E_NOTIMPL;
  3000. }
  3002. /////////////////////////////////////////////////////////////////////////////
  3003. // CScreenSaverWindow::Invoke
  3004. /////////////////////////////////////////////////////////////////////////////
  3005. STDMETHODIMP CScreenSaverWindow::Invoke
  3006. (
  3007.     DISPID          dispIDMember,
  3008.     REFIID          riid,
  3009.     LCID            lcid,
  3010.     unsigned short  wFlags,
  3011.     DISPPARAMS *    pDispParams,
  3012.     VARIANT *       pVarResult,
  3013.     EXCEPINFO *     pExcepInfo,
  3014.     UINT *          puArgErr)
  3015. {
  3016.     VARIANT varResult;
  3017.     HRESULT hrResult = S_OK;
  3019.     for (;;)
  3020.     {
  3021.         if (!InlineIsEqualGUID(riid, IID_NULL))
  3022.         {
  3023.             hrResult = E_INVALIDARG;
  3024.             break;
  3025.         }
  3027.         // We don't handle the return value of any events if
  3028.         // events have them.  We should, however, initialize an
  3029.         // empty return value just so it's not garbage.
  3030.         if (pVarResult == NULL)
  3031.             pVarResult = &varResult;
  3033.         VariantInit(pVarResult);
  3034.         V_VT(pVarResult) = VT_EMPTY;
  3036.         // Only method and get calls are valid.
  3037.         if (wFlags & ~(DISPATCH_METHOD | DISPATCH_PROPERTYGET))
  3038.         {
  3039.             hrResult = DISP_E_MEMBERNOTFOUND;
  3040.             break;
  3041.         }
  3043.         // Process the event by looking for dispIDMember in the
  3044.         // list maintained in the tenant that maps event IDs to
  3045.         // actions.  If we find the ID, then we execute the action,
  3046.         // otherwise we do nothing.
  3047.         switch (dispIDMember)
  3048.         {
  3049.             case DISPID_AMBIENT_DLCONTROL:
  3050.             {
  3051.                 TraceMsg(TF_NAVIGATION, "NAV: Returning DLCTL ambient");
  3052.                 
  3053.                 VARIANT_BOOL bPlaySounds;
  3054.                 EVAL(SUCCEEDED(m_pSSConfig->get_PlaySounds(&bPlaySounds)));
  3056.                 VARIANT_BOOL bOffline;
  3057.                 EVAL(SUCCEEDED(m_pWebBrowser->get_Offline(&bOffline)));
  3059.                 V_VT(pVarResult) = VT_I4;
  3060.                 V_I4(pVarResult) = DLCTL_SILENT
  3061.                                     | ((bOffline == VARIANT_TRUE) ? DLCTL_OFFLINE : 0)
  3062.                                     | DLCTL_DLIMAGES
  3063.                                     | DLCTL_VIDEOS
  3064.                                     | ((bPlaySounds == VARIANT_TRUE) ? DLCTL_BGSOUNDS : 0);
  3065.                 break;                                        
  3066.             }
  3067.                 
  3068.             case DISPID_BEFORENAVIGATE:
  3069.             case DISPID_FRAMEBEFORENAVIGATE:
  3070.             {
  3071.                 TraceMsg(TF_NAVIGATION, "NAV: OnBeforeNavigate(Frame = %d)", (dispIDMember == DISPID_FRAMEBEFORENAVIGATE));
  3073.                 m_bScrollbarVisible = TRUE;
  3075.                 hrResult = OnBeforeNavigate(pDispParams, pVarResult);
  3076.                 break;
  3077.             }
  3079.             case DISPID_NEWWINDOW:
  3080.             case DISPID_FRAMENEWWINDOW:
  3081.             {
  3082.                 TraceMsg(TF_NAVIGATION, "NAV: OnNewWindow(Frame = %d)", (dispIDMember == DISPID_FRAMEBEFORENAVIGATE));
  3083.                 m_bScrollbarVisible = TRUE;
  3084.                 hrResult = OnNewWindow(pDispParams, pVarResult);  
  3085.                 break;
  3086.             }
  3088.             case DISPID_DOCUMENTCOMPLETE:
  3089.             {
  3090.                 TraceMsg(TF_NAVIGATION, "NAV: DocumentComplete()");
  3092.                 if (pDispParams == NULL)
  3093.                 {
  3094.                     hrResult = DISP_E_PARAMNOTOPTIONAL;
  3095.                     break;
  3096.                 }
  3098.                 ASSERT(V_VT(&pDispParams->rgvarg[0]) == (VT_VARIANT | VT_BYREF));
  3099.                 ASSERT(V_VT(V_VARIANTREF(&pDispParams->rgvarg[0])) == VT_BSTR);
  3101.                 OnDocumentComplete(V_BSTR(V_VARIANTREF(&pDispParams->rgvarg[0])));
  3102.                 break;
  3103.             }
  3105.             case DISPID_TITLECHANGE:
  3106.             {
  3107.                 if (pDispParams == NULL)
  3108.                 {
  3109.                     hrResult = DISP_E_PARAMNOTOPTIONAL;
  3110.                     break;
  3111.                 }
  3113.                 if (pDispParams->cArgs != 1)
  3114.                 {
  3115.                     hrResult = DISP_E_BADPARAMCOUNT;
  3116.                     break;
  3117.                 }
  3119.                 ASSERT(V_VT(&pDispParams->rgvarg[0]) == VT_BSTR);
  3120.     
  3121.                 hrResult = OnTitleChange(V_BSTR(&pDispParams->rgvarg[0]));
  3122.                 break;
  3123.             }
  3125.             case DISPID_HTMLDOCUMENTEVENTS_ONCLICK:
  3126.             {
  3127.                 DWORD dwFeatureFlags;
  3128.                 EVAL(SUCCEEDED(m_pSSConfig->get_Features(&dwFeatureFlags)));
  3130.                 if (!(dwFeatureFlags & FEATURE_IGNORE_MOUSE_CLICKS))
  3131.                 {
  3132.                     m_bMouseClicked = TRUE;
  3134.                     // Kill the current click check timer and restart if needed.
  3135.                     if (m_idClickCheckTimer != 0)
  3136.                     {
  3137.                         EVAL(KillTimer(m_idClickCheckTimer));
  3138.                         m_idClickCheckTimer = 0;
  3139.                     }
  3141.                     EVAL((m_idClickCheckTimer = SetTimer(   ID_CLICKCHECK_TIMER,
  3142.                                                             TIME_CLICKCHECK_TIMEOUT,
  3143.                                                             NULL)) != 0);
  3144.                 }
  3146.                 break;
  3147.             }
  3149.             default:
  3150.                 hrResult = DISP_E_MEMBERNOTFOUND;
  3151.                 break;
  3152.         }
  3154.         break;
  3155.     }
  3157.     return hrResult;
  3158. }
  3160. #if 0
  3162. // Darrenmi will wire this into the IOleCommandTarget interface 
  3164. /////////////////////////////////////////////////////////////////////////////
  3165. // INotificationSink interface
  3166. /////////////////////////////////////////////////////////////////////////////
  3167. /////////////////////////////////////////////////////////////////////////////
  3168. // CScreenSaverWindow::OnNotification
  3169. /////////////////////////////////////////////////////////////////////////////
  3170. STDMETHODIMP THIS_CLASS::OnNotification
  3171. (
  3172.     LPNOTIFICATION          pNotification,
  3173.     LPNOTIFICATIONREPORT    pNotfctnReport,
  3174.     DWORD                   dwReserved
  3175. )
  3176. {
  3177.     ASSERT(pNotification != NULL);
  3179.     TraceMsg(TF_NOTIFY, "OnNotification()");
  3181.     NOTIFICATIONTYPE nt;
  3182.     if (SUCCEEDED(pNotification->GetNotificationInfo(   &nt,
  3183.                                                         NULL,
  3184.                                                         NULL,
  3185.                                                         NULL,
  3186.                                                         0)))
  3187.     {
  3188.         if (InlineIsEqualGUID(nt, NOTIFICATIONTYPE_INET_OFFLINE))
  3189.         {
  3190.             TraceMsg(TF_NOTIFY, "Going OFFLINE");
  3191.             EVAL(SUCCEEDED(m_pWebBrowser->put_Offline(VARIANT_TRUE)));
  3192.         }
  3193.         else if (InlineIsEqualGUID(nt, NOTIFICATIONTYPE_INET_ONLINE))
  3194.         {
  3195.             TraceMsg(TF_NOTIFY, "Going ONLINE");
  3196.             EVAL(SUCCEEDED(m_pWebBrowser->put_Offline(VARIANT_FALSE)));
  3197.         }
  3198.         else
  3199.             ASSERT(FALSE);
  3200.     }
  3201.     else
  3202.         ASSERT(FALSE);
  3204.     return S_OK;
  3205. }
  3207. #endif