Category

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

Windows Kernel

Development Platform:

Visual C++

dhuihand.cpp：Code Content
  1. #include "priv.h"
  2. #include "resource.h"
  3. #include "mshtmcid.h"
  5. #include <mluisupp.h>
  7. #ifndef X_IEHELPID_H_
  8. #define X_IEHELPID_H_
  9. #include "iehelpid.h"
  10. #endif
  12. #ifdef UNIX
  13. #ifndef X_MAINWIN_H_
  14. #define X_MAINWIN_H_
  15. #  include <mainwin.h>
  16. #endif
  17. #endif // UNIX
  20. #include "dhuihand.h"
  22. #define DM_DOCHOSTUIHANDLER 0
  23. #define CX_CONTEXTMENUOFFSET    2
  24. #define CY_CONTEXTMENUOFFSET    2
  26. //+------------------------------------------------------------------------
  27. //
  28. // The following defines were stolen from commdlg.h.  Since SHDOCVW is
  29. // compiled with WINVER=0x0400 and these defines are WINVER=0x0500 they
  30. // needed to be copied and included here.  These must be kept in sync
  31. // with the commdlg.h definitions.
  32. //
  33. // If shdocvw ever gets compiled with WINVER=0x0500 or above, then these
  34. // can be removed.
  35. //
  36. //-------------------------------------------------------------------------
  38. #define NEED_BECAUSE_COMPILED_AT_WINVER_4
  39. #ifdef  NEED_BECAUSE_COMPILED_AT_WINVER_4
  40. //
  41. //  Define the start page for the print dialog when using PrintDlgEx.
  42. //
  43. #define START_PAGE_GENERAL             0xffffffff
  45. //
  46. //  Page Range structure for PrintDlgEx.
  47. //
  48. typedef struct tagPRINTPAGERANGE {
  49.    DWORD  nFromPage;
  50.    DWORD  nToPage;
  51. } PRINTPAGERANGE, *LPPRINTPAGERANGE;
  54. //
  55. //  PrintDlgEx structure.
  56. //
  57. typedef struct tagPDEXA {
  58.    DWORD                 lStructSize;          // size of structure in bytes
  59.    HWND                  hwndOwner;            // caller's window handle
  60.    HGLOBAL               hDevMode;             // handle to DevMode
  61.    HGLOBAL               hDevNames;            // handle to DevNames
  62.    HDC                   hDC;                  // printer DC/IC or NULL
  63.    DWORD                 Flags;                // PD_ flags
  64.    DWORD                 Flags2;               // reserved
  65.    DWORD                 ExclusionFlags;       // items to exclude from driver pages
  66.    DWORD                 nPageRanges;          // number of page ranges
  67.    DWORD                 nMaxPageRanges;       // max number of page ranges
  68.    LPPRINTPAGERANGE      lpPageRanges;         // array of page ranges
  69.    DWORD                 nMinPage;             // min page number
  70.    DWORD                 nMaxPage;             // max page number
  71.    DWORD                 nCopies;              // number of copies
  72.    HINSTANCE             hInstance;            // instance handle
  73.    LPCSTR                lpPrintTemplateName;  // template name for app specific area
  74.    LPUNKNOWN             lpCallback;           // app callback interface
  75.    DWORD                 nPropertyPages;       // number of app property pages in lphPropertyPages
  76.    HPROPSHEETPAGE       *lphPropertyPages;     // array of app property page handles
  77.    DWORD                 nStartPage;           // start page id
  78.    DWORD                 dwResultAction;       // result action if S_OK is returned
  79. } PRINTDLGEXA, *LPPRINTDLGEXA;
  80. //
  81. //  PrintDlgEx structure.
  82. //
  83. typedef struct tagPDEXW {
  84.    DWORD                 lStructSize;          // size of structure in bytes
  85.    HWND                  hwndOwner;            // caller's window handle
  86.    HGLOBAL               hDevMode;             // handle to DevMode
  87.    HGLOBAL               hDevNames;            // handle to DevNames
  88.    HDC                   hDC;                  // printer DC/IC or NULL
  89.    DWORD                 Flags;                // PD_ flags
  90.    DWORD                 Flags2;               // reserved
  91.    DWORD                 ExclusionFlags;       // items to exclude from driver pages
  92.    DWORD                 nPageRanges;          // number of page ranges
  93.    DWORD                 nMaxPageRanges;       // max number of page ranges
  94.    LPPRINTPAGERANGE      lpPageRanges;         // array of page ranges
  95.    DWORD                 nMinPage;             // min page number
  96.    DWORD                 nMaxPage;             // max page number
  97.    DWORD                 nCopies;              // number of copies
  98.    HINSTANCE             hInstance;            // instance handle
  99.    LPCWSTR               lpPrintTemplateName;  // template name for app specific area
  100.    LPUNKNOWN             lpCallback;           // app callback interface
  101.    DWORD                 nPropertyPages;       // number of app property pages in lphPropertyPages
  102.    HPROPSHEETPAGE       *lphPropertyPages;     // array of app property page handles
  103.    DWORD                 nStartPage;           // start page id
  104.    DWORD                 dwResultAction;       // result action if S_OK is returned
  105. } PRINTDLGEXW, *LPPRINTDLGEXW;
  106. #ifdef UNICODE
  107. typedef PRINTDLGEXW PRINTDLGEX;
  108. typedef LPPRINTDLGEXW LPPRINTDLGEX;
  109. #else
  110. typedef PRINTDLGEXA PRINTDLGEX;
  111. typedef LPPRINTDLGEXA LPPRINTDLGEX;
  112. #endif // UNICODE
  114. HRESULT  APIENTRY  PrintDlgExA(LPPRINTDLGEXA);
  115. HRESULT  APIENTRY  PrintDlgExW(LPPRINTDLGEXW);
  116. #ifdef UNICODE
  117. #define PrintDlgEx  PrintDlgExW
  118. #else
  119. #define PrintDlgEx  PrintDlgExA
  120. #endif // !UNICODE
  122. //
  123. //  Result action ids for PrintDlgEx.
  124. //
  125. #define PD_RESULT_CANCEL               0
  126. #define PD_RESULT_PRINT                1
  127. #define PD_RESULT_APPLY                2
  129. #endif // NEED_BECAUSE_COMPILED_AT_WINVER_4
  131. //+------------------------------------------------------------------------
  132. //
  133. // Useful combinations of flags for IOleCommandTarget
  134. //
  135. //-------------------------------------------------------------------------
  137. #define OLECMDSTATE_DISABLED    OLECMDF_SUPPORTED
  138. #define OLECMDSTATE_UP          (OLECMDF_SUPPORTED | OLECMDF_ENABLED)
  139. #define OLECMDSTATE_DOWN        (OLECMDF_SUPPORTED | OLECMDF_ENABLED | OLECMDF_LATCHED)
  140. #define OLECMDSTATE_NINCHED     (OLECMDF_SUPPORTED | OLECMDF_ENABLED | OLECMDF_NINCHED)
  142. struct SExpandoInfo
  143. {
  144.     TCHAR * name;
  145.     VARTYPE type;
  146. };
  148. // Enumerations for custom expandos
  149. enum MessageEnum
  150. {
  151.    MessageText,
  152.    MessageCaption,
  153.    MessageStyle,
  154.    MessageHelpFile,
  155.    MessageHelpContext
  156. };
  158. enum PagesetupEnum
  159. {
  160.     PagesetupHeader,
  161.     PagesetupFooter,
  162.     PagesetupStruct
  163. };
  165. enum PrintEnum
  166. {
  167.     PrintfRootDocumentHasFrameset,
  168.     PrintfAreRatingsEnabled,
  169.     PrintfPrintActiveFrame,
  170.     PrintfPrintLinked,
  171.     PrintfPrintSelection,
  172.     PrintfPrintAsShown,
  173.     PrintfShortcutTable,
  174.     PrintiFontScaling,
  175.     PrintpBodyActiveTarget,
  176.     PrintStruct,
  177.     PrintToFileOk,
  178.     PrintToFileName
  179. #ifdef UNIX
  180.     , PrintdmOrientation
  181. #endif // UNIX
  182. };
  184. enum PropertysheetEnum
  185. {
  186.     PropertysheetPunks
  187. };
  189. #ifdef UNIX
  190. #   define ID_PRINT_R_PORTRAIT rad7
  191. #   define ID_PRINT_R_LANDSCAPE rad8
  192. #   define MAX_COMMAND_LEN   255
  193. #endif // UNIX
  195. //----------------------------------------------------------------------------
  196. //
  197. //  Arrays describing helpcontextids for PageSetup/Print
  198. //
  199. //----------------------------------------------------------------------------
  201. static const DWORD aPrintDialogHelpIDs[] =
  202. {
  203.     stc6,                       IDH_PRINT_CHOOSE_PRINTER,
  204.     cmb4,                       IDH_PRINT_CHOOSE_PRINTER,
  205.     psh2,                       IDH_PRINT_PROPERTIES,
  206.     stc7,                       IDH_PRINT_SETUP_DETAILS,
  207.     stc8,                       IDH_PRINT_SETUP_DETAILS,
  208.     stc9,                       IDH_PRINT_SETUP_DETAILS,
  209.     stc10,                      IDH_PRINT_SETUP_DETAILS,
  210.     stc12,                      IDH_PRINT_SETUP_DETAILS,
  211.     stc11,                      IDH_PRINT_SETUP_DETAILS,
  212.     stc14,                      IDH_PRINT_SETUP_DETAILS,
  213.     stc13,                      IDH_PRINT_SETUP_DETAILS,
  214.     stc5,                       IDH_PRINT_TO_FILE,
  215.     chx1,                       IDH_PRINT_TO_FILE,
  216.     ico3,                       IDH_PRINT_COLLATE,
  217.     chx2,                       IDH_PRINT_COLLATE,
  218.     grp1,                       IDH_PRINT_RANGE,
  219.     rad1,                       IDH_PRINT_RANGE,        // all
  220.     rad2,                       IDH_PRINT_RANGE,        // selection
  221.     rad3,                       IDH_PRINT_RANGE,        // pages
  222.     stc2,                       IDH_PRINT_RANGE,
  223.     stc3,                       IDH_PRINT_RANGE,
  224.     edt1,                       IDH_PRINT_RANGE,
  225.     edt2,                       IDH_PRINT_RANGE,
  226.     edt3,                       IDH_PRINT_COPIES,
  227.     rad4,                       IDH_PRINT_SCREEN,
  228.     rad5,                       IDH_PRINT_SEL_FRAME,
  229.     rad6,                       IDH_PRINT_ALL_FRAME,
  230.     IDC_LINKED,                 IDH_PRINT_LINKS,
  231.     IDC_SHORTCUTS,              IDH_PRINT_SHORTCUTS,
  232.     0,    0
  233. };
  235. static const DWORD aPageSetupDialogHelpIDs[] =
  236. {
  237.     psh3,                       IDH_PRINT_PRINTER_SETUP,
  238.     stc2,                       IDH_PAGE_PAPER_SIZE,
  239.     cmb2,                       IDH_PAGE_PAPER_SIZE,
  240.     stc3,                       IDH_PAGE_PAPER_SOURCE,
  241.     cmb3,                       IDH_PAGE_PAPER_SOURCE,
  242.     rad1,                       IDH_PAGE_ORIENTATION,
  243.     rad2,                       IDH_PAGE_ORIENTATION,
  244.     stc15,                      IDH_PAGE_MARGINS,
  245.     edt4,                       IDH_PAGE_MARGINS,
  246.     stc16,                      IDH_PAGE_MARGINS,
  247.     edt5,                       IDH_PAGE_MARGINS,
  248.     stc17,                      IDH_PAGE_MARGINS,
  249.     edt6,                       IDH_PAGE_MARGINS,
  250.     stc18,                      IDH_PAGE_MARGINS,
  251.     edt7,                       IDH_PAGE_MARGINS,
  252.     IDC_EDITHEADER,             IDH_PAGESETUP_HEADER_LEFT,
  253.     IDC_STATICHEADER,           IDH_PAGESETUP_HEADER_LEFT,
  254.     IDC_EDITFOOTER,             IDH_PAGESETUP_HEADER_LEFT,
  255.     IDC_STATICFOOTER,           IDH_PAGESETUP_HEADER_LEFT,
  256.     IDC_HEADERFOOTER,           IDH_PAGESETUP_HEADER_LEFT,
  257.     0,    0
  258. };
  260. //+---------------------------------------------------------------------------
  261. //
  262. //  Function:   GetControlID
  263. //
  264. //  Synopsis:
  265. //
  266. //  Arguments:  HWND - passed window handle of WM_CONTEXTMENU
  267. //              lParam  - passed coordinates (lParam) of WM_CONTEXTMENU
  268. //
  269. //  Returns:    int - ctrlid
  270. //
  271. //
  272. //----------------------------------------------------------------------------
  273. int GetControlID(HWND hwnd, LPARAM lParam)
  274. {
  275.     int CtrlID;
  277.     CtrlID = GetDlgCtrlID(hwnd);
  278.     if (CtrlID==0)
  279.     {
  280.         POINT pt;
  281.         pt.x = GET_X_LPARAM(lParam);
  282.         pt.y = GET_Y_LPARAM(lParam);
  283.         if (ScreenToClient(hwnd, &pt))
  284.         {
  285.             HWND  hwndChild = ChildWindowFromPointEx(hwnd, pt, CWP_ALL);
  286.             if (hwndChild)
  287.             {
  288.                 CtrlID = GetDlgCtrlID(hwndChild);
  289.             }
  290.         }
  291.     }
  292.     return CtrlID;
  294. }
  296. //+---------------------------------------------------------------------------
  297. //
  298. //  Function:   GetHelpFile
  299. //
  300. //  Synopsis:
  301. //
  302. //  Arguments:  iCtrlID - id of the control
  303. //              adw     - array of DWORDS, consisting of controlid,helpid pairs
  304. //
  305. //  Returns:    A string with the name of the helpfile
  306. //
  307. //  Notes:      Help topics for the print dialogs can be either in iexplore.hlp
  308. //              or in windows.hlp.  We key off the helpid to determine which
  309. //              file to go to.
  310. //
  311. //----------------------------------------------------------------------------
  314. LPTSTR
  315. GetHelpFile(int iCtrlID, DWORD * adw)
  316. {
  317.     BOOL fContinue = TRUE;
  319.     ASSERT (adw);
  320.     while (fContinue)
  321.     {
  322.         int ctrlid = int(*adw);
  323.         int helpid = int(*(adw + 1));
  325.         if (ctrlid == 0 && helpid == 0)
  326.         {
  327.             fContinue = FALSE;
  328.             break;
  329.         }
  331.         if (ctrlid == iCtrlID)
  332.         {
  333.             //TraceTag((tagContextHelp, "for ctrl=%d, topic=%d", ctrlid, helpid));
  334.             return (helpid < 50000) ? TEXT("windows.hlp") : TEXT("iexplore.hlp");
  335.         }
  337.         adw += 2;
  338.     }
  339.     return TEXT("windows.hlp");
  340. }
  342. GetInterfaceFromClientSite(IUnknown *pUnk, REFIID riid, void ** ppv)
  343. {
  344.     HRESULT               hr;
  345.     IOleObject          * pOleObject = NULL;
  346.     IOleClientSite      * pOleClientSite = NULL;
  348.     if (!pUnk || !ppv)
  349.     {
  350.         hr = E_INVALIDARG;
  351.         goto Cleanup;
  352.     }
  354.     *ppv = NULL;
  356.     hr = pUnk->QueryInterface(IID_IOleObject, (void **)&pOleObject);
  357.     if (hr)
  358.         goto Cleanup;
  360.     hr = pOleObject->GetClientSite(&pOleClientSite);
  361.     if (pOleClientSite == NULL)
  362.     {
  363.         hr = E_FAIL;
  364.     }
  365.     if (hr)
  366.         goto Cleanup;
  368.     hr = pOleClientSite->QueryInterface(riid, ppv);
  370. Cleanup:
  371.     ATOMICRELEASE(pOleClientSite);
  372.     ATOMICRELEASE(pOleObject);
  374.     return hr;
  375.     
  376.     
  377. }
  379. //
  380. // Get the IOleInPlaceFrame if available.  If this proves useful, move this somewhere interesting.
  381. //
  382. HRESULT GetInPlaceFrameFromUnknown(IUnknown * punk, IOleInPlaceFrame ** ppOleInPlaceFrame)
  383. {
  384.     HRESULT               hr;
  385.     IOleInPlaceSite     * pOleInPlaceSite = NULL;
  386.     IOleInPlaceUIWindow * pOleInPlaceUIWindow = NULL;
  387.     RECT                  rcPos, rcClip;
  388.     OLEINPLACEFRAMEINFO   frameInfo;
  390.     hr = GetInterfaceFromClientSite(punk, IID_IOleInPlaceSite, (void**)&pOleInPlaceSite);
  391.     if (hr)
  392.         goto Cleanup;
  394.     *ppOleInPlaceFrame = NULL;
  396.     frameInfo.cb = sizeof(OLEINPLACEFRAMEINFO);
  397.     hr = pOleInPlaceSite->GetWindowContext(ppOleInPlaceFrame,
  398.                                            &pOleInPlaceUIWindow,
  399.                                            &rcPos,
  400.                                            &rcClip,
  401.                                            &frameInfo);
  403. Cleanup:
  404.     ATOMICRELEASE(pOleInPlaceUIWindow);
  405.     ATOMICRELEASE(pOleInPlaceSite);
  407.     return hr;
  408. }
  410. HRESULT
  411. GetHwndFromUnknown(
  412.     IUnknown          * punk,
  413.     HWND              * phwnd)
  414. {
  415.     HRESULT             hr;
  416.     IOleInPlaceFrame  * pOleInPlaceFrame = NULL;
  418.     ASSERT(punk);
  419.     ASSERT(phwnd);
  421.     if (phwnd)
  422.     {
  423.         *phwnd = NULL;
  424.     }
  426.     if (!punk || !phwnd)
  427.     {
  428.         hr = E_INVALIDARG;
  429.         goto Cleanup;
  430.     }
  432.     hr = GetInPlaceFrameFromUnknown((IUnknown*)punk, &pOleInPlaceFrame);
  433.     if (hr)
  434.         goto Cleanup;
  436.     hr = pOleInPlaceFrame->GetWindow(phwnd);
  437.     if (hr)
  438.         goto Cleanup;
  440. Cleanup:
  441.     ATOMICRELEASE(pOleInPlaceFrame);
  443.     return hr;
  444. }
  446. HRESULT
  447. GetEventFromUnknown(
  448.     IUnknown       * punk,
  449.     IHTMLEventObj ** ppEventObj)
  450. {
  451.     HRESULT             hr;
  452.     IHTMLDocument2    * pOmDoc = NULL;
  453.     IHTMLWindow2      * pOmWindow = NULL;
  455.     ASSERT(punk);
  456.     ASSERT(ppEventObj);
  458.     if (ppEventObj)
  459.         *ppEventObj = NULL;
  461.     if (!punk || !ppEventObj)
  462.     {
  463.         hr = E_INVALIDARG;
  464.         goto Cleanup;
  465.     }
  467.     hr = punk->QueryInterface(IID_IHTMLDocument2, (void **) &pOmDoc);
  468.     if (hr)
  469.         goto Cleanup;
  471.     hr = pOmDoc->get_parentWindow(&pOmWindow);
  472.     if (hr)
  473.         goto Cleanup;
  475.     hr = pOmWindow->get_event(ppEventObj);
  476.     if (hr)
  477.         goto Cleanup;
  479. Cleanup:
  480.     ATOMICRELEASE(pOmDoc);
  481.     ATOMICRELEASE(pOmWindow);
  483.     return hr;
  484. }
  486. //
  487. // Gets the dispids/variants from the event.
  488. //
  489. HRESULT
  490. GetParamsFromEvent(
  491.     IHTMLEventObj         * pEventObj,
  492.     unsigned int            cExpandos,
  493.     DISPID                  aDispid[],
  494.     VARIANT                 aVariant[],
  495.     const SExpandoInfo      aExpandos[])
  496. {
  497.     HRESULT             hr;
  498.     IDispatchEx       * pDispatchEx = NULL;
  499.     unsigned int        i;
  501.     ASSERT(pEventObj);
  502.     ASSERT(aVariant);
  503.     ASSERT(aExpandos);
  504.     ASSERT(cExpandos >= 0);
  506.     if (!pEventObj || !aVariant || !aExpandos || cExpandos < 0)
  507.     {
  508.         hr = E_INVALIDARG;
  509.         goto Cleanup;
  510.     }
  512.     for (i=0; i<cExpandos; i++)
  513.     {
  514.         VariantInit(aVariant+i);
  515.         aDispid[i] = DISPID_UNKNOWN;
  516.     }
  518.     hr = pEventObj->QueryInterface(IID_IDispatchEx, (void**)&pDispatchEx);
  519.     if (hr)
  520.         goto Cleanup;
  522.     for (i=0; i<cExpandos; i++)
  523.     {
  524.         hr = pDispatchEx->GetDispID(
  525.             aExpandos[i].name,
  526.             fdexNameCaseSensitive,
  527.             aDispid+i);
  528.         if (hr)
  529.             goto Cleanup;
  531.         hr = pDispatchEx->InvokeEx(
  532.             aDispid[i],
  533.             LOCALE_USER_DEFAULT,
  534.             DISPATCH_PROPERTYGET,
  535.             (DISPPARAMS *)&g_dispparamsNoArgs,
  536.             aVariant+i,
  537.             NULL,
  538.             NULL);
  540.         // Check the variant types match
  541.         ASSERT(V_VT(aVariant+i) == aExpandos[i].type);
  543.         if (hr)
  544.             goto Cleanup;
  545.     }
  547. Cleanup:
  548.     ATOMICRELEASE(pDispatchEx);
  550.     return hr;
  551. }
  554. HRESULT
  555. PutParamToEvent(DISPID dispid, VARIANT * var, IHTMLEventObj * pEventObj)
  556. {
  557.     HRESULT         hr;
  558.     IDispatchEx   * pDispatchEx = NULL;
  559.     DISPPARAMS      dispparams = {var, &dispid, 1, 1};
  561.     ASSERT(var);
  562.     ASSERT(pEventObj);
  564.     if (!var || !pEventObj)
  565.     {
  566.         hr = E_INVALIDARG;
  567.         goto Cleanup;
  568.     }
  570.     hr = pEventObj->QueryInterface(IID_IDispatchEx, (void**)&pDispatchEx);
  571.     if (hr)
  572.         goto Cleanup;
  574.     hr = pDispatchEx->InvokeEx(
  575.             dispid,
  576.             LOCALE_USER_DEFAULT,
  577.             DISPATCH_PROPERTYPUT,
  578.             &dispparams,
  579.             NULL,
  580.             NULL,
  581.             NULL);
  582.     if (hr)
  583.         goto Cleanup;
  585. Cleanup:
  586.     ATOMICRELEASE(pDispatchEx);
  588.     return hr;
  589. }
  591. void PutFindText(IWebBrowser2* pwb, LPCWSTR pwszFindText)
  592. {
  593.     BSTR bstrName = SysAllocString(STR_FIND_DIALOG_TEXT);
  595.     if (NULL != bstrName)
  596.     {
  597.         VARIANT var = {VT_EMPTY};
  599.         if (NULL != pwszFindText)
  600.         {
  601.             var.vt = VT_BSTR;
  602.             var.bstrVal = SysAllocString(pwszFindText);
  603.         }
  605.         if ((VT_EMPTY == var.vt) || (NULL != var.bstrVal))
  606.         {
  607.             pwb->PutProperty(bstrName, var);
  608.         }
  610.         SysFreeString(var.bstrVal);
  611.         SysFreeString(bstrName);
  612.     }
  613. }
  615. BSTR GetFindText(IWebBrowser2* pwb)
  616. {   
  617.     BSTR bstrName = SysAllocString(STR_FIND_DIALOG_TEXT);
  619.     VARIANT var = {VT_EMPTY};
  621.     if (bstrName)
  622.     {
  623.         ASSERT(pwb);
  625.         pwb->GetProperty(bstrName, &var);
  627.         SysFreeString(bstrName);
  628.     }
  630.     BSTR bstrResult; 
  631.     
  632.     if (VT_BSTR == var.vt)
  633.     {
  634.         bstrResult = var.bstrVal;
  635.     }
  636.     else
  637.     {   
  638.         bstrResult = NULL;
  639.         VariantClear(&var);
  640.     }
  642.     return bstrResult;
  643. }
  645. CDocHostUIHandler::CDocHostUIHandler(void) : m_cRef(1)
  646. {
  647.     DllAddRef();
  648. }
  650. CDocHostUIHandler::~CDocHostUIHandler(void)
  651. {
  652.     ATOMICRELEASE(_punkSite);
  653.     ATOMICRELEASE(_pExternal);
  654.     ATOMICRELEASE(_pOptionsHolder);
  655.     if (_hBrowseMenu)
  656.         DestroyMenu(_hBrowseMenu);
  657.     if (_hEditMenu)
  658.         DestroyMenu(_hEditMenu);
  660.     DllRelease();
  661. }
  663. STDMETHODIMP CDocHostUIHandler::QueryInterface(REFIID riid, PVOID *ppvObj)
  664. {
  665.     static const QITAB qit[] = {
  666.         QITABENT(CDocHostUIHandler, IDocHostUIHandler),
  667.         QITABENT(CDocHostUIHandler, IObjectWithSite),
  668.         QITABENT(CDocHostUIHandler, IOleCommandTarget),
  669.         QITABENT(CDocHostUIHandler, IDispatch),
  670.         { 0 },
  671.     };
  673.     return QISearch(this, qit, riid, ppvObj);
  674. }
  676. STDMETHODIMP_(ULONG) CDocHostUIHandler::AddRef()
  677. {
  678.     InterlockedIncrement(&m_cRef);
  679.     return m_cRef;
  680. }
  682. STDMETHODIMP_(ULONG) CDocHostUIHandler::Release()
  683. {
  684.     if (InterlockedDecrement(&m_cRef))
  685.         return m_cRef;
  687.     delete this;
  688.     return 0;
  689. }
  692. HRESULT CDocHostUIHandler::SetSite(IUnknown *punkSite)
  693. {
  694.     ATOMICRELEASE(_punkSite);
  696.     ASSERT(_punkSite == NULL);  // don't lose a reference to this
  698.     _punkSite = punkSite;
  700.     if (_punkSite)
  701.     {
  702.         _punkSite->AddRef();
  703.     }
  705.     // Always return S_OK
  706.     //
  707.     return S_OK;
  708. }
  710. HRESULT CDocHostUIHandler::GetSite(REFIID riid, void **ppvSite)
  711. {
  712.     if (_punkSite)
  713.         return _punkSite->QueryInterface(riid, ppvSite);
  715.     *ppvSite = NULL;
  716.     return E_FAIL;
  717. }
  720. //==========================================================================
  721. // IDocHostUIHandler implementation
  722. //==========================================================================
  724. HRESULT CDocHostUIHandler::ShowContextMenu(DWORD dwID, POINT *ppt, IUnknown *pcmdtReserved, IDispatch *pdispReserved)
  725. {
  726.     HRESULT                 hr = S_FALSE;
  727.     HCURSOR                 hcursor;
  728.     HMENU                   hMenu = NULL;
  729.     VARIANT                 var, var1, var2;
  730.     VARIANT               * pvar = NULL;
  731.     int                     iSelection = 0;
  732.     HWND                    hwnd = NULL;
  733.     IOleCommandTarget     * pOleCommandTarget = NULL;
  734.     IOleWindow            * pOleWindow = NULL;
  735.     IOleInPlaceFrame      * pOleInPlaceFrame = NULL;
  736.     IDocHostUIHandler     * pUIHandler = NULL;
  737.     MENUITEMINFO            mii;
  738.     int                     i;
  739.     OLECMD                  olecmd;
  740.     UINT                    mf;
  743.     TraceMsg(DM_DOCHOSTUIHANDLER, "CDOH::ShowContextMenu called");
  745.     //BUGBUG:Does anyone, other than MSHTML call this function?
  746.     //If restriction is set, we lie to Mshtml that context menu has been set. 
  747.     if (SHRestricted2W(REST_NoBrowserContextMenu, NULL, 0))
  748.         return S_OK;
  750.     // Do a proper QI for IOleCommandTarget
  751.     //
  752.     hr = pcmdtReserved->QueryInterface(IID_IOleCommandTarget, (void**)&pOleCommandTarget);
  753.     if (hr)
  754.         goto Cleanup;
  757.     // Check if we are in browse mode
  758.     //
  759.     olecmd.cmdID = IDM_BROWSEMODE;
  760.     hr = pOleCommandTarget->QueryStatus(
  761.             &CGID_MSHTML,
  762.             1,
  763.             &olecmd,
  764.             NULL);
  765.     if (hr)
  766.         goto Cleanup;
  767.     if (olecmd.cmdf == OLECMDSTATE_DOWN)
  768.     {
  769.         if (!_hBrowseMenu)
  770.             _hBrowseMenu = LoadMenu(
  771.                                 MLGetHinst(),
  772.                                 MAKEINTRESOURCE(IDR_BROWSE_CONTEXT_MENU));
  773.         hMenu = _hBrowseMenu;
  774.     }
  776.     // Check if we are in edit mode
  777.     else
  778.     {
  779.         olecmd.cmdID = IDM_EDITMODE;
  780.         hr = pOleCommandTarget->QueryStatus(
  781.                 &CGID_MSHTML,
  782.                 1,
  783.                 &olecmd,
  784.                 NULL);
  785.         if (hr)
  786.             goto Cleanup;
  787.         if (olecmd.cmdf == OLECMDSTATE_DOWN)
  788.         {
  789.             if (!_hEditMenu)
  790.                 _hEditMenu = LoadMenu(
  791.                                 MLGetHinst(),
  792.                                 MAKEINTRESOURCE(IDR_FORM_CONTEXT_MENU));
  793.             hMenu = _hEditMenu;
  794.         }
  796.         // Neither Browse nor Edit flags were set
  797.         else
  798.         {
  799.             ASSERT(false);
  800.             goto Cleanup;
  801.         }
  802.     }
  804.     if (!hMenu)
  805.         goto Cleanup;
  808.     //
  809.     // Check to see if the Integrated DESKTOP is ON
  810.     // If not, we need to delete the "Set as Desktop item" menuitem from all the
  811.     // submenus.
  812.     //
  813.     if(WhichPlatform() != PLATFORM_INTEGRATED)
  814.     {
  815.         int  iSubMenuIndex;
  817.         for(iSubMenuIndex = 0;  iSubMenuIndex < GetMenuItemCount(hMenu); iSubMenuIndex++)
  818.         {
  819.             HMENU hSubMenu;
  820.             if(hSubMenu = GetSubMenu(hMenu, iSubMenuIndex))
  821.                 DeleteMenu(hSubMenu, IDM_SETDESKTOPITEM, MF_BYCOMMAND);
  822.         }
  823.     }
  826.     // Make sure we are running mshtml debug build if we are loading debug window
  827.     if (dwID == CONTEXT_MENU_DEBUG)
  828.     {
  829.         olecmd.cmdID = IDM_DEBUG_TRACETAGS;
  830.         hr = pOleCommandTarget->QueryStatus(
  831.                 &CGID_MSHTML,
  832.                 1,
  833.                 &olecmd,
  834.                 NULL);
  835.         if (olecmd.cmdf != OLECMDSTATE_UP)
  836.             goto Cleanup;
  837.     }
  840.     // Select the appropriate submenu based on the passed in ID
  841.     hMenu = GetSubMenu(hMenu, dwID);
  844.     // Loop through and QueryStatus the menu items.
  845.     //
  846.     for(i = 0; i < GetMenuItemCount(hMenu); i++)
  847.     {
  848.         olecmd.cmdID = GetMenuItemID(hMenu, i);
  849.         if (olecmd.cmdID > 0)
  850.         {
  851.             pOleCommandTarget->QueryStatus(
  852.                     &CGID_MSHTML,
  853.                     1,
  854.                     &olecmd,
  855.                     NULL);
  856.             switch (olecmd.cmdf)
  857.             {
  858.             case OLECMDSTATE_UP:
  859.             case OLECMDSTATE_NINCHED:
  860.                 mf = MF_BYCOMMAND | MF_ENABLED | MF_UNCHECKED;
  861.                 break;
  863.             case OLECMDSTATE_DOWN:
  864.                 mf = MF_BYCOMMAND | MF_ENABLED | MF_CHECKED;
  865.                 break;
  867.             case OLECMDSTATE_DISABLED:
  868.             default:
  869.                 mf = MF_BYCOMMAND | MF_DISABLED | MF_GRAYED;
  870.                 break;
  871.             }
  872.             CheckMenuItem(hMenu, olecmd.cmdID, mf);
  873.             EnableMenuItem(hMenu, olecmd.cmdID, mf);
  874.         }
  875.     }
  878.     // Get the language submenu
  879.     hr = pOleCommandTarget->Exec(&CGID_ShellDocView, SHDVID_GETMIMECSETMENU, 0, NULL, &var);
  880.     if (hr)
  881.         goto Cleanup;
  883.     mii.cbSize = sizeof(mii);
  884.     mii.fMask  = MIIM_SUBMENU;
  885. //$ WIN64: mshtmlsrcsitebaseformmso.cxx needs to return VT_INT_PTR instead
  886. //  mii.hSubMenu = var.byref; // BUGBUG - Line should be this
  887.     mii.hSubMenu = (HMENU) LongToHandle(V_I4(&var)); 
  889.     SetMenuItemInfo(hMenu, IDM_LANGUAGE, FALSE, &mii);
  891.     // Insert Context Menu
  892. //$ WIN64: mshtmlsrcsitebaseformmso.cxx needs to accept VT_INT_PTR instead
  893. //  V_VT(&var1) = VT_INT_PTR; // BUGBUG -- Line should be this
  894. //  V_BYREF(&var1) = hMenu; // BUGBUG -- Line should be this
  895.     V_VT(&var1) = VT_I4;
  896.     V_I4(&var1) = HandleToLong(hMenu);
  898.     V_VT(&var2) = VT_I4;
  899.     V_I4(&var2) = dwID;
  901.     hr = pOleCommandTarget->Exec(&CGID_ShellDocView, SHDVID_ADDMENUEXTENSIONS, 0, &var1, &var2);
  902.     if (hr)
  903.         goto Cleanup;
  905.     // Get the window also.
  906.     //
  907.     if (SUCCEEDED(pcmdtReserved->QueryInterface(IID_IOleWindow, (void**)&pOleWindow)))
  908.     {
  909.         pOleWindow->GetWindow(&hwnd);
  910.     }
  912.     if (hwnd)
  913.     {
  915.         GetInterfaceFromClientSite(pcmdtReserved, IID_IDocHostUIHandler, (void **)&pUIHandler);
  916.         if (pUIHandler)
  917.             pUIHandler->EnableModeless(FALSE);
  919.         GetInPlaceFrameFromUnknown(pcmdtReserved, &pOleInPlaceFrame);
  920.         if (pOleInPlaceFrame)
  921.                 pOleInPlaceFrame->EnableModeless(FALSE);
  923.         hcursor = SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW)));
  925.         // Display the menu.  Pass in the HWND of our site object.
  926.         //
  927.         iSelection = ::TrackPopupMenu(
  928.                         hMenu,
  929.                         TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD,
  930.                         ppt->x + CX_CONTEXTMENUOFFSET,
  931.                         ppt->y + CY_CONTEXTMENUOFFSET,
  932.                         0,
  933.                         hwnd,
  934.                         (RECT*)NULL);
  936.         if (pUIHandler)
  937.             pUIHandler->EnableModeless(TRUE);
  939.         if (pOleInPlaceFrame)
  940.             pOleInPlaceFrame->EnableModeless(TRUE);
  942.         SetCursor(hcursor);
  943.     }
  945.     if (iSelection)
  946.     {
  947.         switch (iSelection)
  948.         {
  949.             case IDM_FOLLOWLINKN:
  950.                 // tell the top level browser to save its window size to the registry so 
  951.                 // that our new window can pick it up and cascade properly
  953.                 IUnknown_Exec(_punkSite, &CGID_Explorer, SBCMDID_SUGGESTSAVEWINPOS, 0, NULL, NULL);
  955.                 // fall through
  957.             case IDM_PROPERTIES:
  958.             case IDM_FOLLOWLINKC:
  959.             
  960.                 pvar = &var;
  961.                 V_VT(pvar) = VT_I4;
  962.                 V_I4(pvar) = MAKELONG(ppt->x, ppt->y);
  963.                 break;
  964.         }
  966.         pOleCommandTarget->Exec(&CGID_MSHTML, iSelection, 0, pvar, NULL);
  967.     }
  969. Cleanup:
  970.     ATOMICRELEASE(pOleCommandTarget);
  971.     ATOMICRELEASE(pOleWindow);
  972.     ATOMICRELEASE(pOleInPlaceFrame);
  973.     ATOMICRELEASE(pUIHandler);
  974.     return hr;
  975. }
  977. HRESULT CDocHostUIHandler::GetHostInfo(DOCHOSTUIINFO *pInfo)
  978. {
  979.     DWORD dwUrlEncodingDisableUTF8;
  980.     DWORD dwSize = SIZEOF(dwUrlEncodingDisableUTF8);
  981.     BOOL  fDefault = FALSE;
  982.     DWORD dwLoadf = 0;
  984.     TraceMsg(DM_DOCHOSTUIHANDLER, "CDOH::GetHostInfo called");
  986.     pInfo->cbSize = SIZEOF(DOCHOSTUIINFO);
  987.     pInfo->dwFlags = DOCHOSTUIFLAG_BROWSER;
  989.     pInfo->dwDoubleClick = DOCHOSTUIDBLCLK_DEFAULT;     // default
  991.     SHRegGetUSValue(REGSTR_PATH_INTERNET_SETTINGS,
  992.         TEXT("UrlEncoding"), NULL, (LPBYTE) &dwUrlEncodingDisableUTF8, &dwSize, FALSE, (LPVOID) &fDefault, SIZEOF(fDefault));
  994.     if (dwUrlEncodingDisableUTF8)
  995.         pInfo->dwFlags |= DOCHOSTUIFLAG_URL_ENCODING_DISABLE_UTF8;
  996.     else
  997.         pInfo->dwFlags |= DOCHOSTUIFLAG_URL_ENCODING_ENABLE_UTF8;
  999.     return S_OK;
  1000. }
  1002. HRESULT CDocHostUIHandler::ShowUI(
  1003.     DWORD dwID, IOleInPlaceActiveObject *pActiveObject,
  1004.     IOleCommandTarget *pCommandTarget, IOleInPlaceFrame *pFrame,
  1005.     IOleInPlaceUIWindow *pDoc)
  1006. {
  1007.     TraceMsg(DM_DOCHOSTUIHANDLER, "CDOH::ShowUI called");
  1009.     // Host did not display its own UI. Trident will proceed to display its own.
  1010.     return S_FALSE;
  1011. }
  1013. HRESULT CDocHostUIHandler::HideUI(void)
  1014. {
  1015.     TraceMsg(DM_DOCHOSTUIHANDLER, "CDOH::HideUI called");
  1016.     // This one is paired with ShowUI
  1017.     return S_FALSE;
  1018. }
  1020. HRESULT CDocHostUIHandler::UpdateUI(void)
  1021. {
  1022.     TraceMsg(DM_DOCHOSTUIHANDLER, "CDOH::UpdateUI called");
  1023.     // LATER: Isn't this equivalent to OLECMDID_UPDATECOMMANDS?
  1024.     return S_FALSE;
  1025. }
  1027. HRESULT CDocHostUIHandler::EnableModeless(BOOL fEnable)
  1028. {
  1029.     TraceMsg(DM_DOCHOSTUIHANDLER, "CDOH::EnableModeless called");
  1030.     // Called from the Trident when the equivalent member of its
  1031.     // IOleInPlaceActiveObject is called by the frame. We don't care
  1032.     // those cases.
  1033.     return S_OK;
  1034. }
  1036. HRESULT CDocHostUIHandler::OnDocWindowActivate(BOOL fActivate)
  1037. {
  1038.     // Called from the Trident when the equivalent member of its
  1039.     // IOleInPlaceActiveObject is called by the frame. We don't care
  1040.     // those cases.
  1041.     return S_OK;
  1042. }
  1044. HRESULT CDocHostUIHandler::OnFrameWindowActivate(BOOL fActivate)
  1045. {
  1046.     // Called from the Trident when the equivalent member of its
  1047.     // IOleInPlaceActiveObject is called by the frame. We don't care
  1048.     // those cases.
  1049.     return S_OK;
  1050. }
  1052. HRESULT CDocHostUIHandler::ResizeBorder(
  1053. LPCRECT prcBorder, IOleInPlaceUIWindow *pUIWindow, BOOL fRameWindow)
  1054. {
  1055.     // Called from the Trident when the equivalent member of its
  1056.     // IOleInPlaceActiveObject is called by the frame. We don't care
  1057.     // those cases.
  1058.     return S_OK;
  1059. }
  1061. HRESULT CDocHostUIHandler::TranslateAccelerator(
  1062. LPMSG lpMsg, const GUID *pguidCmdGroup, DWORD nCmdID)
  1063. {
  1064.     // Called from the Trident when the equivalent member of its
  1065.     // IOleInPlaceActiveObject is called by the frame. We don't care
  1066.     // those cases.
  1067.     return S_FALSE; // The message was not translated
  1068. }
  1070. HRESULT CDocHostUIHandler::GetOptionKeyPath(BSTR *pbstrKey, DWORD dw)
  1071. {
  1072.     // Trident will default to its own user options.
  1073.     *pbstrKey = NULL;
  1074.     return S_FALSE;
  1075. }
  1077. HRESULT CDocHostUIHandler::GetDropTarget(IDropTarget *pDropTarget, IDropTarget **ppDropTarget)
  1078. {
  1079.     TraceMsg(DM_DOCHOSTUIHANDLER, "CDOH::GetDropTarget called");
  1080.     return E_NOTIMPL;
  1081. }
  1083. HRESULT CDocHostUIHandler::GetAltExternal(IDispatch **ppDisp)
  1084. {
  1085.     HRESULT hr = E_FAIL;
  1087.     IServiceProvider  *psp;
  1088.     IDocHostUIHandler *pDocHostUIHandler;
  1089.     IOleObject        *pOleObject;
  1090.     IOleClientSite    *pOleClientSite;
  1092.     *ppDisp = NULL;
  1094.     //  * QI ourselves for a service provider
  1095.     //  * QS for the top level browser's service provider
  1096.     //  * Ask for an IOleObject
  1097.     //  * Ask the IOleObject for an IOleClientSite
  1098.     //  * QI the IOleClientSite for an IDocHostUIHandler
  1099.     //  * Call GetExternal on the IDocHostUIHandler to get the IDispatch
  1101.     if (SUCCEEDED(IUnknown_QueryService(_punkSite,
  1102.                                         SID_STopLevelBrowser,
  1103.                                         IID_IServiceProvider,
  1104.                                         (void **)&psp)))
  1105.     {
  1106.         if (SUCCEEDED(psp->QueryService(SID_SWebBrowserApp, IID_IOleObject,
  1107.                                         (void **)&pOleObject)))
  1108.         {
  1109.             if (SUCCEEDED(pOleObject->GetClientSite(&pOleClientSite)))
  1110.             {
  1111.                 if (SUCCEEDED(pOleClientSite->QueryInterface(IID_IDocHostUIHandler,
  1112.                                                              (void **)&pDocHostUIHandler)))
  1113.                 {
  1114.                     hr = pDocHostUIHandler->GetExternal(ppDisp);
  1115.                     pDocHostUIHandler->Release();
  1116.                 }
  1117.                 pOleClientSite->Release();
  1118.             }
  1119.             pOleObject->Release();
  1120.         }
  1121.         psp->Release();
  1122.     }
  1124.     return hr;
  1125. }
  1127. HRESULT CDocHostUIHandler::GetExternal(IDispatch **ppDisp)
  1128. {
  1129.     TraceMsg(DM_DOCHOSTUIHANDLER, "CDOH::GetExternal called");
  1131.     HRESULT hr = S_OK;
  1133.     if (!ppDisp)
  1134.     {
  1135.         hr = E_INVALIDARG;
  1136.         goto Cleanup;
  1137.     }
  1139.     if (_pExternal)
  1140.     {
  1141.         *ppDisp = _pExternal;
  1142.         (*ppDisp)->AddRef();
  1143.         goto Cleanup;
  1144.     }
  1146.     IDispatch *psuihDisp;
  1147.     IDispatch *pAltExternalDisp;
  1149.     *ppDisp = NULL;
  1151.     GetAltExternal(&pAltExternalDisp);
  1153.     hr = CShellUIHelper_CreateInstance2((IUnknown **)&psuihDisp, IID_IDispatch,
  1154.                                        _punkSite, pAltExternalDisp);
  1155.     if (SUCCEEDED(hr))
  1156.     {
  1157.         *ppDisp = psuihDisp;
  1158.         _pExternal = *ppDisp;
  1160.         if (pAltExternalDisp)
  1161.         {
  1162.             //  Don't hold a ref - the ShellUIHelper will do it
  1163.             pAltExternalDisp->Release();
  1164.         }
  1165.     }
  1166.     else if (pAltExternalDisp)
  1167.     {
  1168.         //  Couldn't create a ShellUIHelper but we got our host's
  1169.         //  external.
  1170.         *ppDisp = pAltExternalDisp;
  1171.         _pExternal = *ppDisp;
  1172.     }
  1174. Cleanup:
  1175.     ASSERT((SUCCEEDED(hr) && (*ppDisp)) || (FAILED(hr)));
  1176.     return hr;
  1177. }
  1180. HRESULT CDocHostUIHandler::TranslateUrl(DWORD dwTranslate, OLECHAR *pchURLIn, OLECHAR **ppchURLOut)
  1181. {
  1182.     TraceMsg(DM_DOCHOSTUIHANDLER, "CDOH::TranslateUrl called");
  1184.     return S_FALSE;
  1185. }
  1188. HRESULT CDocHostUIHandler::FilterDataObject(IDataObject *pDO, IDataObject **ppDORet)
  1189. {
  1190.     TraceMsg(DM_DOCHOSTUIHANDLER, "CDOH::FilterDataObject called");
  1192.     return S_FALSE;
  1193. }
  1195. STDAPI CDocHostUIHandler_CreateInstance(IUnknown * punkOuter, IUnknown ** ppunk, LPCOBJECTINFO poi)
  1196. {
  1197.     HRESULT hres = E_OUTOFMEMORY;
  1198.     CDocHostUIHandler *pis = new CDocHostUIHandler;
  1199.     if (pis)
  1200.     {
  1201.         *ppunk = SAFECAST(pis, IDocHostUIHandler *);
  1202.         hres = S_OK;
  1203.     }
  1204.     return hres;
  1205. }
  1207. //==========================================================================
  1208. // IOleCommandTarget implementation
  1209. //==========================================================================
  1211. HRESULT CDocHostUIHandler::QueryStatus(const GUID *pguidCmdGroup,
  1212.         ULONG cCmds, OLECMD rgCmds[], OLECMDTEXT *pcmdtext)
  1213. {
  1214.     HRESULT hres = OLECMDERR_E_UNKNOWNGROUP;
  1216.     if (IsEqualGUID(CGID_DocHostCommandHandler, *pguidCmdGroup))
  1217.     {
  1218.         ULONG i;
  1220.         if (rgCmds == NULL)
  1221.             return E_INVALIDARG;
  1223.         for (i = 0 ; i < cCmds ; i++)
  1224.         {
  1225.             // ONLY say that we support the stuff we support in ::Exec
  1226.             switch (rgCmds[i].cmdID)
  1227.             {
  1228.             case OLECMDID_SHOWSCRIPTERROR:
  1229.             case OLECMDID_SHOWMESSAGE:
  1230.             case OLECMDID_SHOWFIND:
  1231.             case OLECMDID_SHOWPAGESETUP:
  1232.             case OLECMDID_SHOWPRINT:
  1233.             case OLECMDID_PROPERTIES:
  1234.             case SHDVID_CLSIDTOMONIKER:
  1235.                 rgCmds[i].cmdf = OLECMDF_ENABLED;
  1236.                 break;
  1238.             default:
  1239.                 rgCmds[i].cmdf = 0;
  1240.                 break;
  1241.             }
  1242.         }
  1244.         hres = S_OK;
  1245.     }
  1247.     return hres;
  1248. }
  1250. HRESULT CDocHostUIHandler::Exec(const GUID *pguidCmdGroup,
  1251.         DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
  1252. {
  1253.     if (IsEqualGUID(CGID_DocHostCommandHandler, *pguidCmdGroup))
  1254.     {
  1255.         switch (nCmdID)
  1256.         {
  1257.         case OLECMDID_SHOWSCRIPTERROR:
  1258.             if (!pvarargIn || !pvarargOut)
  1259.                 return E_INVALIDARG;
  1261.             ShowErrorDialog(pvarargIn, pvarargOut, nCmdexecopt);
  1262.             return S_OK;
  1264.         case OLECMDID_SHOWMESSAGE:
  1265.             if (!pvarargIn || !pvarargOut)
  1266.                 return E_INVALIDARG;
  1267.             else
  1268.                 return ShowMessage(pvarargIn, pvarargOut, nCmdexecopt);
  1270.         case OLECMDID_SHOWFIND:
  1271.             if (!pvarargIn)
  1272.                 return E_INVALIDARG;
  1274.             ShowFindDialog(pvarargIn, pvarargOut, nCmdexecopt);
  1275.             return S_OK;
  1277.         case OLECMDID_SHOWPAGESETUP:
  1278.             if (!pvarargIn)
  1279.                 return E_INVALIDARG;
  1280.             else
  1281.                 return ShowPageSetupDialog(pvarargIn, pvarargOut, nCmdexecopt);
  1283.         case OLECMDID_SHOWPRINT:
  1284.             if (!pvarargIn)
  1285.                 return E_INVALIDARG;
  1286.             else
  1287.                 return ShowPrintDialog(pvarargIn, pvarargOut, nCmdexecopt);
  1289.         case OLECMDID_PROPERTIES:
  1290.             if (!pvarargIn)
  1291.                 return E_INVALIDARG;
  1292.             else
  1293.                 return ShowPropertysheetDialog(pvarargIn, pvarargOut, nCmdexecopt);
  1295.         case SHDVID_CLSIDTOMONIKER:
  1296.             if (!pvarargIn || !pvarargOut)
  1297.                 return E_INVALIDARG;
  1298.             else
  1299.                 return ClsidToMoniker(pvarargIn, pvarargOut);
  1301.         default:
  1302.             return OLECMDERR_E_NOTSUPPORTED;
  1303.         }
  1304.     }
  1306.     return OLECMDERR_E_UNKNOWNGROUP;
  1307. }
  1309. //+---------------------------------------------------------------------------
  1310. //
  1311. //  Helper for OLECMDID_SHOWSCRIPTERROR
  1312. //
  1313. //+---------------------------------------------------------------------------
  1315. void CDocHostUIHandler::ShowErrorDialog(VARIANTARG *pvarargIn, VARIANTARG *pvarargOut, DWORD)
  1316. {
  1317.     HRESULT hr;
  1318.     HWND hwnd;
  1319.     IHTMLEventObj * pEventObj = NULL;
  1320.     IMoniker * pmk = NULL;
  1321.     VARIANT varEventObj;
  1322.     TCHAR   szResURL[MAX_URL_STRING];
  1324.     hr = GetHwndFromUnknown(V_UNKNOWN(pvarargIn), &hwnd);
  1325.     if (hr)
  1326.         goto Cleanup;
  1328.     hr = GetEventFromUnknown(V_UNKNOWN(pvarargIn), &pEventObj);
  1329.     if (hr)
  1330.         goto Cleanup;
  1332.     hr = MLBuildResURLWrap(TEXT("shdoclc.dll"),
  1333.                            HINST_THISDLL,
  1334.                            ML_CROSSCODEPAGE,
  1335.                            TEXT("error.dlg"),
  1336.                            szResURL,
  1337.                            ARRAYSIZE(szResURL),
  1338.                            TEXT("shdocvw.dll"));
  1339.     if (FAILED(hr))
  1340.     {
  1341.         goto Cleanup;
  1342.     }
  1344.     hr = CreateURLMoniker(NULL, szResURL, &pmk);
  1345.     if (FAILED(hr))
  1346.         goto Cleanup;
  1348.     V_VT(&varEventObj) = VT_DISPATCH;
  1349.     V_DISPATCH(&varEventObj) = pEventObj;
  1351.     ShowHTMLDialog(hwnd, pmk, &varEventObj, NULL, pvarargOut);
  1353. Cleanup:
  1354.     ATOMICRELEASE(pEventObj);
  1355.     ATOMICRELEASE(pmk);
  1356. }
  1358. //+---------------------------------------------------------------------------
  1359. //
  1360. //  Callback procedure for OLECMDID_SHOWMESSAGE dialog
  1361. //
  1362. //+---------------------------------------------------------------------------
  1363. struct MSGBOXCALLBACKINFO
  1364. {
  1365.     DWORD   dwHelpContext;
  1366.     TCHAR * pstrHelpFile;
  1367.     HWND    hwnd;
  1368. };
  1370. static void CALLBACK
  1371. MessageBoxCallBack(HELPINFO *phi)
  1372. {
  1373.     MSGBOXCALLBACKINFO  *p = (MSGBOXCALLBACKINFO *)phi->dwContextId;
  1374.     BOOL                fRet;
  1376.     fRet = WinHelp(
  1377.             p->hwnd,
  1378.             p->pstrHelpFile,
  1379.             HELP_CONTEXT,
  1380.             p->dwHelpContext);
  1382.     THR(fRet ? S_OK : E_FAIL);
  1383. }
  1385. //+---------------------------------------------------------------------------
  1386. //
  1387. //  Helper for OLECMDID_SHOWMESSAGE
  1388. //
  1389. //+---------------------------------------------------------------------------
  1391. HRESULT
  1392. CDocHostUIHandler::ShowMessage(VARIANTARG *pvarargIn, VARIANTARG *pvarargOut, DWORD)
  1393. {
  1395. // must match order of MessageEnum
  1396. static const SExpandoInfo s_aMessageExpandos[] =
  1397. {
  1398.     {TEXT("messageText"),         VT_BSTR},
  1399.     {TEXT("messageCaption"),      VT_BSTR},
  1400.     {TEXT("messageStyle"),        VT_UI4},
  1401.     {TEXT("messageHelpFile"),     VT_BSTR},
  1402.     {TEXT("messageHelpContext"),  VT_UI4}
  1403. };
  1405.     HRESULT             hr;
  1406.     HWND                hwnd = NULL;
  1407.     MSGBOXPARAMS        mbp;
  1408.     MSGBOXCALLBACKINFO  mcbi;
  1409.     LRESULT             plResult = 0;
  1410.     LPOLESTR            lpstrText = NULL;
  1411.     LPOLESTR            lpstrCaption = NULL;
  1412.     DWORD               dwType = 0;
  1413.     LPOLESTR            lpstrHelpFile = NULL;
  1414.     DWORD               dwHelpContext = 0;
  1416.     IHTMLEventObj     * pEventObj = NULL;
  1417.     const int           cExpandos = ARRAYSIZE(s_aMessageExpandos);
  1418.     DISPID              aDispid[cExpandos];
  1419.     VARIANT             aVariant[cExpandos];
  1420.     int                 i;
  1422.     ASSERT(pvarargIn && pvarargOut);
  1424.     for(i=0; i<cExpandos; i++)
  1425.         VariantInit(aVariant + i);
  1427.     ASSERT(V_VT(pvarargIn) == VT_UNKNOWN);
  1428.     if ((V_VT(pvarargIn) != VT_UNKNOWN) || !V_UNKNOWN(pvarargIn))
  1429.     {
  1430.         hr = E_INVALIDARG;
  1431.         goto Cleanup;
  1432.     }
  1434.     GetHwndFromUnknown(V_UNKNOWN(pvarargIn), &hwnd);  // hwnd can be NULL
  1435.     hr = GetEventFromUnknown(V_UNKNOWN(pvarargIn), &pEventObj);
  1436.     if (hr)
  1437.         goto Cleanup;
  1439.     // Get parameters from event object
  1440.     hr = GetParamsFromEvent(
  1441.             pEventObj,
  1442.             cExpandos,
  1443.             aDispid,
  1444.             aVariant,
  1445.             s_aMessageExpandos);
  1446.     if (hr)
  1447.         goto Cleanup;
  1449.     // Copy values from variants
  1450.     lpstrText = V_BSTR(&aVariant[MessageText]);
  1451.     lpstrCaption = V_BSTR(&aVariant[MessageCaption]);
  1452.     dwType = V_UI4(&aVariant[MessageStyle]);
  1453.     lpstrHelpFile = V_BSTR(&aVariant[MessageHelpFile]);
  1454.     dwHelpContext = V_UI4(&aVariant[MessageHelpContext]);
  1456.     // Set message box callback info
  1457.     mcbi.dwHelpContext = dwHelpContext;
  1458.     mcbi.pstrHelpFile = lpstrHelpFile;
  1459.     mcbi.hwnd = hwnd;
  1461.     // Set message box params
  1462.     memset(&mbp, 0, sizeof(mbp));
  1463.     mbp.cbSize = sizeof(mbp);
  1464.     mbp.hwndOwner = hwnd;           // It is okay if this is NULL
  1465.     mbp.hInstance = MLGetHinst();
  1466.     mbp.lpszText = lpstrText;
  1467.     mbp.lpszCaption = lpstrCaption;
  1468.     mbp.dwContextHelpId = (DWORD_PTR) &mcbi;
  1469.     mbp.lpfnMsgBoxCallback = MessageBoxCallBack;
  1470.     // mbp.dwLanguageID = ?
  1471.     mbp.dwStyle = dwType;
  1473.     if (dwHelpContext && lpstrHelpFile)
  1474.         mbp.dwStyle |= MB_HELP;
  1476.     if (mbp.hwndOwner == NULL)
  1477.         mbp.dwStyle |= MB_TASKMODAL;
  1479.     plResult = MessageBoxIndirect(&mbp);
  1481. Cleanup:
  1482.     V_VT(pvarargOut) = VT_I4;
  1483.     V_I4(pvarargOut) = (LONG)plResult;
  1485.     for (i=0; i<cExpandos; i++)
  1486.         VariantClear(&aVariant[i]);
  1488.     ATOMICRELEASE(pEventObj);
  1490.     return hr;
  1491. }
  1494. BOOL CDocHostUIHandler::IsFindDialogUp(IWebBrowser2* pwb, IHTMLWindow2** ppWindow)
  1495. {
  1496.     BSTR bstrName = SysAllocString(STR_FIND_DIALOG_NAME);
  1497.     VARIANT var;
  1498.     VariantInit(&var);
  1500.     if (bstrName)
  1501.     {
  1502.         ASSERT(pwb);
  1504.         pwb->GetProperty(bstrName, &var);
  1506.         if ( (var.vt == VT_DISPATCH) && (var.pdispVal != NULL) )
  1507.         {
  1508.             //GetProperty addref's it
  1509.             var.pdispVal->Release();
  1510.         
  1511.             if (ppWindow)
  1512.                 *ppWindow = (IHTMLWindow2*)var.pdispVal;
  1513.         }
  1514.         SysFreeString(bstrName);
  1515.     }
  1517.     return ( (var.vt == VT_DISPATCH) && (var.pdispVal != NULL) );
  1518. }
  1520. //if this fails, then we have no choice but to orphan the dialog
  1521. void SetFindDialogUp(IWebBrowser2* pwb, IHTMLWindow2* pWindow)
  1522. {
  1523.     BSTR bstrName = SysAllocString(STR_FIND_DIALOG_NAME);
  1525.     if (bstrName)
  1526.     {
  1527.         ASSERT(pwb);
  1529.         VARIANT var;
  1530.         VariantInit(&var);
  1531.         var.vt = VT_DISPATCH;
  1532.         var.pdispVal = pWindow;
  1534.         pwb->PutProperty(bstrName, var);
  1536.         SysFreeString(bstrName);
  1537.     }
  1538. }
  1541. //+---------------------------------------------------------------------------
  1542. //
  1543. //  Helper for OLECMDID_SHOWFIND
  1544. //
  1545. //  pvarargIn - IDispatch Interface
  1546. //  dwflags   - bidi flag
  1547. //+---------------------------------------------------------------------------
  1549. void
  1550. CDocHostUIHandler::ShowFindDialog(VARIANTARG *pvarargIn, VARIANTARG *pvarargOut, DWORD dwflags)
  1551. {
  1552.     IDispatch             * pDispatch = NULL;
  1553.     IHTMLOptionsHolder    * pHTMLOptionsHolder = NULL;
  1554.     IHTMLDocument2        * pHTMLDocument2 = NULL;
  1555.     IHTMLWindow2          * pHTMLWindow2 = NULL;
  1556.     IOleInPlaceFrame      * pOleInPlaceFrame = NULL;
  1557.     HWND                    hwnd = NULL;
  1558.     IMoniker              * pmk = NULL;
  1560.     if (EVAL(V_VT(pvarargIn) == VT_DISPATCH))
  1561.     {
  1562.         pDispatch = V_DISPATCH(pvarargIn);
  1563.         
  1564.         if (SUCCEEDED(pDispatch->QueryInterface(IID_IHTMLOptionsHolder, (void**)&pHTMLOptionsHolder)))
  1565.         {
  1566.             if (SUCCEEDED(pHTMLOptionsHolder->get_document(&pHTMLDocument2)) && pHTMLDocument2)
  1567.             {
  1568.                 if (SUCCEEDED(pHTMLDocument2->get_parentWindow(&pHTMLWindow2)))
  1569.                 {
  1570.                     if (SUCCEEDED(GetInPlaceFrameFromUnknown(pHTMLDocument2, &pOleInPlaceFrame)))
  1571.                     {
  1572.                         if (SUCCEEDED(pOleInPlaceFrame->GetWindow(&hwnd)))
  1573.                         {
  1574.                             BOOL fInBrowser = FALSE;
  1575.                             IWebBrowser2 * pwb2 = NULL;
  1576.                             IServiceProvider * psp;
  1578.                             if (SUCCEEDED(IUnknown_QueryService(_punkSite, SID_STopLevelBrowser, IID_IServiceProvider, (LPVOID*)&psp)))
  1579.                             {
  1580.                                 if (SUCCEEDED(psp->QueryService(SID_SWebBrowserApp, IID_IWebBrowser2, (LPVOID*)&pwb2)))
  1581.                                 {
  1582.                                     fInBrowser = TRUE;
  1583.                                 }
  1584.                                 psp->Release();
  1585.                             }
  1587.                             TCHAR   szResURL[MAX_URL_STRING];
  1589.                             if (SUCCEEDED(MLBuildResURLWrap(TEXT("shdoclc.dll"),
  1590.                                                             HINST_THISDLL,
  1591.                                                             ML_CROSSCODEPAGE,
  1592.                                                             (dwflags ? TEXT("bidifind.dlg") : TEXT("find.dlg")),
  1593.                                                             szResURL,
  1594.                                                             ARRAYSIZE(szResURL),
  1595.                                                             TEXT("shdocvw.dll"))))
  1596.                             {
  1597.                                 CreateURLMoniker(NULL, szResURL, &pmk);
  1599.                                 if (fInBrowser)
  1600.                                 {
  1601.                                     IHTMLWindow2 *pWinOut;
  1603.                                     if (!IsFindDialogUp(pwb2, NULL))
  1604.                                     {
  1606.                                         if ((NULL != pvarargIn) && 
  1607.                                             (VT_DISPATCH == pvarargIn->vt) &&
  1608.                                             (NULL != pvarargIn->pdispVal))
  1609.                                         {
  1610.                                             BSTR bstrFindText = GetFindText(pwb2);
  1612.                                             if (NULL != bstrFindText)
  1613.                                             {
  1614.                                                 //  paranoia since we hang on to this object
  1615.                                                 //  a while and there is always potential 
  1616.                                                 //  for screw ups below where we mean to
  1617.                                                 //  release it.
  1618.                                                 ATOMICRELEASE(_pOptionsHolder);
  1620.                                                 pvarargIn->pdispVal->QueryInterface(
  1621.                                                                      IID_IHTMLOptionsHolder,
  1622.                                                                      (void **)&_pOptionsHolder);
  1623.                                                 if (NULL != _pOptionsHolder)
  1624.                                                 {
  1625.                                                     _pOptionsHolder->put_findText(bstrFindText);
  1626.                                                 }
  1627.                                                 
  1628.                                                 SysFreeString(bstrFindText);
  1629.                                             }
  1630.                                         }
  1632.                                         ShowModelessHTMLDialog(hwnd, pmk, pvarargIn, NULL, &pWinOut);
  1634.                                         if (pWinOut)
  1635.                                         {
  1636.                                             //can't really handle failure here, because the dialog is already up.
  1637.                                             BSTR bstrOnunload = SysAllocString(L"onunload");
  1638.                                             if (bstrOnunload)
  1639.                                             {
  1640.                                                 IHTMLWindow3 * pWin3;
  1642.                                                 if (SUCCEEDED(pWinOut->QueryInterface(IID_IHTMLWindow3, (void**)&pWin3)))
  1643.                                                 {
  1644.                                                     VARIANT_BOOL varBool;
  1645.                                                     pWin3->attachEvent(bstrOnunload, (IDispatch*)this, &varBool);
  1646.                                                     pWin3->Release();
  1647.                                                 }
  1648.                                                 SysFreeString(bstrOnunload);
  1649.                                             }
  1650.                                             SetFindDialogUp(pwb2, pWinOut);
  1651.                                         }        
  1652.                                     }
  1653.                                     else
  1654.                                     {
  1655.                                         //this time, get the pointer to the window. 
  1656.                                         //note that none of this will cause an addref.
  1657.                                         EVAL(IsFindDialogUp(pwb2, &pWinOut));
  1659.                                         //since the find dialog is already up, send focus to it
  1660.                                         if (pWinOut)
  1661.                                             pWinOut->focus();
  1662.                                     }
  1663.                                 }
  1664.                                 else
  1665.                                 {
  1666.                                     //we're not in the browser, so just show it modal
  1667.                                     ShowHTMLDialog(hwnd, pmk, pvarargIn, NULL, NULL);
  1668.                                 }
  1669.                                 if (pmk)
  1670.                                     pmk->Release();
  1671.                             }
  1672.                             ATOMICRELEASE(pwb2);
  1674.                         }
  1675.                         pOleInPlaceFrame->Release();
  1676.                     }
  1677.                     pHTMLWindow2->Release();
  1678.                 }
  1679.                 pHTMLDocument2->Release();
  1680.             }
  1681.             pHTMLOptionsHolder->Release();
  1682.         }
  1683.     }
  1685.     //pWinOut gets released in CDocHostUIHandler::Invoke() or CIEFrameAuto::COmWindow::ViewReleased(),
  1686.     // in response to the onunload event.
  1687.     
  1688.     if (pvarargOut)
  1689.         VariantInit(pvarargOut);
  1690. }
  1692. //+---------------------------------------------------------------------------
  1693. //
  1694. //  Callback procedure for OLECMDID_SHOWPAGESETUP dialog
  1695. //
  1696. //+---------------------------------------------------------------------------
  1697. struct PAGESETUPBOXCALLBACKINFO
  1698. {
  1699.     TCHAR   strHeader[1024];
  1700.     TCHAR   strFooter[1024];
  1701. };
  1703. UINT_PTR APIENTRY
  1704. PageSetupHookProc(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
  1705. {
  1706.     HKEY    keyPageSetup = NULL;
  1708.     switch (uiMsg)
  1709.     {
  1710.     case WM_INITDIALOG:
  1711.         PAGESETUPBOXCALLBACKINFO * ppscbi;
  1712.         ppscbi = (PAGESETUPBOXCALLBACKINFO *) ((PAGESETUPDLG*)lParam)->lCustData;
  1713.         SetWindowLongPtr(hdlg, DWLP_USER, (LONG_PTR)ppscbi);
  1715. #ifdef UNIX
  1716.         SendDlgItemMessage(hdlg,IDC_EDITHEADER, EM_LIMITTEXT, 1023, 0L);
  1717.         SendDlgItemMessage(hdlg,IDC_EDITFOOTER, EM_LIMITTEXT, 1023, 0L);
  1718. #endif
  1719.         SetDlgItemText(hdlg,IDC_EDITHEADER, ppscbi->strHeader);
  1720.         SetDlgItemText(hdlg,IDC_EDITFOOTER, ppscbi->strFooter);
  1721.         return TRUE;
  1723.     case WM_COMMAND:
  1724.         switch (GET_WM_COMMAND_ID(wParam, lParam))
  1725.         {
  1726.         case IDOK:
  1727.             {
  1728.                 PAGESETUPBOXCALLBACKINFO * ppscbi;
  1729.                 ppscbi = (PAGESETUPBOXCALLBACKINFO *) GetWindowLongPtr(hdlg, DWLP_USER);
  1730.                 if (ppscbi)
  1731.                 {
  1732.                     GetDlgItemText(hdlg,IDC_EDITHEADER, ppscbi->strHeader,1024);
  1733.                     GetDlgItemText(hdlg,IDC_EDITFOOTER, ppscbi->strFooter,1024);
  1734.                 }
  1735.             }
  1736.         }
  1737.         break;
  1739.    case WM_HELP:
  1740.     {
  1741.         LPHELPINFO pHI;
  1744.         pHI = (LPHELPINFO)lParam;
  1745.         if (pHI->iContextType == HELPINFO_WINDOW)   // must be for a control
  1746.         {
  1747.             WinHelp(
  1748.                     (HWND)pHI->hItemHandle,
  1749.                     GetHelpFile(pHI->iCtrlId, (DWORD *)aPageSetupDialogHelpIDs),
  1750.                     HELP_WM_HELP,
  1751.                     (DWORD_PTR)(LPVOID) aPageSetupDialogHelpIDs);
  1752.         }
  1753.         break;
  1754.         //return TRUE;
  1755.     }
  1757.     case WM_CONTEXTMENU:
  1758.     {
  1759.         int CtrlID = GetControlID((HWND)wParam, lParam);
  1761.         WinHelp(
  1762.                 (HWND)wParam,
  1763.                 GetHelpFile(CtrlID, (DWORD *)aPageSetupDialogHelpIDs),
  1764.                 HELP_CONTEXTMENU,
  1765.                 (DWORD_PTR)(LPVOID) aPageSetupDialogHelpIDs);
  1766.         break;
  1767.     }
  1768.     }
  1770.     return FALSE;
  1771. }
  1773. //+---------------------------------------------------------------------------
  1774. //
  1775. //  Helper for OLECMDID_SHOWPAGESETUP
  1776. //
  1777. //  pvarargIn - holds IHTMLEventObj * for the event
  1778. //
  1779. // Returns S_FALSE if the user clicked Cancel and S_TRUE if the user
  1780. // clicked OK.
  1781. //+---------------------------------------------------------------------------
  1783. HRESULT
  1784. CDocHostUIHandler::ShowPageSetupDialog(VARIANTARG *pvarargIn, VARIANTARG *pvarargOut, DWORD)
  1785. {
  1787. // must match order of PagesetupEnum
  1788. static const SExpandoInfo s_aPagesetupExpandos[] =
  1789. {
  1790.     {OLESTR("pagesetupHeader"),  VT_BSTR},
  1791.     {OLESTR("pagesetupFooter"),  VT_BSTR},
  1792.     {OLESTR("pagesetupStruct"),  VT_INT_PTR}
  1793. };
  1795.     HRESULT                         hr = E_FAIL;
  1796.     PAGESETUPDLG                  * ppagesetupdlg = NULL;
  1797.     PAGESETUPBOXCALLBACKINFO        pagesetupcbi;
  1799.     IHTMLEventObj                 * pEventObj = NULL;
  1800.     const int                       cExpandos = ARRAYSIZE(s_aPagesetupExpandos);
  1801.     DISPID                          aDispid[cExpandos];
  1802.     VARIANT                         aVariant[cExpandos];
  1803.     int                             i;
  1805.     for (i=0; i<cExpandos; i++)
  1806.         VariantInit(aVariant+i);
  1808.     ASSERT(pvarargIn && (V_VT(pvarargIn) == VT_UNKNOWN));
  1809.     if ((V_VT(pvarargIn) != VT_UNKNOWN) || !V_UNKNOWN(pvarargIn))
  1810.         goto Cleanup;
  1812.     if (V_UNKNOWN(pvarargIn)->QueryInterface(IID_IHTMLEventObj, (void **) &pEventObj))
  1813.         goto Cleanup;
  1815.     // Get parameters from event object
  1816.     if (GetParamsFromEvent(
  1817.             pEventObj,
  1818.             cExpandos,
  1819.             aDispid,
  1820.             aVariant,
  1821.             s_aPagesetupExpandos))
  1822.         goto Cleanup;
  1824.     // Copy values from variants
  1825.     StrCpyN((TCHAR*)pagesetupcbi.strHeader,
  1826.         V_BSTR(&aVariant[PagesetupHeader]) ? V_BSTR(&aVariant[PagesetupHeader]) : TEXT(""),
  1827.         ARRAYSIZE(pagesetupcbi.strHeader));
  1828.     StrCpyN((TCHAR*)pagesetupcbi.strFooter,
  1829.         V_BSTR(&aVariant[PagesetupFooter]) ? V_BSTR(&aVariant[PagesetupFooter]) : TEXT(""),
  1830.         ARRAYSIZE(pagesetupcbi.strHeader));
  1832.     ppagesetupdlg = (PAGESETUPDLG *)V_BYREF(&aVariant[PagesetupStruct]);
  1833.     if (!ppagesetupdlg)
  1834.         goto Cleanup;
  1836.     // Set up custom dialog resource fields in pagesetupdlg
  1837.     ppagesetupdlg->Flags |= PSD_ENABLEPAGESETUPHOOK | PSD_ENABLEPAGESETUPTEMPLATE;
  1838.     ppagesetupdlg->lCustData = (LPARAM) &pagesetupcbi;
  1839.     ppagesetupdlg->lpfnPageSetupHook = PageSetupHookProc;
  1840.     ppagesetupdlg->hInstance = MLLoadShellLangResources();
  1842. #ifdef UNIX
  1843.     ppagesetupdlg->lpPageSetupTemplateName = MAKEINTRESOURCE(PAGESETUPDLGORDMOTIF);
  1844. #else
  1845.     ppagesetupdlg->lpPageSetupTemplateName = MAKEINTRESOURCE(PAGESETUPDLGORD);
  1846. #endif // UNIX
  1848.     // Show dialog
  1849.     if (!PageSetupDlg(ppagesetupdlg))
  1850.     {
  1851.         // treat failure as canceling
  1852.         hr = S_FALSE;
  1853.         goto Cleanup;
  1854.     }
  1855.     hr = S_OK;
  1857.     // Save header/footer in event object
  1858.     VARIANT var;
  1860.     V_VT(&var) = VT_BSTR;
  1861.     V_BSTR(&var) = SysAllocString(pagesetupcbi.strHeader ? pagesetupcbi.strHeader : TEXT(""));
  1862.     if (NULL != V_BSTR(&var))
  1863.     {
  1864.         PutParamToEvent(aDispid[PagesetupHeader], &var, pEventObj);
  1865.         VariantClear(&var);
  1866.     }
  1868.     V_VT(&var) = VT_BSTR;
  1869.     V_BSTR(&var) = SysAllocString(pagesetupcbi.strFooter ? pagesetupcbi.strFooter : TEXT(""));
  1870.     if (NULL != V_BSTR(&var))
  1871.     {
  1872.         PutParamToEvent(aDispid[PagesetupFooter], &var, pEventObj);
  1873.         VariantClear(&var);
  1874.     }
  1876. Cleanup:
  1877.     MLFreeLibrary(ppagesetupdlg->hInstance);
  1879.     for (i=0; i<cExpandos; i++)
  1880.         VariantClear(&aVariant[i]);
  1882.     if (pvarargOut)
  1883.         VariantInit(pvarargOut);
  1885.     ATOMICRELEASE(pEventObj);
  1887.     return hr;
  1888. }
  1890. //+---------------------------------------------------------------------------
  1891. //
  1892. //  Callback procedure for OLECMDID_SHOWPRINT dialog
  1893. //
  1894. //+---------------------------------------------------------------------------
  1896. static void SetPreviewBitmap(long bitmapID, HWND hdlg);
  1897. HRESULT GetPrintFileName(HWND hwnd, TCHAR achFilePath[]);
  1899. struct PRINTBOXCALLBACKINFO
  1900. {
  1901.     BOOL    fRootDocumentHasFrameset;
  1902.     BOOL    fAreRatingsEnabled;
  1903.     BOOL    fPrintActiveFrame;
  1904.     BOOL    fPrintLinked;
  1905.     BOOL    fPrintSelection;
  1906.     BOOL    fPrintAsShown;
  1907.     BOOL    fShortcutTable;
  1908.     int     iFontScaling;
  1909.     IOleCommandTarget * pBodyActive;
  1910. #ifdef UNIX
  1911.     int     dmOrientation
  1912. #endif // UNIX
  1913. };
  1915. // Common handling functions for both NT 5 and legacy print dialogs
  1916. void OnInitDialog( HWND hdlg, PRINTBOXCALLBACKINFO * ppcbi )
  1917. {
  1918.     if (ppcbi)
  1919.     {
  1920.         // Set the frameset default depending on contents of the PRINTINFOBAG
  1921.         if (ppcbi->fPrintActiveFrame)
  1922.         {
  1923.             // Check "print selected frame" radiobutton.
  1924.             CheckRadioButton(hdlg, rad4, rad6, rad5);
  1925.             SetPreviewBitmap(IDR_PRINT_PREVIEWONEDOC, hdlg);
  1926. //           BUBUG
  1927. //           If the focus rect gets fixed, we need a way locking it
  1928. //           from shdocvw.
  1929. //             if(ppcbi->pBodyActive);
  1930. //                 ppcbi->pBodyActive->Layout()->LockFocusRect(TRUE);
  1931.         }
  1932.         else // No frame or iframe selected:
  1933.         {
  1934.             // Disable "print selected frame" radiobutton.
  1935.             HWND hwndPrintActiveFrame = GetDlgItem(hdlg, rad5);
  1936.             EnableWindow(hwndPrintActiveFrame, FALSE);
  1938.             // Check "print all frames" radiobutton.
  1939.             CheckRadioButton(hdlg, rad4, rad6, rad6);
  1940.             SetPreviewBitmap(IDR_PRINT_PREVIEWALLDOCS, hdlg);
  1941.             if (!ppcbi->fRootDocumentHasFrameset)
  1942.             {
  1943.                 HWND hwndPrintAsLaidOutOnScreen = GetDlgItem(hdlg, rad4);
  1945.                 // Since no frame or iframe is selected and we are not a frameset,
  1946.                 // disable "print as laid out on screen" radiobutton.
  1947.                 EnableWindow(hwndPrintAsLaidOutOnScreen, FALSE);
  1948.                 SetPreviewBitmap(IDR_PRINT_PREVIEWDISABLED, hdlg);
  1949.             }
  1950. //            if(ppcbi->pBodyActive);
  1951. //                ppcbi->pBodyActive->Layout()->LockFocusRect(FALSE);
  1952.         }
  1954.         HWND hwndSelection = GetDlgItem(hdlg, rad2);
  1955.         if (hwndSelection) EnableWindow(hwndSelection, (ppcbi->fPrintSelection));
  1957.         // If there is no frameset, disable "print all frames" radiobutton.
  1958.         if (!ppcbi->fRootDocumentHasFrameset)
  1959.         {
  1960.             HWND hwndPrintAllFrames = GetDlgItem(hdlg, rad6);
  1961.             EnableWindow(hwndPrintAllFrames, FALSE);
  1962.         }
  1964. #ifdef FONTSIZE_BOX
  1965.         int i=0, cbLen=0;
  1967.         //bugwin16: need to fix this.
  1968.         for (i = 0; i < IDS_PRINT_FONTMAX; i++)
  1969.         {
  1970.             TCHAR   achBuffer[128];
  1972.             cbLen = MLLoadShellLangString(IDS_PRINT_FONTSCALE+i,achBuffer,127);
  1973.             if (cbLen)
  1974.             {
  1975.                 SendDlgItemMessage(hdlg, IDC_SCALING, CB_ADDSTRING, 0, (long) achBuffer);
  1976.             }
  1977.         }
  1979.         if (i>0)
  1980.         {
  1981.             SendDlgItemMessage(hdlg, IDC_SCALING, CB_SETCURSEL, IDS_PRINT_FONTMAX - 1 - ppcbi->iFontScaling, 0);
  1982.         }
  1983. #endif // FONTSIZE_BOX
  1985.         // If ratings are enabled, don't allow recursive printing.
  1986.         if (ppcbi->fAreRatingsEnabled)
  1987.         {
  1988.             HWND hwndPrintLinkedDocuments = GetDlgItem(hdlg, IDC_LINKED);
  1989.             CheckDlgButton(hdlg, IDC_LINKED, BST_UNCHECKED);
  1990.             EnableWindow(hwndPrintLinkedDocuments, FALSE);
  1991.         }
  1992.     }
  1994. #ifdef UNIX
  1995.     {
  1996.        CHAR szPrinterCommand[MAX_PATH];
  1997.        HWND hChkBox;
  1999.        hChkBox = GetDlgItem(hdlg, IDC_LINKED);
  2000.        if (hChkBox)
  2001.            CheckDlgButton(hdlg, IDC_LINKED, FALSE);
  2003.        hChkBox = GetDlgItem(hdlg, IDC_SHORTCUTS);
  2004.        if (hChkBox)
  2005.            CheckDlgButton(hdlg, IDC_SHORTCUTS, FALSE);
  2007.        // Take off Page Setup button from Print Dialog
  2008.        hChkBox = GetDlgItem(hdlg, psh1);
  2009.        if (hChkBox)
  2010.            EnableWindow(hChkBox, TRUE);
  2012.        // Enable user to enter print command
  2013.        MwGetPrintCommand( szPrinterCommand, sizeof( szPrinterCommand ));
  2015.        SendDlgItemMessage(hdlg,edt4, EM_SETLIMITTEXT,
  2016.                           (WPARAM)MAX_COMMAND_LEN, 0);
  2017.        SetDlgItemTextA(hdlg, edt4, szPrinterCommand);
  2018.     }
  2019. #endif  // UNIX
  2021. }
  2023. void OnCommand( HWND hdlg, WPARAM wParam, LPARAM lParam )
  2024. {
  2025.     PRINTBOXCALLBACKINFO * ppcbi;
  2026.     ppcbi = (PRINTBOXCALLBACKINFO *)GetWindowLongPtr(hdlg, DWLP_USER);
  2028.     if (!ppcbi)
  2029.     {
  2030.         return;
  2031.     }
  2033.     switch (GET_WM_COMMAND_ID(wParam, lParam))
  2034.     {
  2035.     case rad1:         // "Print all"
  2036.     case rad3:         // "Print range"
  2037.     case rad2:         // "Print selection" (text selection)
  2038.       {
  2039.         // If we are printing a text selection, and we have a selected frame,
  2040.         // force a print selected frame.
  2041.         if (ppcbi && ppcbi->fPrintActiveFrame && ppcbi->fPrintSelection)
  2042.         {
  2043.             HWND hwndPrintWhatGroup = GetDlgItem(hdlg, grp3);
  2044.             HWND hwndPrintActiveFrame = GetDlgItem(hdlg, rad5);
  2045.             HWND hwndPrintAllFrames = GetDlgItem(hdlg, rad6);
  2046.             HWND hwndPrintSelectedFrame = GetDlgItem(hdlg, rad4);
  2048.             if (hwndPrintWhatGroup)     EnableWindow(hwndPrintWhatGroup, LOWORD(wParam) != rad2);
  2049.             if (hwndPrintActiveFrame)   EnableWindow(hwndPrintActiveFrame, LOWORD(wParam) != rad2);
  2050.             if (hwndPrintAllFrames)     EnableWindow(hwndPrintAllFrames, ppcbi->fRootDocumentHasFrameset && LOWORD(wParam) != rad2);
  2051.             if (hwndPrintSelectedFrame) EnableWindow(hwndPrintSelectedFrame, LOWORD(wParam) != rad2);
  2053.         }
  2055.         break;
  2056.       }
  2058.     case rad4:
  2059.         if (HIWORD(wParam) == BN_CLICKED)
  2060.         {
  2061.             // now change the icon...
  2063.             SetPreviewBitmap(IDR_PRINT_PREVIEW, hdlg);
  2064.             HWND hwnd = GetDlgItem(hdlg, rad2);
  2065.             if (hwnd) EnableWindow(hwnd, FALSE);
  2066.             hwnd = GetDlgItem(hdlg, IDC_SHORTCUTS);
  2067.             if (hwnd) EnableWindow(hwnd, FALSE);
  2068.             hwnd = GetDlgItem(hdlg, IDC_LINKED);
  2069.             if (hwnd) EnableWindow(hwnd, FALSE);
  2070.    //         if(ppcbi->pBodyActive);
  2071.    //             ppcbi->pBodyActive->Layout()->LockFocusRect(FALSE);
  2072.         }
  2073.         break;
  2075.     case rad5:
  2076.         if (HIWORD(wParam) == BN_CLICKED)
  2077.         {
  2078.             // now change the icon
  2080.             SetPreviewBitmap(IDR_PRINT_PREVIEWONEDOC, hdlg);
  2081.             HWND hwnd = GetDlgItem(hdlg, rad2);
  2082.             if (hwnd) EnableWindow(hwnd, (ppcbi->fPrintSelection));
  2083.             hwnd = GetDlgItem(hdlg, IDC_SHORTCUTS);
  2084.             if (hwnd) EnableWindow(hwnd, TRUE);
  2085.             hwnd = GetDlgItem(hdlg, IDC_LINKED);
  2086.             if (hwnd) EnableWindow(hwnd, TRUE);
  2087.    //         if(ppcbi->pBodyActive);
  2088.    //             ppcbi->pBodyActive->Layout()->LockFocusRect(TRUE);
  2089.         }
  2090.         break;
  2092.     case rad6:
  2093.         if (HIWORD(wParam) == BN_CLICKED)
  2094.         {
  2095.             // now change the icon
  2097.             SetPreviewBitmap(IDR_PRINT_PREVIEWALLDOCS, hdlg);
  2098.             HWND hwnd = GetDlgItem(hdlg, rad2);
  2099.             if (hwnd) EnableWindow(hwnd, FALSE);
  2100.             hwnd = GetDlgItem(hdlg, IDC_SHORTCUTS);
  2101.             if (hwnd) EnableWindow(hwnd, TRUE);
  2102.             hwnd = GetDlgItem(hdlg, IDC_LINKED);
  2103.             if (hwnd) EnableWindow(hwnd, TRUE);
  2104.    //         if(ppcbi->pBodyActive);
  2105.    //             ppcbi->pBodyActive->Layout()->LockFocusRect(FALSE);
  2106.         }
  2107.         break;
  2109. #ifdef UNIX
  2110.     case rad7:   // Portrait
  2111.         CheckRadioButton(hdlg, ID_PRINT_R_PORTRAIT,
  2112.                          ID_PRINT_R_LANDSCAPE, ID_PRINT_R_PORTRAIT);
  2113.         break;
  2115.     case rad8:   // Landscape
  2116.         CheckRadioButton(hdlg, ID_PRINT_R_PORTRAIT,
  2117.                          ID_PRINT_R_LANDSCAPE, ID_PRINT_R_LANDSCAPE);
  2118.         break;
  2119. #endif // UNIX
  2120.     }
  2121. }
  2123. void OnHelp( HWND hdlg, WPARAM wParam, LPARAM lParam )
  2124. {
  2125.     LPHELPINFO pHI;
  2127.     pHI = (LPHELPINFO)lParam;
  2128.     if (pHI->iContextType == HELPINFO_WINDOW)   // must be for a control
  2129.     {
  2130.         WinHelp(
  2131.                 (HWND)pHI->hItemHandle,
  2132.                 GetHelpFile(pHI->iCtrlId, (DWORD *) aPrintDialogHelpIDs),
  2133.                 HELP_WM_HELP,
  2134.                 (DWORD_PTR)(LPVOID) aPrintDialogHelpIDs);
  2135.     }
  2136. }
  2138. void OnContextMenu( HWND hdlg, WPARAM wParam, LPARAM lParam )
  2139. {
  2140.     int CtrlID = GetControlID((HWND)wParam, lParam);
  2142.     WinHelp(
  2143.             (HWND)wParam,
  2144.             GetHelpFile(CtrlID, (DWORD *) aPrintDialogHelpIDs),
  2145.             HELP_CONTEXTMENU,
  2146.             (DWORD_PTR)(LPVOID) aPrintDialogHelpIDs);
  2147. }
  2149. void OnApplyOrOK( HWND hdlg, WPARAM wParam, LPARAM lParam )
  2150. {
  2151. #ifdef UNIX
  2152.     CHAR szPrinterCommand[MAX_PATH];
  2153. #endif // UNIX
  2154.     PRINTBOXCALLBACKINFO * ppcbi;
  2155.     ppcbi = (PRINTBOXCALLBACKINFO *)GetWindowLongPtr(hdlg, DWLP_USER);
  2157.     if (ppcbi)
  2158.     {
  2159.         ppcbi->fPrintLinked      = IsDlgButtonChecked(hdlg, IDC_LINKED);
  2160.         ppcbi->fPrintSelection   = IsDlgButtonChecked(hdlg, rad2);
  2161.         ppcbi->fPrintActiveFrame = IsDlgButtonChecked(hdlg, rad5) ||
  2162.                                        ( ppcbi->fPrintSelection &&
  2163.                                          ppcbi->fRootDocumentHasFrameset
  2164.                                         );
  2165.         ppcbi->fPrintAsShown     = IsDlgButtonChecked(hdlg, rad4) ||
  2166.                                        ( ppcbi->fPrintSelection &&
  2167.                                          ppcbi->fRootDocumentHasFrameset
  2168.                                         );
  2169.         ppcbi->fShortcutTable    = IsDlgButtonChecked(hdlg, IDC_SHORTCUTS);
  2170. #ifdef FONTSIZE_BOX
  2171.         ppcbi->iFontScaling      = IDS_PRINT_FONTMAX - 1 - SendDlgItemMessage( hdlg, IDC_SCALING, CB_GETCURSEL, 0,0 );
  2172. #endif
  2174. #ifdef UNIX
  2175.         // Code to deal with orientation on print dialog
  2176.         if ( IsDlgButtonChecked(hdlg, ID_PRINT_R_PORTRAIT) )
  2177.         {
  2178.             ppcbi->dmOrientation = DMORIENT_PORTRAIT;
  2179.         }
  2180.         else
  2181.         {
  2182.             ppcbi->dmOrientation = DMORIENT_LANDSCAPE;
  2183.         }
  2185.         // get user entered printer command
  2186.         GetDlgItemTextA(hdlg, edt4, szPrinterCommand, MAX_PATH);
  2187.         MwSetPrintCommand( szPrinterCommand );
  2188. #endif // UNIX
  2189.     }
  2191. }
  2192. // This is the callback routine (and dlgproc) for the options
  2193. // page in the NT 5 print dialog.
  2194. INT_PTR APIENTRY
  2195. OptionsPageProc(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
  2196. {
  2197.     switch (uiMsg)
  2198.     {
  2199.     case WM_INITDIALOG:
  2200.     {
  2201.         PRINTBOXCALLBACKINFO * ppcbi;
  2202.         ppcbi = (PRINTBOXCALLBACKINFO *) ((PROPSHEETPAGE *)lParam)->lParam;
  2203.         SetWindowLongPtr(hdlg, DWLP_USER, (LONG_PTR)ppcbi);
  2205.         OnInitDialog( hdlg, ppcbi );
  2206.         break;
  2207.     }
  2209.     case WM_NOTIFY:
  2210.         switch (((NMHDR FAR *)lParam)->code)
  2211.         {
  2212.         case PSN_APPLY:
  2213.             OnApplyOrOK( hdlg, wParam, lParam );
  2214.             SetWindowLongPtr (hdlg, DWLP_MSGRESULT, PSNRET_NOERROR);
  2215.             return TRUE;
  2216.             break;
  2218.         case PSN_KILLACTIVE:
  2219.             SetWindowLongPtr (hdlg, DWLP_MSGRESULT, FALSE);
  2220.             return 1;
  2221.             break;
  2223.         case PSN_RESET:
  2224.             SetWindowLongPtr (hdlg, DWLP_MSGRESULT, FALSE);
  2225.             break;
  2226.         }
  2227.         break;
  2229.     case WM_COMMAND:
  2230.         OnCommand( hdlg, wParam, lParam );
  2231.         break;
  2233.     case WM_HELP:
  2234.         OnHelp( hdlg, wParam, lParam );
  2235.         break;
  2237.     case WM_CONTEXTMENU:
  2238.         OnContextMenu( hdlg, wParam, lParam );
  2239.         break;
  2240.     }
  2242.     return FALSE;
  2244. }
  2247. UINT_PTR CALLBACK
  2248. PrintHookProc(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
  2249. {
  2250.     switch (uiMsg)
  2251.     {
  2252.     case WM_INITDIALOG:
  2253.         if (lParam)
  2254.         {
  2255.             PRINTBOXCALLBACKINFO * ppcbi;
  2256.             ppcbi = (PRINTBOXCALLBACKINFO *) ((PRINTDLG*)lParam)->lCustData;
  2257.             SetWindowLongPtr(hdlg, DWLP_USER, (LONG_PTR)ppcbi);
  2259.             OnInitDialog( hdlg, ppcbi );
  2260.         }
  2261.         return TRUE;
  2263.     case WM_COMMAND:
  2264.         {
  2265.             switch (GET_WM_COMMAND_ID(wParam, lParam))
  2266.             {
  2267.             case IDOK:
  2268.                 OnApplyOrOK( hdlg, wParam, lParam );
  2269.                 break;
  2271.             default:
  2272.                 OnCommand( hdlg, wParam, lParam );
  2273.                 break;
  2274.             }
  2275.         }
  2276.         break;
  2278.     case WM_HELP:
  2279.         OnHelp( hdlg, wParam, lParam );
  2280.         break;
  2281.         //return TRUE;
  2283.     case WM_CONTEXTMENU:
  2284.         OnContextMenu( hdlg, wParam, lParam );
  2285.         break;
  2287.     case WM_DESTROY:
  2288.     {
  2289.         PRINTBOXCALLBACKINFO * ppcbi;
  2290.         ppcbi = (PRINTBOXCALLBACKINFO *)GetWindowLongPtr(hdlg, DWLP_USER);
  2291.         ASSERT(ppcbi);
  2293.   //      if(ppcbi && ppcbi->pBodyActive);
  2294.   //          ppcbi->pBodyActive->Layout()->LockFocusRect(FALSE);
  2295.         break;
  2296.     }
  2297.     }
  2299.     return FALSE;
  2300. }
  2302. void SetPreviewBitmap(long bitmapID, HWND hdlg)
  2303. {
  2304.     // now change the icon...(note these bitmaps are not localized)
  2305.     HBITMAP hNewBitmap, hOldBitmap;
  2306.     hNewBitmap = (HBITMAP) LoadImage(HINST_THISDLL, MAKEINTRESOURCE(bitmapID),
  2307.                            IMAGE_BITMAP, 0, 0, LR_DEFAULTSIZE | LR_LOADMAP3DCOLORS );
  2309.     ASSERT(hNewBitmap);
  2310.     if (hNewBitmap)
  2311.     {
  2312.         hOldBitmap = (HBITMAP) SendDlgItemMessage(hdlg, IDC_PREVIEW, STM_SETIMAGE,
  2313.                                                   (WPARAM) IMAGE_BITMAP, (LPARAM) hNewBitmap);
  2315.         if (hOldBitmap)
  2316.         {
  2317.             //VERIFY(DeleteObject(hOldBitmap)!=0);
  2318.             int i;
  2319.             i = DeleteObject(hOldBitmap);
  2320.             ASSERT(i!=0);
  2321.         }
  2322.     }
  2323. }
  2326. //+---------------------------------------------------------------------------
  2327. //
  2328. //  Helper for OLECMDID_SHOWPRINT
  2329. //
  2330. //+---------------------------------------------------------------------------
  2332. HRESULT
  2333. CDocHostUIHandler::ShowPrintDialog(VARIANTARG *pvarargIn, VARIANTARG *pvarargOut, DWORD)
  2334. {
  2336. // the following must match the order of PrintEnum
  2337. static const SExpandoInfo s_aPrintExpandos[] =
  2338. {
  2339.     {OLESTR("printfRootDocumentHasFrameset"),   VT_BOOL},
  2340.     {OLESTR("printfAreRatingsEnabled"),         VT_BOOL},
  2341.     {OLESTR("printfActiveFrame"),               VT_BOOL},
  2342.     {OLESTR("printfLinked"),                    VT_BOOL},
  2343.     {OLESTR("printfSelection"),                 VT_BOOL},
  2344.     {OLESTR("printfAsShown"),                   VT_BOOL},
  2345.     {OLESTR("printfShortcutTable"),             VT_BOOL},
  2346.     {OLESTR("printiFontScaling"),               VT_INT},
  2347.     {OLESTR("printpBodyActiveTarget"),          VT_UNKNOWN},
  2348.     {OLESTR("printStruct"),                     VT_INT_PTR},
  2349.     {OLESTR("printToFileOk"),                   VT_BOOL},
  2350.     {OLESTR("printToFileName"),                 VT_BSTR}
  2351. #ifdef UNIX
  2352.    ,{OLESTR("printdmOrientation"),              VT_INT}
  2353. #endif // UNIX
  2354. };
  2356.     HRESULT                         hr = E_FAIL;
  2357.     PRINTDLG                      * pprintdlg = NULL;
  2358.     PRINTBOXCALLBACKINFO            printcbi;
  2360.     IHTMLEventObj                 * pEventObj = NULL;
  2361.     const int                       cExpandos = ARRAYSIZE(s_aPrintExpandos);
  2362.     DISPID                          aDispid[cExpandos];
  2363.     VARIANT                         aVariant[cExpandos];
  2364.     int                             i;
  2366.     printcbi.pBodyActive = NULL;
  2368.     if (!V_UNKNOWN(pvarargIn))
  2369.         goto Cleanup;
  2371.     if (V_UNKNOWN(pvarargIn)->QueryInterface(IID_IHTMLEventObj, (void **) &pEventObj))
  2372.         goto Cleanup;
  2374.     // Get parameters from event object
  2375.     if (GetParamsFromEvent(
  2376.             pEventObj,
  2377.             cExpandos,
  2378.             aDispid,
  2379.             aVariant,
  2380.             s_aPrintExpandos))
  2381.         goto Cleanup;
  2383.     // Copy values from variants
  2384.     printcbi.fRootDocumentHasFrameset = V_BOOL(&aVariant[PrintfRootDocumentHasFrameset]);
  2385.     printcbi.fAreRatingsEnabled = V_BOOL(&aVariant[PrintfAreRatingsEnabled]);
  2386.     printcbi.fPrintActiveFrame = V_BOOL(&aVariant[PrintfPrintActiveFrame]);
  2387.     printcbi.fPrintLinked = V_BOOL(&aVariant[PrintfPrintLinked]);
  2388.     printcbi.fPrintSelection = V_BOOL(&aVariant[PrintfPrintSelection]);
  2389.     printcbi.fPrintAsShown = V_BOOL(&aVariant[PrintfPrintAsShown]);
  2390.     printcbi.fShortcutTable = V_BOOL(&aVariant[PrintfShortcutTable]);
  2391.     printcbi.iFontScaling = V_INT(&aVariant[PrintiFontScaling]);
  2393.     // BUGBUG if we ever get LockFocusRect, use this field to access it
  2394.     // peterlee 8/7/98
  2395.     /*
  2396.     if (V_UNKNOWN(&aVariant[PrintpBodyActiveTarget]))
  2397.     {
  2398.         if (V_UNKNOWN(&aVariant[PrintpBodyActiveTarget])->QueryInterface(IID_IOleCommandTarget,
  2399.                 (void**)&printcbi.pBodyActive))
  2400.             goto Cleanup;
  2401.     }
  2402.     */
  2404.     pprintdlg = (PRINTDLG *)V_BYREF(&aVariant[PrintStruct]);
  2405.     if (!pprintdlg)
  2406.         goto Cleanup;
  2408.     // Set up custom dialog resource fields in pagesetupdlg
  2409.     pprintdlg->hInstance            = MLLoadShellLangResources();
  2410.     pprintdlg->lCustData            = (LPARAM) &printcbi;
  2411.     pprintdlg->lpfnPrintHook        = PrintHookProc;
  2412. #ifdef UNIX
  2413.     pprintdlg->lpPrintTemplateName  = MAKEINTRESOURCE(PRINTDLGORDMOTIF);
  2414.     pprintdlg->Flags |= PD_SHOWHELP;
  2415.     pprintdlg->Flags |= PD_ENABLESETUPHOOK;
  2416.     pprintdlg->lpfnSetupHook = PageSetupHookProc;
  2417. #else
  2418.     pprintdlg->lpPrintTemplateName  = MAKEINTRESOURCE(PRINTDLGORD);
  2419. #endif // UNIX
  2421.     if (g_bRunOnNT5)
  2422.     {
  2423.         // We want to use the new PrintDlgEx in NT 5, so map all the PrintDlg
  2424.         // settings to the new PrintDlgEx, get a pointer to the new function
  2425.         // and then call it.
  2427.         // Load the function from comdlg32 directly...
  2428.         typedef HRESULT (*PFNPRINTDLGEX)(LPPRINTDLGEX pdex);
  2429.         PFNPRINTDLGEX pfnPrintDlgEx = NULL;
  2430.         HMODULE hComDlg32 = LoadLibrary( TEXT("comdlg32.dll") );
  2432.         if (hComDlg32)
  2433.         {
  2434.             pfnPrintDlgEx = (PFNPRINTDLGEX)GetProcAddress( hComDlg32, "PrintDlgExW" );
  2435.         }
  2438.         // Make sure we can call the function...
  2439.         if (!pfnPrintDlgEx)
  2440.         {
  2441.             if (hComDlg32)
  2442.             {
  2443.                 FreeLibrary( hComDlg32 );
  2444.             }
  2445.             hr = E_FAIL;
  2446.             goto Cleanup;
  2447.         }
  2449.         PRINTDLGEX      pdex;
  2450.         PROPSHEETPAGE   psp;
  2451.         HPROPSHEETPAGE  pages[1];
  2452.         PRINTPAGERANGE  ppr;
  2454.         // Copy over existing settings
  2455.         memset( &pdex, 0, sizeof(pdex) );
  2456.         pdex.lStructSize = sizeof(pdex);
  2457.         pdex.hwndOwner   = pprintdlg->hwndOwner;
  2458.         pdex.hDevMode    = pprintdlg->hDevMode;
  2459.         pdex.hDevNames   = pprintdlg->hDevNames;
  2460.         pdex.hDC         = pprintdlg->hDC;
  2461.         pdex.Flags       = pprintdlg->Flags;
  2462.         pdex.nMinPage    = pprintdlg->nMinPage;
  2463.         pdex.nMaxPage    = pprintdlg->nMaxPage;
  2464.         pdex.nCopies     = pprintdlg->nCopies;
  2466.         // New settings
  2467.         pdex.nStartPage     = START_PAGE_GENERAL;
  2468.         ppr.nFromPage       = pprintdlg->nFromPage;
  2469.         ppr.nToPage         = pprintdlg->nToPage;
  2470.         pdex.nPageRanges    = 1;
  2471.         pdex.nMaxPageRanges = 1;
  2472.         pdex.lpPageRanges   = &ppr;
  2474.         // Create options page
  2475.         memset( &psp, 0, sizeof(psp) );
  2476.         psp.dwSize       = sizeof(psp);
  2477.         psp.dwFlags      = PSP_DEFAULT;
  2478.         psp.hInstance    = pprintdlg->hInstance;
  2479.         psp.pszTemplate  = MAKEINTRESOURCE(IDD_PRINTOPTIONS);
  2480.         psp.pfnDlgProc   = OptionsPageProc;
  2481.         psp.lParam       = (LPARAM)&printcbi;
  2483.         pages[0] = CreatePropertySheetPage(&psp);
  2485.         if (pages[0])
  2486.         {
  2488.             pdex.nPropertyPages = 1;
  2489.             pdex.lphPropertyPages = pages;
  2491.             // Show the dialog
  2492.             hr = pfnPrintDlgEx(&pdex);
  2494.             if (SUCCEEDED(hr))
  2495.             {
  2496.                 hr = S_FALSE;
  2498.                 if ((pdex.dwResultAction == PD_RESULT_PRINT) || (pdex.Flags & PD_RETURNDEFAULT))
  2499.                 {
  2500.                     // copy back values which might have changed
  2501.                     // during the call to PrintDlgEx
  2502.                     pprintdlg->Flags     = pdex.Flags;
  2503.                     pprintdlg->hDevMode  = pdex.hDevMode;
  2504.                     pprintdlg->hDevNames = pdex.hDevNames;
  2505.                     pprintdlg->nCopies   = (WORD)pdex.nCopies;
  2506.                     pprintdlg->nFromPage = (WORD)ppr.nFromPage;
  2507.                     pprintdlg->nToPage   = (WORD)ppr.nToPage;
  2508.                     if (pprintdlg->Flags & PD_RETURNDC)
  2509.                     {
  2510.                         pprintdlg->hDC = pdex.hDC;
  2511.                     }
  2513.                     hr = S_OK;
  2514.                 }
  2515.                 else if ((pdex.Flags & (PD_RETURNDC | PD_RETURNIC)) && pdex.hDC)
  2516.                 {
  2517.                     DeleteDC(pdex.hDC);
  2518.                     pdex.hDC = NULL;
  2519.                 }
  2520.             }
  2521.             else
  2522.             {
  2523.                 hr = S_FALSE;
  2524.             }
  2526.             FreeLibrary( hComDlg32 );
  2527.         }
  2528.         else
  2529.         {
  2530.             FreeLibrary( hComDlg32 );
  2531.             hr = E_OUTOFMEMORY;
  2532.             goto Cleanup;
  2533.         }
  2537.     }
  2538.     else
  2539.     {
  2540.         pprintdlg->Flags |= PD_ENABLEPRINTTEMPLATE | PD_ENABLEPRINTHOOK;
  2542.         // Show dialog
  2543.         if (!PrintDlg(pprintdlg))
  2544.         {
  2545.            // treat failure as canceling
  2546.             hr = S_FALSE;
  2547.             goto Cleanup;
  2548.         }
  2549.         hr = S_OK;
  2550.     }
  2552.     // Write changed values to event object
  2553.     VARIANT var;
  2554.     V_VT(&var) = VT_BOOL;
  2555.     V_BOOL(&var) = printcbi.fPrintLinked ? VARIANT_TRUE : VARIANT_FALSE;
  2556.     PutParamToEvent(aDispid[PrintfPrintLinked], &var, pEventObj);
  2558.     V_BOOL(&var) = printcbi.fPrintActiveFrame ? VARIANT_TRUE : VARIANT_FALSE;
  2559.     PutParamToEvent(aDispid[PrintfPrintActiveFrame], &var, pEventObj);
  2561.     V_BOOL(&var) = printcbi.fPrintAsShown ? VARIANT_TRUE : VARIANT_FALSE;
  2562.     PutParamToEvent(aDispid[PrintfPrintAsShown], &var, pEventObj);
  2564.     V_BOOL(&var) = printcbi.fShortcutTable ? VARIANT_TRUE : VARIANT_FALSE;
  2565.     PutParamToEvent(aDispid[PrintfShortcutTable], &var, pEventObj);
  2567. #ifdef FONTSIZE_BOX
  2568.     V_VT(&var) = VT_INT;
  2569.     V_INT(&var) = printcbi.iFontScaling;
  2570.     PutParamToEvent(aDispid[PrintiFontScaling], &var, pEventObj);
  2571. #endif // FONTSIZE_BOX
  2573. #ifdef UNIX
  2574.     V_VT(&var) = VT_INT;
  2575.     V_INT(&var) = printcbi.dmOrientation;
  2576.     PutParamToEvent(aDispid[PrintdmOrientation], &var, pEventObj);
  2577. #endif // UNIX
  2579.     // now pop up the fileselection dialog and save the filename...
  2580.     // this is the only place where we can make this modal
  2581.     BOOL fPrintToFileOk;
  2582.     fPrintToFileOk = FALSE;
  2583.     if ((pprintdlg->Flags & PD_PRINTTOFILE) != 0)
  2584.     {
  2585.         // Get the save file path from the event object
  2586.         TCHAR achPrintToFileName[MAX_PATH];
  2588.         StrCpyN(achPrintToFileName,
  2589.             V_BSTR(&aVariant[PrintToFileName]) ? V_BSTR(&aVariant[PrintToFileName]) : TEXT(""),
  2590.             ARRAYSIZE(achPrintToFileName));
  2592.         if (!GetPrintFileName(pprintdlg->hwndOwner, achPrintToFileName) &&
  2593.                 achPrintToFileName)
  2594.         {
  2595.             fPrintToFileOk = TRUE;
  2596.             V_VT(&var) = VT_BSTR;
  2597.             V_BSTR(&var) = SysAllocString(achPrintToFileName);
  2598.             if (NULL != V_BSTR(&var))
  2599.             {
  2600.                 PutParamToEvent(aDispid[PrintToFileName], &var, pEventObj);
  2601.                 VariantClear(&var);
  2602.             }
  2603.         }
  2604.     }
  2606.     V_VT(&var) = VT_BOOL;
  2607.     V_BOOL(&var) = fPrintToFileOk ? VARIANT_TRUE : VARIANT_FALSE;
  2608.     PutParamToEvent(aDispid[PrintToFileOk], &var, pEventObj);
  2610. Cleanup:
  2611.     MLFreeLibrary(pprintdlg->hInstance);
  2613.     for (i=0; i<cExpandos; i++)
  2614.         VariantClear(&aVariant[i]);
  2616.     if (pvarargOut)
  2617.         VariantInit(pvarargOut);
  2619.     ATOMICRELEASE(pEventObj);
  2620.     ATOMICRELEASE(printcbi.pBodyActive);
  2622.     return hr;
  2623. }
  2626. //+---------------------------------------------------------------------------
  2627. //
  2628. //   Callback procedure for PrintToFile Dialog
  2629. //
  2630. //+---------------------------------------------------------------------------
  2631. UINT_PTR APIENTRY PrintToFileHookProc(HWND hdlg,
  2632.                               UINT uiMsg,
  2633.                               WPARAM wParam,
  2634.                               LPARAM lParam)
  2635. {
  2636.     switch (uiMsg)
  2637.     {
  2638.         case WM_INITDIALOG:
  2639.         {
  2640.             int      cbLen;
  2641.             TCHAR    achOK[MAX_PATH];
  2643.             // change "save" to "ok"
  2644.             cbLen = MLLoadShellLangString(IDS_PRINTTOFILE_OK,achOK,MAX_PATH);
  2645.             if (cbLen < 1)
  2646.                 StrCpyN(achOK, TEXT("OK"), ARRAYSIZE(achOK));
  2648.     //        SetDlgItemText(hdlg, IDOK, _T("OK"));
  2649.             SetDlgItemText(hdlg, IDOK, achOK);
  2651.             // ...and, finally force us into foreground (needed for Win95, Bug : 13368)
  2652.             ::SetForegroundWindow(hdlg);
  2653.             break;
  2654.         }
  2655.     }
  2656.     return FALSE;
  2657. }
  2659. //+---------------------------------------------------------------------------
  2660. //
  2661. //  Member:     GetPrintFileName
  2662. //
  2663. //  Synopsis:   Opens up the customized save file dialog and gets
  2664. //              a filename for the printoutput
  2665. //  Returns:
  2666. //
  2667. //----------------------------------------------------------------------------
  2668. HRESULT GetPrintFileName(HWND hwnd, TCHAR achFilePath[])
  2669. {
  2670.     OPENFILENAME    openfilename;
  2671.     int             cbLen;
  2672.     TCHAR           achTitlePrintInto[MAX_PATH];
  2673.     TCHAR           achFilePrintInto[MAX_PATH];
  2674.     TCHAR           achFilter[MAX_PATH];
  2675.     TCHAR           achPath[MAX_PATH];
  2677.     HRESULT         hr = E_FAIL;
  2679.     memset(&openfilename,0,sizeof(openfilename));
  2680.     openfilename.lStructSize = sizeof(openfilename);
  2681.     openfilename.hwndOwner = hwnd;
  2683.     cbLen = MLLoadShellLangString(IDS_PRINTTOFILE_TITLE,achTitlePrintInto,MAX_PATH);
  2684.     ASSERT (cbLen && "could not load the resource");
  2686.     if (cbLen > 0)
  2687.         openfilename.lpstrTitle = achTitlePrintInto;
  2689.     // guarantee trailing 0 to terminate the filter string
  2690.     memset(achFilter, 0, sizeof(TCHAR)*MAX_PATH);
  2691.     cbLen = MLLoadShellLangString(IDS_PRINTTOFILE_SPEC,achFilter,MAX_PATH-2);
  2692.     ASSERT (cbLen && "could not load the resource");
  2694.     if (cbLen>0)
  2695.     {
  2696.         for (; cbLen >= 0; cbLen--)
  2697.         {
  2698.             if (achFilter[cbLen]== L',')
  2699.             {
  2700.                 achFilter[cbLen] = 0;
  2701.             }
  2702.         }
  2703.     }
  2705.     openfilename.nMaxFileTitle = lstrlen(openfilename.lpstrTitle);
  2706.     StrCpyN(achFilePrintInto, TEXT(""), ARRAYSIZE(achFilePrintInto));
  2707.     openfilename.lpstrFile = achFilePrintInto;
  2708.     openfilename.nMaxFile = MAX_PATH;
  2709.     openfilename.Flags = OFN_NOREADONLYRETURN | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT |
  2710.                         OFN_ENABLEHOOK | OFN_NOCHANGEDIR;
  2711.     openfilename.lpfnHook = PrintToFileHookProc;
  2712.     openfilename.lpstrFilter = achFilter;
  2713.     openfilename.nFilterIndex = 1;
  2715.     StrCpyN(achPath, achFilePath, ARRAYSIZE(achPath));
  2716.     openfilename.lpstrInitialDir = *achPath ? achPath : NULL;
  2718.     if (GetSaveFileName(&openfilename))
  2719.     {
  2720.         StrCpyN(achFilePath, openfilename.lpstrFile, MAX_PATH);
  2721.         hr = S_OK;
  2722.     }
  2724.     if (hr)
  2725.         *achFilePath = NULL;
  2727.     return hr;
  2728. }
  2730. //+---------------------------------------------------------------------------
  2731. //
  2732. //  Helpers for OLECMDID_PROPERTIES
  2733. //
  2734. //+---------------------------------------------------------------------------
  2736. HRESULT
  2737. CDocHostUIHandler::ShowPropertysheetDialog(VARIANTARG *pvarargIn, VARIANTARG *pvarargOut, DWORD)
  2738. {
  2740. // must match order of PropertysheetEnum
  2741. static const SExpandoInfo s_aPropertysheetExpandos[] =
  2742. {
  2743.     {OLESTR("propertysheetPunks"),  VT_SAFEARRAY}
  2744. };
  2746.     HRESULT             hr;
  2747.     HWND                hwnd = NULL;
  2748.     HWND                hwndParent;
  2749.     IUnknown          * punk = NULL;
  2750.     OLECMD              olecmd = {0, 0};
  2751.     int                 cUnk = 0;
  2752.     IUnknown * HUGEP  * apUnk = NULL;
  2753.     OCPFIPARAMS         ocpfiparams;
  2754.     CAUUID              ca = { 0, 0 };
  2755.     RECT                rc = {0, 0, 0, 0};
  2756.     RECT                rcDesktop = {0, 0, 0, 0};
  2757.     SIZE                pixelOffset;
  2758.     SIZE                metricOffset = {0, 0};
  2760.     IHTMLEventObj     * pEventObj = NULL;
  2761.     const int           cExpandos = ARRAYSIZE(s_aPropertysheetExpandos);
  2762.     VARIANT             aVariant[cExpandos];
  2763.     DISPID              aDispid[cExpandos];
  2764.     SAFEARRAY         * psafearray = NULL;
  2766.     ASSERT(pvarargIn && V_VT(pvarargIn) == VT_UNKNOWN && V_UNKNOWN(pvarargIn));
  2767.     if (!pvarargIn || (V_VT(pvarargIn) != VT_UNKNOWN) || !V_UNKNOWN(pvarargIn))
  2768.     {
  2769.         hr = E_INVALIDARG;
  2770.         goto Cleanup;
  2771.     }
  2773.     // get the hwnd
  2774.     punk = V_UNKNOWN(pvarargIn);
  2775.     hr = GetHwndFromUnknown(punk, &hwnd);
  2776.     if (hr)
  2777.         goto Cleanup;
  2779.     // get the SafeArray expando from the event obj
  2780.     hr = GetEventFromUnknown(punk, &pEventObj);
  2781.     if (hr)
  2782.         goto Cleanup;
  2784.     hr = GetParamsFromEvent(
  2785.             pEventObj,
  2786.             cExpandos,
  2787.             aDispid,
  2788.             aVariant,
  2789.             s_aPropertysheetExpandos);
  2790.     if (hr)
  2791.         goto Cleanup;
  2792.     psafearray = V_ARRAY(&aVariant[PropertysheetPunks]);
  2794.     // verify array dimensions
  2795.     if (SafeArrayGetDim(psafearray) != 1)
  2796.     {
  2797.         hr = E_INVALIDARG;
  2798.         goto Cleanup;
  2799.     }
  2801.     // get array size, adding one to 0-based size
  2802.     hr = SafeArrayGetUBound(psafearray, 1, (long*)&cUnk);
  2803.     if (hr)
  2804.         goto Cleanup;
  2805.     cUnk++;
  2807.     if (cUnk)
  2808.     {
  2809.         // get pointer to vector
  2810.         hr = SafeArrayAccessData(psafearray, (void HUGEP* FAR*)&apUnk);
  2811.         if (hr)
  2812.             goto Cleanup;
  2813.     }
  2814.     else
  2815.     {
  2816.         cUnk = 1;
  2817.         apUnk = &punk;
  2818.     }
  2820.     // Compute pages to load
  2821.     hr = THR(GetCommonPages(cUnk, apUnk, &ca));
  2822.     if (hr)
  2823.         goto Cleanup;
  2825.     //  compute top-level parent
  2826.     while ( hwndParent = GetParent(hwnd) )
  2827.         hwnd = hwndParent;
  2829.     // BUGBUG dialog box is not centered on screen
  2830.     // the ocpfi seems to be ignoring the x, y values in ocpfiparams
  2831.     // Compute offset to center of screen
  2832.     GetWindowRect(GetDesktopWindow(), &rcDesktop);
  2833.     GetWindowRect(hwnd, &rc);
  2834.     pixelOffset.cx = (rcDesktop.right - rcDesktop.left)/2 - rc.left;
  2835.     pixelOffset.cy = (rcDesktop.bottom - rcDesktop.top)/2 - rc.top;
  2836.     AtlPixelToHiMetric(&pixelOffset, &metricOffset);
  2838.     memset(&ocpfiparams, 0, sizeof(ocpfiparams));
  2840.     ocpfiparams.cbStructSize = sizeof(ocpfiparams);
  2841.     ocpfiparams.hWndOwner = hwnd;
  2842.     ocpfiparams.x = metricOffset.cx;
  2843.     ocpfiparams.y = metricOffset.cy;
  2844.     ocpfiparams.lpszCaption = NULL;
  2845.     ocpfiparams.cObjects = cUnk;
  2846.     ocpfiparams.lplpUnk = apUnk;
  2847.     ocpfiparams.cPages = ca.cElems;
  2848.     ocpfiparams.lpPages = ca.pElems;
  2849.     ocpfiparams.lcid = GetUserDefaultLCID();
  2850.     ocpfiparams.dispidInitialProperty = DISPID_UNKNOWN;
  2852.     // OleCreatePropertyFrameIndirect throws its own dialog on error,
  2853.     // so we don't want to display that twice
  2854.     THR(OleCreatePropertyFrameIndirect(&ocpfiparams));
  2855.     hr = S_OK;
  2857. Cleanup:
  2858.     if (ca.cElems)
  2859.         CoTaskMemFree(ca.pElems);
  2861.     if (psafearray && apUnk)
  2862.         SafeArrayUnaccessData(psafearray);
  2864.     if (pvarargOut)
  2865.         VariantInit(pvarargOut);
  2867.     for (int i=0; i<cExpandos; i++)
  2868.         VariantClear(&aVariant[i]);
  2870.     ATOMICRELEASE(pEventObj);
  2872.     return hr;
  2873. }
  2875. HRESULT
  2876. CDocHostUIHandler::GetCommonPages(int cUnk, IUnknown **apUnk, CAUUID *pca)
  2877. {
  2878.     HRESULT                hr;
  2879.     int                    i;
  2880.     UINT                   iScan, iFill, iCompare;
  2881.     BOOL                   fFirst = TRUE;
  2882.     CAUUID                 caCurrent;
  2883.     IUnknown *             pUnk;
  2884.     ISpecifyPropertyPages *pSPP;
  2886.     pca->cElems = 0;
  2887.     pca->pElems = NULL;
  2889.     for (i = 0; i < cUnk; i++)
  2890.     {
  2891.         pUnk = apUnk[i];
  2892.         ASSERT(pUnk);
  2894.         hr = THR(pUnk->QueryInterface(
  2895.                 IID_ISpecifyPropertyPages,
  2896.                 (void **)&pSPP));
  2897.         if (hr)
  2898.             goto Cleanup;
  2900.          hr = THR(pSPP->GetPages(fFirst ? pca : &caCurrent));
  2901.          ATOMICRELEASE(pSPP);
  2902.          if (hr)
  2903.              goto Cleanup;
  2905.          if (fFirst)
  2906.              continue;
  2908.          // keep only the common pages
  2909.          else
  2910.          {
  2911.              for (iScan = 0, iFill = 0; iScan < pca->cElems; iScan++)
  2912.              {
  2913.                  for (iCompare = 0; iCompare < caCurrent.cElems; iCompare++)
  2914.                  {
  2915.                      if (caCurrent.pElems[iCompare] == pca->pElems[iScan])
  2916.                          break;
  2917.                  }
  2918.                  if (iCompare != caCurrent.cElems)
  2919.                  {
  2920.                      pca->pElems[iFill++] = pca->pElems[iScan];
  2922.                  }
  2923.              }
  2924.              pca->cElems = iFill;
  2925.              CoTaskMemFree(caCurrent.pElems);
  2926.          }
  2927.     }
  2930. Cleanup:
  2931.     return hr;
  2932. }
  2934. //+---------------------------------------------------------------------------
  2935. //
  2936. //  Helper for SHDVID_CLSIDTOMONIKER
  2937. //
  2938. //+---------------------------------------------------------------------------
  2940. struct HTMLPAGECACHE
  2941. {
  2942.     const CLSID *   pclsid;
  2943.     TCHAR *         ach;
  2944. };
  2946. HRESULT CDocHostUIHandler::ClsidToMoniker(VARIANTARG *pvarargIn, VARIANTARG *pvarargOut)
  2947. {
  2948.     static const HTMLPAGECACHE s_ahtmlpagecache[] =
  2949.     {
  2950.         &CLSID_CAnchorBrowsePropertyPage,           _T("anchrppg.ppg"),
  2951.         &CLSID_CImageBrowsePropertyPage,            _T("imageppg.ppg"),
  2952.         &CLSID_CDocBrowsePropertyPage,              _T("docppg.ppg"),
  2953.     };
  2955.     HRESULT                 hr = E_FAIL;
  2956.     IMoniker              * pmk = NULL;
  2957.     IUnknown              * pUnk = NULL;
  2958.     int                     i;
  2959.     const HTMLPAGECACHE   * phtmlentry;
  2960.     const CLSID           * pclsid;
  2962.     ASSERT(pvarargIn);
  2963.     ASSERT(pvarargOut);
  2964.     ASSERT(V_VT(pvarargIn) == VT_UINT_PTR && V_BYREF(pvarargIn));
  2966.     if (!pvarargIn || V_VT(pvarargIn) != VT_UINT_PTR || !V_BYREF(pvarargIn))
  2967.         goto Cleanup;
  2968.     pclsid = (CLSID *)V_BYREF(pvarargIn);
  2970.     if (!pvarargOut)
  2971.         goto Cleanup;
  2972.     VariantInit(pvarargOut);
  2974.     // lookup the resource from the CLSID
  2975.     for (i = ARRAYSIZE(s_ahtmlpagecache) - 1, phtmlentry = s_ahtmlpagecache;
  2976.         i >= 0;
  2977.         i--, phtmlentry++)
  2978.     {
  2979.         ASSERT(phtmlentry->pclsid && phtmlentry->ach);
  2980.         if (IsEqualCLSID(*pclsid, *phtmlentry->pclsid))
  2981.         {
  2982.             // create a moniker for the dialog resource
  2983.             TCHAR szResURL[MAX_URL_STRING];
  2984. #ifndef UNIX
  2985.             // IEUNIX: BUGBUG , should call Wrap version here ???
  2986.             hr = MLBuildResURL(TEXT("shdoclc.dll"),
  2987.                        HINST_THISDLL,
  2988.                        ML_CROSSCODEPAGE,
  2989.                        phtmlentry->ach,
  2990.                        szResURL,
  2991.                        ARRAYSIZE(szResURL));
  2992. #else
  2993.             hr = MLBuildResURLWrap(TEXT("shdoclc.dll"),
  2994.                        HINST_THISDLL,
  2995.                        ML_CROSSCODEPAGE,
  2996.                        phtmlentry->ach,
  2997.                        szResURL,
  2998.                        ARRAYSIZE(szResURL),
  2999.                        TEXT("shdocvw.dll"));
  3000. #endif
  3001.             if (hr)
  3002.                 goto Cleanup;
  3004.             hr = CreateURLMoniker(NULL, szResURL, &pmk);
  3005.             if (hr)
  3006.                 goto Cleanup;
  3008.             break;
  3009.         }
  3010.     }
  3012.     if (!pmk)
  3013.         goto Cleanup;
  3015.     // return the moniker
  3016.     hr = pmk->QueryInterface(IID_IUnknown, (void**)&pUnk);
  3017.     if (hr)
  3018.         goto Cleanup;
  3019.     else
  3020.     {
  3021.         V_VT(pvarargOut) = VT_UNKNOWN;
  3022.         V_UNKNOWN(pvarargOut) = pUnk;
  3023.         V_UNKNOWN(pvarargOut)->AddRef();
  3024.     }
  3026. Cleanup:
  3027.     ATOMICRELEASE(pUnk);
  3028.     ATOMICRELEASE(pmk);
  3030.     return hr;
  3031. }
  3033. STDMETHODIMP CDocHostUIHandler::Invoke(
  3034.     DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, 
  3035.     VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
  3036. {
  3037.     HRESULT hr = S_OK;
  3039.     if (pDispParams && pDispParams->cArgs>=1)
  3040.     {
  3041.         if (pDispParams->rgvarg[0].vt == VT_DISPATCH)
  3042.         {
  3043.             IHTMLEventObj *pObj=NULL;
  3045.             if (SUCCEEDED(pDispParams->rgvarg[0].pdispVal->QueryInterface(IID_IHTMLEventObj, (void **)&pObj) && pObj))
  3046.             {
  3047.                 BSTR bstrEvent=NULL;
  3049.                 pObj->get_type(&bstrEvent);
  3051.                 if (bstrEvent)
  3052.                 {
  3053.                     ASSERT(!StrCmpCW(bstrEvent, L"unload"));
  3055.                     IServiceProvider* psp;
  3056.                     
  3057.                     hr = IUnknown_QueryService(_punkSite, SID_STopLevelBrowser, IID_IServiceProvider, (LPVOID*)&psp);
  3058.                     if (SUCCEEDED(hr))
  3059.                     {
  3060.                         IWebBrowser2* pwb2;
  3061.                     
  3062.                         hr = psp->QueryService(SID_SWebBrowserApp, IID_IWebBrowser2, (LPVOID*)&pwb2);
  3063.                         if (SUCCEEDED(hr))
  3064.                         {
  3065.                             IHTMLWindow2* pWindow;
  3067.                             // we shouldn't be catching this event if the dialog is not up
  3068.                             if (EVAL(IsFindDialogUp(pwb2, &pWindow)))
  3069.                             {
  3070.                                 if (NULL != _pOptionsHolder)
  3071.                                 {
  3072.                                     BSTR bstrFindText;
  3073.                                     
  3074.                                     _pOptionsHolder->get_findText(&bstrFindText);
  3075.                                     ATOMICRELEASE(_pOptionsHolder);
  3077.                                     PutFindText(pwb2, bstrFindText);
  3078.                                     SysFreeString(bstrFindText);
  3079.                                 }
  3080.                                 
  3081.                                 ASSERT(pWindow);
  3082.                                 
  3083.                                 BSTR bstrOnunload = SysAllocString(L"onunload");
  3084.                                 if (bstrOnunload)
  3085.                                 {
  3086.                                     IHTMLWindow3 * pWin3;
  3088.                                     if (SUCCEEDED(pWindow->QueryInterface(IID_IHTMLWindow3, (void**)&pWin3)))
  3089.                                     {
  3090.                                         pWin3->detachEvent(bstrOnunload, (IDispatch*)this);
  3091.                                         pWin3->Release();
  3092.                                     }
  3093.                                     SysFreeString(bstrOnunload);
  3094.                                 }
  3095.                                  //this is the one that should release the dialog (the pWinOut from ShowFindDialog())
  3096.                                 pWindow->Release();
  3098.                                 BSTR bstrName = SysAllocString(STR_FIND_DIALOG_NAME);
  3099.                                 if (bstrName)
  3100.                                 {
  3101.                                     VARIANT var;
  3102.                                     VariantInit(&var);
  3103.                                     var.vt = VT_DISPATCH;
  3104.                                     var.pdispVal = NULL;
  3106.                                     pwb2->PutProperty(bstrName, var);
  3107.                                     SysFreeString(bstrName);
  3108.                                 }
  3109.                             }
  3110.                             pwb2->Release();
  3111.                         }
  3112.                         psp->Release();
  3113.                     }
  3114.                     SysFreeString(bstrEvent);
  3115.                 }
  3116.                 pObj->Release();
  3117.             }
  3118.         }
  3119.     }
  3121.     return hr;
  3122. }