home *** CD-ROM | disk | FTP | other *** search
/ Team Palmtops 7 / Palmtops_numero07.iso / WinCE / SDKWindowsCE / HandHeldPCPro30 / sdk.exe / Jupiter SDK / data1.cab / ATL / include / Atlhost.h < prev    next >
Encoding:
C/C++ Source or Header  |  1999-02-19  |  79.3 KB  |  2,795 lines
  1. // This is a part of the Active Template Library.
  2. // Copyright (C) 1996-1998 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Active Template Library Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Active Template Library product.
  10.  
  11.  
  12. #ifndef __ATLHOST_H__
  13. #define __ATLHOST_H__
  14.  
  15. #if !defined(_WIN32_WCE)
  16. #include <urlmon.h>
  17. #include <mshtml.h>
  18. #include <mshtmhst.h>
  19. #include <exdisp.h>
  20. #endif // _WIN32_WCE
  21.  
  22. #ifndef _ATL_AXHOST
  23. #define _ATL_AXHOST
  24. #endif //_ATL_AXHOST
  25.  
  26. #include <atlwin.h>
  27.  
  28. #ifndef __cplusplus
  29.     #error ATL requires C++ compilation (use a .cpp suffix)
  30. #endif
  31.  
  32. #ifndef __ATLCOM_H__
  33.     #error atlhost.h requires atlcom.h to be included first
  34. #endif
  35.  
  36. #ifdef _ATL_NO_HOSTING
  37.     #error atlhost.h requires Hosting support (_ATL_NO_HOSTING is defined)
  38. #endif //_ATL_NO_HOSTING
  39.  
  40. namespace ATL
  41. {
  42. //AtlAxWinTerm is not exported
  43. inline BOOL AtlAxWinTerm()
  44. {
  45. #ifndef _ATL_DLL //don't unregister DLL's version
  46.     UnregisterClass(CAxWindow::GetWndClassName(), _Module.GetModuleInstance());
  47. #endif
  48.     return TRUE;
  49. }
  50.  
  51.  
  52. // Define this to host SHDOCVW rather than MSHTML
  53. #define SHDOCVW
  54.  
  55. UINT __declspec(selectany) WM_ATLGETHOST = 0;
  56. UINT __declspec(selectany) WM_ATLGETCONTROL = 0;
  57.  
  58. //EXTERN_C const IID IID_IHTMLDocument2 = {0x332C4425,0x26CB,0x11D0,{0xB4,0x83,0x00,0xC0,0x4F,0xD9,0x01,0x19}};
  59.  
  60. typedef HRESULT (__stdcall *typeMkParseDisplayName)(IBindCtx*, LPCWSTR , ULONG*, LPMONIKER*);
  61.  
  62. static HRESULT CreateNormalizedObject(LPCOLESTR lpszTricsData, REFIID riid, void** ppvObj, bool& bWasHTML)
  63. {
  64.     ATLASSERT(ppvObj);
  65.  
  66.     CLSID clsid;
  67.     HRESULT hr = E_FAIL;
  68.     BOOL bInited = FALSE;
  69.  
  70.     bWasHTML = false;
  71.  
  72.     *ppvObj = NULL;
  73.  
  74.     if (lpszTricsData == NULL || lpszTricsData[0] == 0)
  75.         return S_OK;
  76.  
  77. #if defined(_WIN32_WCE)
  78.     if (ocslen(lpszTricsData) < 255)
  79.     {
  80.         if (lpszTricsData[0] == '{') // Is it a CLSID?
  81.             hr = CLSIDFromString((LPOLESTR)lpszTricsData, &clsid);
  82.         else
  83.             hr = WCE_FCTN(CLSIDFromProgID)((LPOLESTR)lpszTricsData, &clsid); // How about a ProgID?
  84.         if (SUCCEEDED(hr))    // Aha, it was one of those two
  85.             hr = CoCreateInstance(clsid, NULL, CLSCTX_SERVER, riid, ppvObj);
  86.     }
  87. #else // _WIN32_WCE
  88.     // Is it HTML ?
  89.     USES_CONVERSION;
  90.     if ((lpszTricsData[0] == OLECHAR('M') || lpszTricsData[0] == OLECHAR('m')) &&
  91.         (lpszTricsData[1] == OLECHAR('S') || lpszTricsData[1] == OLECHAR('s')) &&
  92.         (lpszTricsData[2] == OLECHAR('H') || lpszTricsData[2] == OLECHAR('h')) &&
  93.         (lpszTricsData[3] == OLECHAR('T') || lpszTricsData[3] == OLECHAR('t')) &&
  94.         (lpszTricsData[4] == OLECHAR('M') || lpszTricsData[4] == OLECHAR('m')) &&
  95.         (lpszTricsData[5] == OLECHAR('L') || lpszTricsData[5] == OLECHAR('l')) &&
  96.         (lpszTricsData[6] == OLECHAR(':')))
  97.     {
  98.         // It's HTML, so let's create mshtml
  99.         hr = CoCreateInstance(CLSID_HTMLDocument, NULL, CLSCTX_SERVER, riid, ppvObj);
  100.         bWasHTML = true;
  101.     }
  102.     if (FAILED(hr))
  103.     {
  104.         // Can't be clsid, or progid if length is grater than 255
  105.         if (ocslen(lpszTricsData) < 255)
  106.         {
  107.             if (lpszTricsData[0] == '{') // Is it a CLSID?
  108.                 hr = CLSIDFromString((LPOLESTR)lpszTricsData, &clsid);
  109.             else
  110.                 hr = CLSIDFromProgID((LPOLESTR)lpszTricsData, &clsid); // How about a ProgID?
  111.             if (SUCCEEDED(hr))    // Aha, it was one of those two
  112.                 hr = CoCreateInstance(clsid, NULL, CLSCTX_SERVER, riid, ppvObj);
  113.         }
  114.         if (FAILED(hr))
  115.         {
  116.             // Last guess - it must be either a URL so let's create shdocvw
  117.             hr = CoCreateInstance(CLSID_WebBrowser, NULL, CLSCTX_SERVER, riid, ppvObj);
  118.             bWasHTML = true;
  119.         }
  120.     }
  121. #endif // _WIN32_WCE
  122.  
  123.     if (SUCCEEDED(hr) && bInited)
  124.         hr = S_FALSE;
  125.  
  126.     return hr;
  127. }
  128.  
  129.  
  130. class ATL_NO_VTABLE CAxFrameWindow : 
  131.     public CComObjectRootEx<CComObjectThreadModel>,
  132.     public CWindowImpl<CAxFrameWindow>,
  133.     public IOleInPlaceFrame
  134. {
  135. public:
  136.     CAxFrameWindow()
  137.     {
  138.     }
  139.     void FinalRelease()
  140.     {
  141.         m_spActiveObject.Release();
  142.         if (m_hWnd)
  143.             DestroyWindow();
  144.     }
  145.  
  146.     DECLARE_POLY_AGGREGATABLE(CAxFrameWindow)
  147.  
  148.     BEGIN_COM_MAP(CAxFrameWindow)
  149.         COM_INTERFACE_ENTRY(IOleInPlaceFrame)
  150.         COM_INTERFACE_ENTRY(IOleInPlaceUIWindow)
  151.         COM_INTERFACE_ENTRY(IOleWindow)
  152.     END_COM_MAP()
  153.  
  154.     DECLARE_EMPTY_MSG_MAP()
  155.  
  156. // IOleWindow
  157.     STDMETHOD(GetWindow)(HWND* phwnd)
  158.     {
  159.         if (m_hWnd == NULL)
  160.         {
  161.             RECT rcPos = { CW_USEDEFAULT, 0, 0, 0 };
  162.             Create(NULL, rcPos, _T("AXWIN Frame Window"), WS_OVERLAPPEDWINDOW, 0, (UINT)NULL);
  163.         }
  164.         *phwnd = m_hWnd;
  165.         return S_OK;
  166.     }
  167.     STDMETHOD(ContextSensitiveHelp)(BOOL /*fEnterMode*/)
  168.     {
  169.         return S_OK;
  170.     }
  171.  
  172. // IOleInPlaceUIWindow
  173.     STDMETHOD(GetBorder)(LPRECT /*lprectBorder*/)
  174.     {
  175.         return S_OK;
  176.     }
  177.  
  178.     STDMETHOD(RequestBorderSpace)(LPCBORDERWIDTHS /*pborderwidths*/)
  179.     {
  180.         return INPLACE_E_NOTOOLSPACE;
  181.     }
  182.  
  183.     STDMETHOD(SetBorderSpace)(LPCBORDERWIDTHS /*pborderwidths*/)
  184.     {
  185.         return S_OK;
  186.     }
  187.  
  188.     STDMETHOD(SetActiveObject)(IOleInPlaceActiveObject* pActiveObject, LPCOLESTR /*pszObjName*/)
  189.     {
  190.         m_spActiveObject = pActiveObject;
  191.         return S_OK;
  192.     }
  193.  
  194. // IOleInPlaceFrameWindow
  195.     STDMETHOD(InsertMenus)(HMENU /*hmenuShared*/, LPOLEMENUGROUPWIDTHS /*lpMenuWidths*/)
  196.     {
  197.         return S_OK;
  198.     }
  199.  
  200.     STDMETHOD(SetMenu)(HMENU /*hmenuShared*/, HOLEMENU /*holemenu*/, HWND /*hwndActiveObject*/)
  201.     {
  202.         return S_OK;
  203.     }
  204.  
  205.     STDMETHOD(RemoveMenus)(HMENU /*hmenuShared*/)
  206.     {
  207.         return S_OK;
  208.     }
  209.  
  210.     STDMETHOD(SetStatusText)(LPCOLESTR /*pszStatusText*/)
  211.     {
  212.         return S_OK;
  213.     }
  214.  
  215.     STDMETHOD(EnableModeless)(BOOL /*fEnable*/)
  216.     {
  217.         return S_OK;
  218.     }
  219.  
  220.     STDMETHOD(TranslateAccelerator)(LPMSG /*lpMsg*/, WORD /*wID*/)
  221.     {
  222.         return S_FALSE;
  223.     }
  224.  
  225.     CComPtr<IOleInPlaceActiveObject> m_spActiveObject;
  226. };
  227.  
  228.  
  229. class ATL_NO_VTABLE CAxUIWindow : 
  230.     public CComObjectRootEx<CComObjectThreadModel>,
  231.     public CWindowImpl<CAxUIWindow>,
  232.     public IOleInPlaceUIWindow
  233. {
  234. public:
  235.     CAxUIWindow()
  236.     {
  237.     }
  238.  
  239.     void FinalRelease()
  240.     {
  241.         m_spActiveObject.Release();
  242.         if (m_hWnd)
  243.             DestroyWindow();
  244.     }
  245.  
  246.     DECLARE_POLY_AGGREGATABLE(CAxUIWindow)
  247.  
  248.     BEGIN_COM_MAP(CAxUIWindow)
  249.         COM_INTERFACE_ENTRY(IOleInPlaceUIWindow)
  250.         COM_INTERFACE_ENTRY(IOleWindow)
  251.     END_COM_MAP()
  252.  
  253.     DECLARE_EMPTY_MSG_MAP()
  254.  
  255. // IOleWindow
  256.     STDMETHOD(GetWindow)(HWND* phwnd)
  257.     {
  258.         if (m_hWnd == NULL)
  259.         {
  260.             RECT rcPos = { CW_USEDEFAULT, CW_USEDEFAULT, 0, 0 };
  261.             Create(NULL, rcPos, _T("AXWIN UI Window"), WS_OVERLAPPEDWINDOW, 0, (UINT)NULL);
  262.         }
  263.         *phwnd = m_hWnd;
  264.         return S_OK;
  265.     }
  266.  
  267.     STDMETHOD(ContextSensitiveHelp)(BOOL /*fEnterMode*/)
  268.     {
  269.         return S_OK;
  270.     }
  271.  
  272. // IOleInPlaceUIWindow
  273.     STDMETHOD(GetBorder)(LPRECT /*lprectBorder*/)
  274.     {
  275.         return S_OK;
  276.     }
  277.  
  278.     STDMETHOD(RequestBorderSpace)(LPCBORDERWIDTHS /*pborderwidths*/)
  279.     {
  280.         return INPLACE_E_NOTOOLSPACE;
  281.     }
  282.  
  283.     STDMETHOD(SetBorderSpace)(LPCBORDERWIDTHS /*pborderwidths*/)
  284.     {
  285.         return S_OK;
  286.     }
  287.  
  288.     STDMETHOD(SetActiveObject)(IOleInPlaceActiveObject* pActiveObject, LPCOLESTR /*pszObjName*/)
  289.     {
  290.         m_spActiveObject = pActiveObject;
  291.         return S_OK;
  292.     }
  293.  
  294.     CComPtr<IOleInPlaceActiveObject> m_spActiveObject;
  295. };
  296.  
  297.  
  298. /////////////////////////////////////////////////////////////////////////////
  299. // CAxHostWindow
  300. // This class is not cocreateable
  301.  
  302. class ATL_NO_VTABLE CAxHostWindow : 
  303.         public CComCoClass<CAxHostWindow , &CLSID_NULL>,
  304.         public CComObjectRootEx<CComSingleThreadModel>,
  305.         public CWindowImpl<CAxHostWindow>,
  306.         public IAxWinHostWindow,
  307.         public IOleClientSite,
  308.         public IOleInPlaceSiteWindowless,
  309.         public IOleControlSite,
  310.         public IOleContainer,
  311.         public IObjectWithSiteImpl<CAxHostWindow>,
  312. WCE_DEL    public IServiceProvider,
  313.         public IAdviseSink,
  314. #ifndef _ATL_NO_DOCHOSTUIHANDLER
  315. WCE_DEL    public IDocHostUIHandler,
  316. #endif
  317.         public IDispatchImpl<IAxWinAmbientDispatch, &IID_IAxWinAmbientDispatch, &LIBID_ATLLib>
  318. {
  319. public:
  320. // ctor/dtor
  321.     CAxHostWindow()
  322.     {
  323.         m_bInPlaceActive = FALSE;
  324.         m_bUIActive = FALSE;
  325.         m_bMDIApp = FALSE;
  326.         m_bWindowless = FALSE;
  327.         m_bCapture = FALSE;
  328.         m_bHaveFocus = FALSE;
  329.  
  330.         // Initialize ambient properties
  331.         m_bCanWindowlessActivate = TRUE;
  332.         m_bUserMode = TRUE;
  333.         m_bDisplayAsDefault = FALSE;
  334.         m_clrBackground = GetSysColor(COLOR_BACKGROUND);
  335.         m_clrForeground = GetSysColor(COLOR_WINDOWTEXT);
  336.         m_lcidLocaleID = LOCALE_USER_DEFAULT;
  337.         m_bMessageReflect = true;
  338.  
  339.         m_bReleaseAll = FALSE;
  340.  
  341.         m_bSubclassed = FALSE;
  342.  
  343.         m_dwAdviseSink = 0xCDCDCDCD;
  344.         WCE_DEL m_dwDocHostFlags = DOCHOSTUIFLAG_NO3DBORDER;
  345.         WCE_DEL m_dwDocHostDoubleClickFlags = DOCHOSTUIDBLCLK_DEFAULT;
  346.         m_bAllowContextMenu = true;
  347.         m_bAllowShowUI = false;
  348.     }
  349.  
  350.     ~CAxHostWindow()
  351.     {
  352.     }
  353.     void FinalRelease()
  354.     {
  355.         ReleaseAll();
  356.     }
  357.  
  358.     virtual void OnFinalMessage(HWND /*hWnd*/)
  359.     {
  360.         GetControllingUnknown()->Release();
  361.     }
  362.  
  363.     DECLARE_NO_REGISTRY()
  364.     DECLARE_POLY_AGGREGATABLE(CAxHostWindow)
  365.     DECLARE_GET_CONTROLLING_UNKNOWN()
  366.  
  367.     BEGIN_COM_MAP(CAxHostWindow)
  368.         COM_INTERFACE_ENTRY2(IDispatch, IAxWinAmbientDispatch)
  369.         COM_INTERFACE_ENTRY(IAxWinHostWindow)
  370.         COM_INTERFACE_ENTRY(IOleClientSite)
  371.         COM_INTERFACE_ENTRY(IOleInPlaceSiteWindowless)
  372.         COM_INTERFACE_ENTRY(IOleInPlaceSiteEx)
  373.         COM_INTERFACE_ENTRY(IOleInPlaceSite)
  374.         COM_INTERFACE_ENTRY(IOleWindow)
  375.         COM_INTERFACE_ENTRY(IOleControlSite)
  376.         COM_INTERFACE_ENTRY(IOleContainer)
  377.         COM_INTERFACE_ENTRY(IObjectWithSite)
  378.     WCE_DEL    COM_INTERFACE_ENTRY(IServiceProvider)
  379.         COM_INTERFACE_ENTRY(IAxWinAmbientDispatch)
  380. #ifndef _ATL_NO_DOCHOSTUIHANDLER
  381.     WCE_DEL    COM_INTERFACE_ENTRY(IDocHostUIHandler)
  382. #endif
  383.         COM_INTERFACE_ENTRY(IAdviseSink)
  384.     END_COM_MAP()
  385.  
  386.     static CWndClassInfo& GetWndClassInfo()
  387.     {
  388. #if defined(_WIN32_WCE)
  389.         static CWndClassInfo wc =
  390.         {
  391.             { CS_HREDRAW|CS_VREDRAW, StartWindowProc,
  392.               0, 0, 0, 0, 0, (HBRUSH)(COLOR_WINDOW+1), 0, _T("AtlAxWin")},
  393.               NULL, NULL, NULL, TRUE, 0, _T("")
  394.         };
  395. #else // _WIN32_WCE
  396.         static CWndClassInfo wc =
  397.         {
  398.             { sizeof(WNDCLASSEX), 0, StartWindowProc,
  399.               0, 0, 0, 0, 0, (HBRUSH)(COLOR_WINDOW + 1), 0, _T("AtlAxWin"), 0 },
  400.             NULL, NULL, IDC_ARROW, TRUE, 0, _T("")
  401.         };
  402. #endif // _WIN32_WCE
  403.         return wc;
  404.     }
  405.  
  406.     BEGIN_MSG_MAP(CAxHostWindow)
  407.         MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
  408.         MESSAGE_HANDLER(WM_PAINT, OnPaint)
  409.         MESSAGE_HANDLER(WM_SIZE, OnSize)
  410.         MESSAGE_HANDLER(WM_SETFOCUS, OnSetFocus)
  411.         MESSAGE_HANDLER(WM_KILLFOCUS, OnKillFocus)
  412.         if (m_bWindowless)
  413.         {
  414.             // Mouse messages handled when a windowless control has captured the cursor
  415.             // or if the cursor is over the control
  416.             DWORD dwHitResult = m_bCapture ? HITRESULT_HIT : HITRESULT_OUTSIDE;
  417.             if (dwHitResult == HITRESULT_OUTSIDE && m_spViewObject != NULL)
  418.             {
  419.                 POINT ptMouse = { LOWORD(lParam), HIWORD(lParam) };
  420.                 m_spViewObject->QueryHitPoint(DVASPECT_CONTENT, &m_rcPos, ptMouse, 0, &dwHitResult);
  421.             }
  422.             if (dwHitResult == HITRESULT_HIT)
  423.             {
  424.                 MESSAGE_HANDLER(WM_MOUSEMOVE, OnWindowlessMouseMessage)
  425.                 WCE_DEL    MESSAGE_HANDLER(WM_SETCURSOR, OnWindowlessMouseMessage)
  426.                 MESSAGE_HANDLER(WM_LBUTTONUP, OnWindowlessMouseMessage)
  427.                 WCE_DEL MESSAGE_HANDLER(WM_RBUTTONUP, OnWindowlessMouseMessage)
  428.                 WCE_DEL MESSAGE_HANDLER(WM_MBUTTONUP, OnWindowlessMouseMessage)
  429.                 MESSAGE_HANDLER(WM_LBUTTONDOWN, OnWindowlessMouseMessage)
  430.                 WCE_DEL MESSAGE_HANDLER(WM_RBUTTONDOWN, OnWindowlessMouseMessage)
  431.                 WCE_DEL MESSAGE_HANDLER(WM_MBUTTONDOWN, OnWindowlessMouseMessage)
  432.                 MESSAGE_HANDLER(WM_LBUTTONDBLCLK, OnWindowlessMouseMessage)
  433.                 WCE_DEL MESSAGE_HANDLER(WM_RBUTTONDBLCLK, OnWindowlessMouseMessage)
  434.                 WCE_DEL MESSAGE_HANDLER(WM_MBUTTONDBLCLK, OnWindowlessMouseMessage)
  435.             }
  436.         }
  437.         if (m_bWindowless & m_bHaveFocus)
  438.         {
  439.             // Keyboard messages handled only when a windowless control has the focus
  440.             MESSAGE_HANDLER(WM_KEYDOWN, OnWindowMessage)
  441.             MESSAGE_HANDLER(WM_KEYUP, OnWindowMessage)
  442.             MESSAGE_HANDLER(WM_CHAR, OnWindowMessage)
  443.             MESSAGE_HANDLER(WM_DEADCHAR, OnWindowMessage)
  444.             MESSAGE_HANDLER(WM_SYSKEYDOWN, OnWindowMessage)
  445.             MESSAGE_HANDLER(WM_SYSKEYUP, OnWindowMessage)
  446.             MESSAGE_HANDLER(WM_SYSDEADCHAR, OnWindowMessage)
  447.             MESSAGE_HANDLER(WM_HELP, OnWindowMessage)
  448.             MESSAGE_HANDLER(WM_CANCELMODE, OnWindowMessage)
  449.             WCE_DEL MESSAGE_HANDLER(WM_IME_CHAR, OnWindowMessage)
  450.             WCE_DEL MESSAGE_HANDLER(WM_MBUTTONDBLCLK, OnWindowMessage)
  451.             WCE_DEL MESSAGE_RANGE_HANDLER(WM_IME_SETCONTEXT, WM_IME_KEYUP, OnWindowMessage)
  452.         }
  453.         MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
  454.         if(!m_bWindowless && m_bMessageReflect)
  455.         {
  456.             bHandled = TRUE;
  457.             lResult = ReflectNotifications(uMsg, wParam, lParam, bHandled);
  458.             if(bHandled)
  459.                 return TRUE;
  460.         }
  461.         MESSAGE_HANDLER(WM_ATLGETHOST, OnGetUnknown)
  462.         MESSAGE_HANDLER(WM_ATLGETCONTROL, OnGetControl)
  463.         MESSAGE_HANDLER(WM_FORWARDMSG, OnForwardMsg)
  464.     END_MSG_MAP()
  465.  
  466.     LRESULT OnForwardMsg(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
  467.     {
  468.         ATLASSERT(lParam != 0);
  469.         LPMSG lpMsg = (LPMSG)lParam;
  470.         CComQIPtr<IOleInPlaceActiveObject, &IID_IOleInPlaceActiveObject> spInPlaceActiveObject(m_spUnknown);
  471.         if(spInPlaceActiveObject)
  472.         {
  473.             if(spInPlaceActiveObject->TranslateAccelerator(lpMsg) == S_OK)
  474.                 return 1;
  475.         }
  476.         return 0;
  477.     }
  478.  
  479.     LRESULT OnGetUnknown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
  480.     {
  481.         IUnknown* pUnk = GetControllingUnknown();
  482.         pUnk->AddRef();
  483.         return (LRESULT)pUnk;
  484.     }
  485.     LRESULT OnGetControl(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
  486.     {
  487.         IUnknown* pUnk = m_spUnknown;
  488.         if (pUnk)
  489.             pUnk->AddRef();
  490.         return (LRESULT)pUnk;
  491.     }
  492.  
  493.     void ReleaseAll()
  494.     {
  495.         if (m_bReleaseAll)
  496.             return;
  497.         m_bReleaseAll = TRUE;
  498.  
  499.         if (m_spViewObject != NULL)
  500.             m_spViewObject->SetAdvise(DVASPECT_CONTENT, 0, NULL);
  501.  
  502.         if(m_dwAdviseSink != 0xCDCDCDCD)
  503.         {
  504.             AtlUnadvise(m_spUnknown, m_iidSink, m_dwAdviseSink);
  505.             m_dwAdviseSink = 0xCDCDCDCD;
  506.         }
  507.  
  508.         if (m_spOleObject)
  509.         {
  510.             m_spOleObject->Unadvise(m_dwOleObject);
  511.             m_spOleObject->Close(OLECLOSE_NOSAVE);
  512.             m_spOleObject->SetClientSite(NULL);
  513.         }
  514.  
  515.         if (m_spUnknown != NULL)
  516.         {
  517.             CComPtr<IObjectWithSite> spSite;
  518.             m_spUnknown->QueryInterface(IID_IObjectWithSite, (void**)&spSite);
  519.             if (spSite != NULL)
  520.                 spSite->SetSite(NULL);
  521.         }
  522.  
  523.         m_spViewObject.Release();
  524.         m_dwViewObjectType = 0;
  525.  
  526.         m_spInPlaceObjectWindowless.Release();
  527.         m_spOleObject.Release();
  528.         m_spUnknown.Release();
  529.  
  530.         m_spInPlaceUIWindow.Release();
  531.         m_spInPlaceFrame.Release();
  532.  
  533.         m_bInPlaceActive = FALSE;
  534.         m_bWindowless = FALSE;
  535.         m_bInPlaceActive = FALSE;
  536.         m_bUIActive = FALSE;
  537.         m_bCapture = FALSE;
  538.         m_bReleaseAll = FALSE;
  539.     }
  540.  
  541.  
  542. // window message handlers
  543.     LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
  544.     {
  545.         if (m_spViewObject == NULL)
  546.             bHandled = false;
  547.         return 1;
  548.     }
  549.     LRESULT OnNCHitTest(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
  550.     {
  551.         return HTCLIENT;
  552.     }
  553.     LRESULT OnSetFocus(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
  554.     {
  555.         m_bHaveFocus = TRUE;
  556.         if (!m_bReleaseAll)
  557.         {
  558.             if (m_spOleObject != NULL && !m_bInPlaceActive)
  559.             {
  560.                 CComPtr<IOleClientSite> spClientSite;
  561.                 GetControllingUnknown()->QueryInterface(IID_IOleClientSite, (void**)&spClientSite);
  562.                 if (spClientSite != NULL)
  563.                     m_spOleObject->DoVerb(OLEIVERB_UIACTIVATE, NULL, spClientSite, 0, m_hWnd, &m_rcPos);
  564.             }
  565.             if(!m_bWindowless && !IsChild(::GetFocus()))
  566.                 ::SetFocus(::GetWindow(m_hWnd, GW_CHILD));
  567.         }
  568.         bHandled = FALSE;
  569.         return 0;
  570.     }
  571.     LRESULT OnKillFocus(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
  572.     {
  573.         m_bHaveFocus = FALSE;
  574.         bHandled = FALSE;
  575.         return 0;
  576.     }
  577.     LRESULT OnSize(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
  578.     {
  579.         int nWidth = LOWORD(lParam);  // width of client area
  580.         int nHeight = HIWORD(lParam); // height of client area
  581.  
  582.         m_rcPos.right = m_rcPos.left + nWidth;
  583.         m_rcPos.bottom = m_rcPos.top + nHeight;
  584.         m_pxSize.cx = m_rcPos.right - m_rcPos.left;
  585.         m_pxSize.cy = m_rcPos.bottom - m_rcPos.top;
  586.         AtlPixelToHiMetric(&m_pxSize, &m_hmSize);
  587.  
  588.         if (m_spOleObject)
  589.             m_spOleObject->SetExtent(DVASPECT_CONTENT, &m_hmSize);
  590.         if (m_spInPlaceObjectWindowless)
  591.             m_spInPlaceObjectWindowless->SetObjectRects(&m_rcPos, &m_rcPos);
  592.         if (m_bWindowless)
  593.             InvalidateRect(NULL, TRUE);
  594.         bHandled = FALSE;
  595.         return 0;
  596.     }
  597.     LRESULT OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
  598.     {
  599.         GetControllingUnknown()->AddRef();
  600.         ReleaseAll();
  601.         DefWindowProc(uMsg, wParam, lParam);
  602.         bHandled = FALSE;
  603.         return 0;
  604.     }
  605.     LRESULT OnWindowMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
  606.     {
  607.         LRESULT lRes = 0;
  608.         HRESULT hr = S_FALSE;
  609.         if (m_bInPlaceActive && m_bWindowless && m_spInPlaceObjectWindowless)
  610.             hr = m_spInPlaceObjectWindowless->OnWindowMessage(uMsg, wParam, lParam, &lRes);
  611.         if (hr == S_FALSE)
  612.             bHandled = FALSE;
  613.         return lRes;
  614.     }
  615.     LRESULT OnWindowlessMouseMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
  616.     {
  617.         LRESULT lRes = 0;
  618.         if (m_bInPlaceActive && m_bWindowless && m_spInPlaceObjectWindowless)
  619.             m_spInPlaceObjectWindowless->OnWindowMessage(uMsg, wParam, lParam, &lRes);
  620.         bHandled = FALSE;
  621.         return lRes;
  622.     }
  623.     LRESULT OnPaint(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
  624.     {
  625.         if (m_spViewObject == NULL)
  626.         {
  627.             PAINTSTRUCT ps;
  628.             HDC hdc = ::BeginPaint(m_hWnd, &ps);
  629.             if (hdc == NULL)
  630.                 return 0;
  631.             RECT rcClient;
  632.             GetClientRect(&rcClient);
  633.             HBRUSH hbrBack = CreateSolidBrush(m_clrBackground);
  634.             FillRect(hdc, &rcClient, hbrBack);
  635.             DeleteObject(hbrBack);
  636.             ::EndPaint(m_hWnd, &ps);
  637.             return 1;
  638.         }
  639.         if (m_spViewObject && m_bWindowless)
  640.         {
  641.             PAINTSTRUCT ps;
  642.             HDC hdc = ::BeginPaint(m_hWnd, &ps);
  643.  
  644.             if (hdc == NULL)
  645.                 return 0;
  646.  
  647.             RECT rcClient;
  648.             GetClientRect(&rcClient);
  649.  
  650.             HBITMAP hBitmap = CreateCompatibleBitmap(hdc, rcClient.right - rcClient.left, rcClient.bottom - rcClient.top);
  651.  
  652.             HDC hdcCompatible = ::CreateCompatibleDC(hdc);
  653.             
  654.             HBITMAP hBitmapOld = (HBITMAP)SelectObject(hdcCompatible, hBitmap); 
  655.  
  656.             HBRUSH hbrBack = CreateSolidBrush(m_clrBackground);
  657.             FillRect(hdcCompatible, &rcClient, hbrBack);
  658.             DeleteObject(hbrBack);
  659.  
  660.             m_spViewObject->Draw(DVASPECT_CONTENT, -1, NULL, NULL, NULL, hdcCompatible, (RECTL*)&m_rcPos, (RECTL*)&m_rcPos, NULL, NULL); 
  661.  
  662.             ::BitBlt(hdc, 0, 0, rcClient.right, rcClient.bottom,  hdcCompatible, 0, 0, SRCCOPY);
  663.  
  664.             ::SelectObject(hdcCompatible, hBitmapOld); 
  665.             ::DeleteObject(hBitmap);
  666.             ::DeleteDC(hdcCompatible);
  667.             ::EndPaint(m_hWnd, &ps);
  668.         }
  669.         else
  670.         {
  671.             bHandled = FALSE;
  672.             return 0;
  673.         }
  674.         return 1;
  675.     }
  676.  
  677. // IAxWinHostWindow
  678.     STDMETHOD(CreateControl)(LPCOLESTR lpTricsData, HWND hWnd, IStream* pStream)
  679.     {
  680.         CComPtr<IUnknown> p;
  681.         return CreateControlEx(lpTricsData, hWnd, pStream, &p, IID_NULL, NULL);
  682.     }
  683.     STDMETHOD(CreateControlEx)(LPCOLESTR lpszTricsData, HWND hWnd, IStream* pStream, IUnknown** ppUnk, REFIID iidAdvise, IUnknown* punkSink)
  684.     {
  685.         HRESULT hr = S_FALSE;
  686.  
  687.         ReleaseAll();
  688.  
  689.         if (m_hWnd != NULL)
  690.         {
  691.             RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_INTERNALPAINT | RDW_FRAME);
  692.             ReleaseWindow();
  693.         }
  694.  
  695.         if (::IsWindow(hWnd))
  696.         {
  697.             USES_CONVERSION;
  698.             SubclassWindow(hWnd);
  699.             if (m_clrBackground == NULL)
  700.             {
  701.                 if (IsParentDialog())
  702.                     m_clrBackground = GetSysColor(COLOR_BTNFACE);
  703.                 else
  704.                     m_clrBackground = GetSysColor(COLOR_WINDOW);
  705.             }
  706.  
  707.             bool bWasHTML;
  708.             hr = CreateNormalizedObject(lpszTricsData, IID_IUnknown, (void**)ppUnk, bWasHTML);
  709.             bool bInited = hr == S_FALSE;
  710.  
  711.             if (SUCCEEDED(hr))
  712.                 hr = ActivateAx(*ppUnk, bInited, pStream);
  713.  
  714.             //Try to hook up any sink the user might have given us.
  715.             m_iidSink = iidAdvise;
  716.             if(SUCCEEDED(hr) && *ppUnk && punkSink)
  717.                 AtlAdvise(*ppUnk, punkSink, m_iidSink, &m_dwAdviseSink);
  718.  
  719. #if !defined(_WIN32_WCE)
  720.             if (SUCCEEDED(hr) && bWasHTML && *ppUnk != NULL)
  721.             {
  722.                 if ((GetStyle() & (WS_VSCROLL | WS_HSCROLL)) == 0)
  723.                     m_dwDocHostFlags |= DOCHOSTUIFLAG_SCROLL_NO;
  724.                 else
  725.                 {
  726.                     DWORD dwStyle = GetStyle();
  727.                     SetWindowLong(GWL_STYLE, dwStyle & ~(WS_VSCROLL | WS_HSCROLL));
  728.                     SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOSIZE | SWP_FRAMECHANGED | SWP_DRAWFRAME);
  729.                 }
  730.  
  731.                 CComPtr<IUnknown> spUnk(*ppUnk);
  732.                 // Is it just plain HTML?
  733.                 USES_CONVERSION;
  734.                 if ((lpszTricsData[0] == OLECHAR('M') || lpszTricsData[0] == OLECHAR('m')) &&
  735.                     (lpszTricsData[1] == OLECHAR('S') || lpszTricsData[1] == OLECHAR('s')) &&
  736.                     (lpszTricsData[2] == OLECHAR('H') || lpszTricsData[2] == OLECHAR('h')) &&
  737.                     (lpszTricsData[3] == OLECHAR('T') || lpszTricsData[3] == OLECHAR('t')) &&
  738.                     (lpszTricsData[4] == OLECHAR('M') || lpszTricsData[4] == OLECHAR('m')) &&
  739.                     (lpszTricsData[5] == OLECHAR('L') || lpszTricsData[5] == OLECHAR('l')) &&
  740.                     (lpszTricsData[6] == OLECHAR(':')))
  741.                 {
  742.                     // Just HTML, eh?
  743.                     CComPtr<IPersistStreamInit> spPSI;
  744.                     hr = spUnk->QueryInterface(IID_IPersistStreamInit, (void**)&spPSI);
  745.                     spPSI->InitNew();
  746.                     bInited = TRUE;
  747.                     CComPtr<IHTMLDocument2> spHTMLDoc2;
  748.                     hr = spUnk->QueryInterface(IID_IHTMLDocument2, (void**)&spHTMLDoc2);
  749.                     if (SUCCEEDED(hr))
  750.                     {
  751.                         CComPtr<IHTMLElement> spHTMLBody;
  752.                         hr = spHTMLDoc2->get_body(&spHTMLBody);
  753.                         if (SUCCEEDED(hr))
  754.                             hr = spHTMLBody->put_innerHTML(CComBSTR(lpszTricsData + 7));
  755.                     }
  756.                 }
  757.                 else
  758.                 {
  759.                     CComPtr<IWebBrowser2> spBrowser;
  760.                     spUnk->QueryInterface(IID_IWebBrowser2, (void**)&spBrowser);
  761.                     if (spBrowser)
  762.                     {
  763.                         CComVariant ve;
  764.                         CComVariant vurl(lpszTricsData);
  765. #pragma warning(disable: 4310) // cast truncates constant value
  766.                         spBrowser->put_Visible(VARIANT_TRUE);
  767. #pragma warning(default: 4310) // cast truncates constant value
  768.                         spBrowser->Navigate2(&vurl, &ve, &ve, &ve, &ve);
  769.                     }
  770.                 }
  771.  
  772.             }
  773. #endif // _WIN32_WCE
  774.             if (FAILED(hr) || m_spUnknown == NULL)
  775.             {
  776.                 // We don't have a control or something failed so release
  777.                 ReleaseAll();
  778.  
  779.                 if (m_hWnd != NULL)
  780.                 {
  781.                     RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_INTERNALPAINT | RDW_FRAME);
  782.                     if (FAILED(hr))
  783.                         ReleaseWindow();
  784.                 }
  785.             }
  786.         }
  787.         return hr;
  788.     }
  789.     STDMETHOD(AttachControl)(IUnknown* pUnkControl, HWND hWnd)
  790.     {
  791.         HRESULT hr = S_FALSE;
  792.  
  793.         ReleaseAll();
  794.  
  795.         if (m_hWnd != NULL)
  796.         {
  797.             RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_INTERNALPAINT | RDW_FRAME);
  798.             ReleaseWindow();
  799.         }
  800.  
  801.         if (::IsWindow(hWnd))
  802.         {
  803.             SubclassWindow(hWnd);
  804.  
  805.             hr = ActivateAx(pUnkControl, TRUE, NULL);
  806.  
  807.             if (FAILED(hr))
  808.             {
  809.                 ReleaseAll();
  810.  
  811.                 if (m_hWnd != NULL)
  812.                 {
  813.                     RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_INTERNALPAINT | RDW_FRAME);
  814.                     ReleaseWindow();
  815.                 }
  816.             }
  817.         }
  818.         return hr;
  819.     }
  820.     STDMETHOD(QueryControl)(REFIID riid, void** ppvObject)
  821.     {
  822.         HRESULT hr = E_POINTER;
  823.         if (ppvObject)
  824.         {
  825.             if (m_spUnknown)
  826.             {
  827.                 hr = m_spUnknown->QueryInterface(riid, ppvObject);
  828.             }
  829.             else
  830.             {
  831.                 *ppvObject = NULL;
  832.                 hr = OLE_E_NOCONNECTION;
  833.             }
  834.         }
  835.         return hr;
  836.     }
  837.     STDMETHOD(SetExternalDispatch)(IDispatch* pDisp)
  838.     {
  839.         m_spExternalDispatch = pDisp;
  840.         return S_OK;
  841.     }
  842. #if !defined(_WIN32_WCE)
  843.     STDMETHOD(SetExternalUIHandler)(IDocHostUIHandlerDispatch* pUIHandler)
  844.     {
  845. #ifndef _ATL_NO_DOCHOSTUIHANDLER
  846.         m_spIDocHostUIHandlerDispatch = pUIHandler;
  847. #endif
  848.         return S_OK;
  849.     }
  850. #endif // _WIN32_WCE
  851.  
  852. #if !defined(_WIN32_WCE)
  853. #ifndef _ATL_NO_DOCHOSTUIHANDLER
  854. // IDocHostUIHandler
  855.     // MSHTML requests to display its context menu
  856.     STDMETHOD(ShowContextMenu)(DWORD dwID, POINT* pptPosition, IUnknown* pCommandTarget, IDispatch* pDispatchObjectHit)
  857.     {
  858.         HRESULT hr = m_bAllowContextMenu ? S_FALSE : S_OK;
  859.         if (m_spIDocHostUIHandlerDispatch != NULL)
  860.             m_spIDocHostUIHandlerDispatch->ShowContextMenu(
  861.                 dwID,
  862.                 pptPosition->x,
  863.                 pptPosition->y,
  864.                 pCommandTarget,
  865.                 pDispatchObjectHit,
  866.                 &hr);
  867.         return hr;
  868.     }
  869.     // Called at initialisation to find UI styles from container
  870.     STDMETHOD(GetHostInfo)(DOCHOSTUIINFO* pInfo)
  871.     {
  872.         if (pInfo == NULL)
  873.             return E_POINTER;
  874.  
  875.         if (m_spIDocHostUIHandlerDispatch != NULL)
  876.             return m_spIDocHostUIHandlerDispatch->GetHostInfo(&pInfo->dwFlags, &pInfo->dwDoubleClick);
  877.  
  878.         pInfo->dwFlags = m_dwDocHostFlags;
  879.         pInfo->dwDoubleClick = m_dwDocHostDoubleClickFlags;
  880.  
  881.         return S_OK;
  882.     }
  883.     // Allows the host to replace the IE4/MSHTML menus and toolbars. 
  884.     STDMETHOD(ShowUI)(DWORD dwID, IOleInPlaceActiveObject* pActiveObject, IOleCommandTarget* pCommandTarget, IOleInPlaceFrame* pFrame, IOleInPlaceUIWindow* pDoc)
  885.     {
  886.         HRESULT hr = m_bAllowShowUI ? S_FALSE : S_OK;
  887.         if (m_spIDocHostUIHandlerDispatch != NULL)
  888.             m_spIDocHostUIHandlerDispatch->ShowUI(
  889.                 dwID,
  890.                 pActiveObject, 
  891.                 pCommandTarget, 
  892.                 pFrame, 
  893.                 pDoc,
  894.                 &hr);
  895.         return hr;
  896.     }
  897.     // Called when IE4/MSHTML removes its menus and toolbars. 
  898.     STDMETHOD(HideUI)()
  899.     {
  900.         HRESULT hr = S_OK;
  901.         if (m_spIDocHostUIHandlerDispatch != NULL)
  902.             hr = m_spIDocHostUIHandlerDispatch->HideUI();
  903.         return hr;
  904.     }
  905.     // Notifies the host that the command state has changed. 
  906.     STDMETHOD(UpdateUI)()
  907.     {
  908.         HRESULT hr = S_OK;
  909.         if (m_spIDocHostUIHandlerDispatch != NULL)
  910.             hr = m_spIDocHostUIHandlerDispatch->UpdateUI();
  911.         return hr;
  912.     }
  913.     // Called from the IE4/MSHTML implementation of IOleInPlaceActiveObject::EnableModeless
  914.     STDMETHOD(EnableModeless)(BOOL fEnable)
  915.     {
  916.         HRESULT hr = S_OK;
  917.         if (m_spIDocHostUIHandlerDispatch != NULL)
  918. #pragma warning(disable: 4310) // cast truncates constant value
  919.             hr = m_spIDocHostUIHandlerDispatch->EnableModeless(fEnable ? VARIANT_TRUE : VARIANT_FALSE);
  920. #pragma warning(default: 4310) // cast truncates constant value
  921.         return hr;
  922.     }
  923.     // Called from the IE4/MSHTML implementation of IOleInPlaceActiveObject::OnDocWindowActivate
  924.     STDMETHOD(OnDocWindowActivate)(BOOL fActivate)
  925.     {
  926.         HRESULT hr = S_OK;
  927.         if (m_spIDocHostUIHandlerDispatch != NULL)
  928. #pragma warning(disable: 4310) // cast truncates constant value
  929.             hr = m_spIDocHostUIHandlerDispatch->OnDocWindowActivate(fActivate ? VARIANT_TRUE : VARIANT_FALSE);
  930. #pragma warning(default: 4310) // cast truncates constant value
  931.         return hr;
  932.     }
  933.     // Called from the IE4/MSHTML implementation of IOleInPlaceActiveObject::OnFrameWindowActivate. 
  934.     STDMETHOD(OnFrameWindowActivate)(BOOL fActivate)
  935.     {
  936.         HRESULT hr = S_OK;
  937.         if (m_spIDocHostUIHandlerDispatch != NULL)
  938. #pragma warning(disable: 4310) // cast truncates constant value
  939.             hr = m_spIDocHostUIHandlerDispatch->OnFrameWindowActivate(fActivate ? VARIANT_TRUE : VARIANT_FALSE);
  940. #pragma warning(default: 4310) // cast truncates constant value
  941.         return hr;
  942.     }
  943.     // Called from the IE4/MSHTML implementation of IOleInPlaceActiveObject::ResizeBorder.
  944.     STDMETHOD(ResizeBorder)(LPCRECT prcBorder, IOleInPlaceUIWindow* pUIWindow, BOOL fFrameWindow)
  945.     {
  946.         HRESULT hr = S_OK;
  947.         if (m_spIDocHostUIHandlerDispatch != NULL)
  948. #pragma warning(disable: 4310) // cast truncates constant value
  949.             hr = m_spIDocHostUIHandlerDispatch->ResizeBorder(
  950.                 prcBorder->left,
  951.                 prcBorder->top,
  952.                 prcBorder->right,
  953.                 prcBorder->bottom,
  954.                 pUIWindow,
  955.                 fFrameWindow ? VARIANT_TRUE : VARIANT_FALSE);
  956. #pragma warning(default: 4310) // cast truncates constant value
  957.         return hr;
  958.     }
  959.     // Called by IE4/MSHTML when IOleInPlaceActiveObject::TranslateAccelerator or IOleControlSite::TranslateAccelerator is called. 
  960.     STDMETHOD(TranslateAccelerator)(LPMSG lpMsg, const GUID* pguidCmdGroup, DWORD nCmdID)
  961.     {
  962.         HRESULT hr = S_FALSE;
  963.         if (m_spIDocHostUIHandlerDispatch != NULL)
  964.             m_spIDocHostUIHandlerDispatch->TranslateAccelerator(
  965.                 (DWORD) lpMsg->hwnd,
  966.                 lpMsg->message,
  967.                 lpMsg->wParam,
  968.                 lpMsg->lParam,
  969.                 CComBSTR(*pguidCmdGroup), 
  970.                 nCmdID,
  971.                 &hr);
  972.         return hr;
  973.     }
  974.     // Returns the registry key under which IE4/MSHTML stores user preferences. 
  975.     // Returns S_OK if successful, or S_FALSE otherwise. If S_FALSE, IE4/MSHTML will default to its own user options.
  976.     STDMETHOD(GetOptionKeyPath)(BSTR* pbstrKey, DWORD dwReserved)
  977.     {
  978.         HRESULT hr = S_FALSE;
  979.         if (pbstrKey == NULL)
  980.             return E_POINTER;
  981.         *pbstrKey = NULL;
  982.         if (m_spIDocHostUIHandlerDispatch != NULL)
  983.         {
  984.             hr = m_spIDocHostUIHandlerDispatch->GetOptionKeyPath(pbstrKey, dwReserved);
  985.             if (FAILED(hr) || *pbstrKey == NULL)
  986.                 hr = S_FALSE;
  987.         }
  988.         else
  989.         {
  990.             if (m_bstrOptionKeyPath.m_str != NULL)
  991.             {
  992.                 *pbstrKey = m_bstrOptionKeyPath.Copy();
  993.                 hr = S_OK;
  994.             }
  995.         }
  996.         return hr;
  997.     }
  998.     // Called by IE4/MSHTML when it is being used as a drop target to allow the host to supply an alternative IDropTarget
  999.     STDMETHOD(GetDropTarget)(IDropTarget* pDropTarget, IDropTarget** ppDropTarget)
  1000.     {
  1001.         HRESULT hr = E_NOTIMPL;
  1002.         if (ppDropTarget == NULL)
  1003.             return E_POINTER;
  1004.         *ppDropTarget = NULL;
  1005.         if (m_spIDocHostUIHandlerDispatch != NULL)
  1006.         {
  1007.             CComPtr<IUnknown> spUnk;
  1008.             hr = m_spIDocHostUIHandlerDispatch->GetDropTarget(pDropTarget, &spUnk);
  1009.             if (spUnk)
  1010.                 hr = spUnk->QueryInterface(IID_IDropTarget, (void**)ppDropTarget);
  1011.             if (FAILED(hr) || *ppDropTarget == NULL)
  1012.                 hr = S_FALSE;
  1013.         }
  1014.         return hr;
  1015.     }
  1016.     // Called by IE4/MSHTML to obtain the host's IDispatch interface
  1017.     STDMETHOD(GetExternal)(IDispatch** ppDispatch)
  1018.     {
  1019.         HRESULT hr = E_NOINTERFACE;
  1020.         if (ppDispatch == NULL)
  1021.             return E_POINTER;
  1022.         *ppDispatch = NULL;
  1023.         if (m_spIDocHostUIHandlerDispatch != NULL)
  1024.         {
  1025.             hr = m_spIDocHostUIHandlerDispatch->GetExternal(ppDispatch);
  1026.             if (FAILED(hr) || *ppDispatch == NULL)
  1027.                 hr = E_NOINTERFACE;
  1028.         }
  1029.         else
  1030.         {
  1031.             // return the IDispatch we have for extending the object Model
  1032.             if (ppDispatch != NULL)
  1033.             {
  1034.                 m_spExternalDispatch.CopyTo(ppDispatch);
  1035.                 hr = S_OK;
  1036.             }
  1037.             else
  1038.                 hr = E_POINTER;
  1039.         }
  1040.         return hr;
  1041.     }
  1042.     // Called by IE4/MSHTML to allow the host an opportunity to modify the URL to be loaded
  1043.     STDMETHOD(TranslateUrl)(DWORD dwTranslate, OLECHAR* pchURLIn, OLECHAR** ppchURLOut)
  1044.     {
  1045.         HRESULT hr = S_FALSE;
  1046.         if (ppchURLOut == NULL)
  1047.             return E_POINTER;
  1048.         *ppchURLOut = NULL;
  1049.         if (m_spIDocHostUIHandlerDispatch != NULL)
  1050.         {
  1051.             CComBSTR bstrURLOut;
  1052.             hr = m_spIDocHostUIHandlerDispatch->TranslateUrl(dwTranslate, CComBSTR(pchURLIn), &bstrURLOut);
  1053.             if (SUCCEEDED(hr) && bstrURLOut.m_str != NULL)
  1054.             {
  1055.                 UINT nLen = (bstrURLOut.Length() + 1) * 2;
  1056.                 *ppchURLOut = (OLECHAR*) CoTaskMemAlloc(nLen);
  1057.                 if (*ppchURLOut == NULL)
  1058.                     return E_OUTOFMEMORY;
  1059.                 memcpy(*ppchURLOut, bstrURLOut.m_str, nLen);
  1060.             }
  1061.             else
  1062.                 hr = S_FALSE;
  1063.         }
  1064.         return hr;
  1065.     }
  1066.     // Called on the host by IE4/MSHTML to allow the host to replace IE4/MSHTML's data object.
  1067.     // This allows the host to block certain clipboard formats or support additional clipboard formats. 
  1068.     STDMETHOD(FilterDataObject)(IDataObject* pDO, IDataObject** ppDORet)
  1069.     {
  1070.         HRESULT hr = S_FALSE;
  1071.         if (ppDORet == NULL)
  1072.             return E_POINTER;
  1073.         *ppDORet = NULL;
  1074.         if (m_spIDocHostUIHandlerDispatch != NULL)
  1075.         {
  1076.             CComPtr<IUnknown> spUnk;
  1077.             hr = m_spIDocHostUIHandlerDispatch->FilterDataObject(pDO, &spUnk);
  1078.             if (spUnk)
  1079.                 hr = QueryInterface(IID_IDataObject, (void**)ppDORet);
  1080.             if (FAILED(hr) || *ppDORet == NULL)
  1081.                 hr = S_FALSE;
  1082.         }
  1083.         return hr;
  1084.     }
  1085. #endif
  1086. #endif // _WIN32_WCE
  1087.  
  1088.     HRESULT FireAmbientPropertyChange(DISPID dispChanged)
  1089.     {
  1090.         HRESULT hr = S_OK;
  1091.         CComQIPtr<IOleControl, &IID_IOleControl> spOleControl(m_spUnknown);
  1092.         if (spOleControl != NULL)
  1093.             hr = spOleControl->OnAmbientPropertyChange(dispChanged);
  1094.         return hr;
  1095.     }
  1096.  
  1097. // IAxWinAmbientDispatch
  1098.     STDMETHOD(put_AllowWindowlessActivation)(VARIANT_BOOL bAllowWindowless)
  1099.     {
  1100.         m_bCanWindowlessActivate = bAllowWindowless;
  1101.         return S_OK;
  1102.     }
  1103.     STDMETHOD(get_AllowWindowlessActivation)(VARIANT_BOOL* pbAllowWindowless)
  1104.     {
  1105. #pragma warning(disable: 4310) // cast truncates constant value
  1106.         *pbAllowWindowless = m_bCanWindowlessActivate ? VARIANT_TRUE : VARIANT_FALSE;
  1107. #pragma warning(default: 4310) // cast truncates constant value
  1108.         return S_OK;
  1109.     }
  1110.     STDMETHOD(put_BackColor)(OLE_COLOR clrBackground)
  1111.     {
  1112.         m_clrBackground = clrBackground;
  1113.         FireAmbientPropertyChange(DISPID_AMBIENT_BACKCOLOR);
  1114.         InvalidateRect(0, FALSE);
  1115.         return S_OK;
  1116.     }
  1117.     STDMETHOD(get_BackColor)(OLE_COLOR* pclrBackground)
  1118.     {
  1119.         *pclrBackground = m_clrBackground;
  1120.         return S_OK;
  1121.     }
  1122.     STDMETHOD(put_ForeColor)(OLE_COLOR clrForeground)
  1123.     {
  1124.         m_clrForeground = clrForeground;
  1125.         FireAmbientPropertyChange(DISPID_AMBIENT_FORECOLOR);
  1126.         return S_OK;
  1127.     }
  1128.     STDMETHOD(get_ForeColor)(OLE_COLOR* pclrForeground)
  1129.     {
  1130.         *pclrForeground = m_clrForeground;
  1131.         return S_OK;
  1132.     }
  1133.     STDMETHOD(put_LocaleID)(LCID lcidLocaleID)
  1134.     {
  1135.         m_lcidLocaleID = lcidLocaleID;
  1136.         FireAmbientPropertyChange(DISPID_AMBIENT_LOCALEID);
  1137.         return S_OK;
  1138.     }
  1139.     STDMETHOD(get_LocaleID)(LCID* plcidLocaleID)
  1140.     {
  1141.         *plcidLocaleID = m_lcidLocaleID;
  1142.         return S_OK;
  1143.     }
  1144.     STDMETHOD(put_UserMode)(VARIANT_BOOL bUserMode)
  1145.     {
  1146.         m_bUserMode = bUserMode;
  1147.         FireAmbientPropertyChange(DISPID_AMBIENT_USERMODE);
  1148.         return S_OK;
  1149.     }
  1150.     STDMETHOD(get_UserMode)(VARIANT_BOOL* pbUserMode)
  1151.     {
  1152. #pragma warning(disable: 4310) // cast truncates constant value
  1153.         *pbUserMode = m_bUserMode ? VARIANT_TRUE : VARIANT_FALSE;
  1154. #pragma warning(default: 4310) // cast truncates constant value
  1155.         return S_OK;
  1156.     }
  1157.     STDMETHOD(put_DisplayAsDefault)(VARIANT_BOOL bDisplayAsDefault)
  1158.     {
  1159.         m_bDisplayAsDefault = bDisplayAsDefault;
  1160.         FireAmbientPropertyChange(DISPID_AMBIENT_DISPLAYASDEFAULT);
  1161.         return S_OK;
  1162.     }
  1163.     STDMETHOD(get_DisplayAsDefault)(VARIANT_BOOL* pbDisplayAsDefault)
  1164.     {
  1165. #pragma warning(disable: 4310) // cast truncates constant value
  1166.         *pbDisplayAsDefault = m_bDisplayAsDefault ? VARIANT_TRUE : VARIANT_FALSE;
  1167. #pragma warning(default: 4310) // cast truncates constant value
  1168.         return S_OK;
  1169.     }
  1170.     STDMETHOD(put_Font)(IFontDisp* pFont)
  1171.     {
  1172.         m_spFont = pFont;
  1173.         FireAmbientPropertyChange(DISPID_AMBIENT_FONT);
  1174.         return S_OK;
  1175.     }
  1176.     STDMETHOD(get_Font)(IFontDisp** pFont)
  1177.     {
  1178. #if defined(_WIN32_WCE)
  1179. // WinCE: no OleCreateFontIndirect
  1180.         RETAILMSG(1, (TEXT("CAxHostWindow::get_Font: Not implemented\r\n")));
  1181.         return E_NOTIMPL;
  1182. #else // _WIN32_WCE
  1183.         if (m_spFont == NULL)
  1184.         {
  1185.             USES_CONVERSION;
  1186.             HFONT hSystemFont = (HFONT) GetStockObject(DEFAULT_GUI_FONT);
  1187.             if (hSystemFont == NULL)
  1188.                 hSystemFont = (HFONT) GetStockObject(SYSTEM_FONT);
  1189.             LOGFONT logfont;
  1190.             GetObject(hSystemFont, sizeof(logfont), &logfont);
  1191.             FONTDESC fd;
  1192.             fd.cbSizeofstruct = sizeof(FONTDESC);
  1193.             fd.lpstrName = T2OLE(logfont.lfFaceName);
  1194.             fd.sWeight = (short)logfont.lfWeight;
  1195.             fd.sCharset = logfont.lfCharSet;
  1196.             fd.fItalic = logfont.lfItalic;
  1197.             fd.fUnderline = logfont.lfUnderline;
  1198.             fd.fStrikethrough = logfont.lfStrikeOut;
  1199.  
  1200.             long lfHeight = logfont.lfHeight;
  1201.             if (lfHeight < 0)
  1202.                 lfHeight = -lfHeight;
  1203.  
  1204.             int ppi;
  1205.             HDC hdc;
  1206.             if (m_hWnd)
  1207.             {
  1208.                 hdc = ::GetDC(m_hWnd);
  1209.                 ppi = GetDeviceCaps(hdc, LOGPIXELSY);
  1210.                 ::ReleaseDC(m_hWnd, hdc);
  1211.             }
  1212.             else
  1213.             {
  1214.                 hdc = ::GetDC(GetDesktopWindow());
  1215.                 ppi = GetDeviceCaps(hdc, LOGPIXELSY);
  1216.                 ::ReleaseDC(GetDesktopWindow(), hdc);
  1217.             }
  1218.             fd.cySize.Lo = lfHeight * 720000 / ppi;
  1219.             fd.cySize.Hi = 0;
  1220.  
  1221.             OleCreateFontIndirect(&fd, IID_IFontDisp, (void**) &m_spFont);
  1222.         }
  1223.  
  1224.         return m_spFont.CopyTo(pFont);
  1225. #endif // _WIN32_WCE
  1226.     }
  1227.     STDMETHOD(put_MessageReflect)(VARIANT_BOOL bMessageReflect)
  1228.     {
  1229.         m_bMessageReflect = bMessageReflect;
  1230.         FireAmbientPropertyChange(DISPID_AMBIENT_MESSAGEREFLECT);
  1231.         return S_OK;
  1232.     }
  1233.     STDMETHOD(get_MessageReflect)(VARIANT_BOOL* pbMessageReflect)
  1234.     {
  1235. #pragma warning(disable: 4310) // cast truncates constant value
  1236.         *pbMessageReflect = m_bMessageReflect ? VARIANT_TRUE : VARIANT_FALSE;
  1237. #pragma warning(default: 4310) // cast truncates constant value
  1238.         return S_OK;
  1239.     }
  1240.     STDMETHOD(get_ShowGrabHandles)(VARIANT_BOOL* pbShowGrabHandles)
  1241.     {
  1242.         *pbShowGrabHandles = VARIANT_FALSE;
  1243.         return S_OK;
  1244.     }
  1245.     STDMETHOD(get_ShowHatching)(VARIANT_BOOL* pbShowHatching)
  1246.     {
  1247.         *pbShowHatching = VARIANT_FALSE;
  1248.         return S_OK;
  1249.     }
  1250. #if !defined(_WIN32_WCE)
  1251.     STDMETHOD(put_DocHostFlags)(DWORD dwDocHostFlags)
  1252.     {
  1253.         m_dwDocHostFlags = dwDocHostFlags;
  1254.         FireAmbientPropertyChange(DISPID_UNKNOWN);
  1255.         return S_OK;
  1256.     }
  1257.     STDMETHOD(get_DocHostFlags)(DWORD* pdwDocHostFlags)
  1258.     {
  1259.         *pdwDocHostFlags = m_dwDocHostFlags;
  1260.         return S_OK;
  1261.     }
  1262.     STDMETHOD(put_DocHostDoubleClickFlags)(DWORD dwDocHostDoubleClickFlags)
  1263.     {
  1264.         m_dwDocHostDoubleClickFlags = dwDocHostDoubleClickFlags;
  1265.         return S_OK;
  1266.     }
  1267.     STDMETHOD(get_DocHostDoubleClickFlags)(DWORD* pdwDocHostDoubleClickFlags)
  1268.     {
  1269.         *pdwDocHostDoubleClickFlags = m_dwDocHostDoubleClickFlags;
  1270.         return S_OK;
  1271.     }
  1272. #endif // _WIN32_WCE
  1273.     STDMETHOD(put_AllowContextMenu)(VARIANT_BOOL bAllowContextMenu)
  1274.     {
  1275.         m_bAllowContextMenu = bAllowContextMenu;
  1276.         return S_OK;
  1277.     }
  1278.     STDMETHOD(get_AllowContextMenu)(VARIANT_BOOL* pbAllowContextMenu)
  1279.     {
  1280. #pragma warning(disable: 4310) // cast truncates constant value
  1281.         *pbAllowContextMenu = m_bAllowContextMenu ? VARIANT_TRUE : VARIANT_FALSE;
  1282. #pragma warning(default: 4310) // cast truncates constant value
  1283.         return S_OK;
  1284.     }
  1285.     STDMETHOD(put_AllowShowUI)(VARIANT_BOOL bAllowShowUI)
  1286.     {
  1287.         m_bAllowShowUI = bAllowShowUI;
  1288.         return S_OK;
  1289.     }
  1290.     STDMETHOD(get_AllowShowUI)(VARIANT_BOOL* pbAllowShowUI)
  1291.     {
  1292. #pragma warning(disable: 4310) // cast truncates constant value
  1293.         *pbAllowShowUI = m_bAllowShowUI ? VARIANT_TRUE : VARIANT_FALSE;
  1294. #pragma warning(default: 4310) // cast truncates constant value
  1295.         return S_OK;
  1296.     }
  1297.     STDMETHOD(put_OptionKeyPath)(BSTR bstrOptionKeyPath)
  1298.     {
  1299.         m_bstrOptionKeyPath = bstrOptionKeyPath;;
  1300.         return S_OK;
  1301.     }
  1302.     STDMETHOD(get_OptionKeyPath)(BSTR* pbstrOptionKeyPath)
  1303.     {
  1304.         *pbstrOptionKeyPath = m_bstrOptionKeyPath;
  1305.         return S_OK;
  1306.     }
  1307.  
  1308. // IObjectWithSite
  1309.     STDMETHOD(SetSite)(IUnknown* pUnkSite)
  1310.     {
  1311.         HRESULT hr = IObjectWithSiteImpl<CAxHostWindow>::SetSite(pUnkSite);
  1312.  
  1313. #if !defined(_WIN32_WCE)
  1314.         if (SUCCEEDED(hr) && m_spUnkSite)
  1315.         {
  1316.             // Look for "outer" IServiceProvider
  1317.             hr = m_spUnkSite->QueryInterface(IID_IServiceProvider, (void**)&m_spServices);
  1318.             ATLASSERT( !hr && "No ServiceProvider!" );
  1319.         }
  1320.  
  1321.         if (pUnkSite == NULL)
  1322.             m_spServices.Release();
  1323. #endif // _WIN32_WCE
  1324.  
  1325.         return hr;
  1326.     }
  1327.  
  1328. // IOleClientSite
  1329.     STDMETHOD(SaveObject)()
  1330.     {
  1331.         ATLTRACENOTIMPL(_T("IOleClientSite::SaveObject"));
  1332.     }
  1333.     STDMETHOD(GetMoniker)(DWORD /*dwAssign*/, DWORD /*dwWhichMoniker*/, IMoniker** /*ppmk*/)
  1334.     {
  1335.         ATLTRACENOTIMPL(_T("IOleClientSite::GetMoniker"));
  1336.     }
  1337.     STDMETHOD(GetContainer)(IOleContainer** ppContainer)
  1338.     {
  1339.         ATLTRACE2(atlTraceHosting, 0, _T("IOleClientSite::GetContainer\n"));
  1340.         HRESULT hr = E_POINTER;
  1341.         if (ppContainer)
  1342.         {
  1343.             hr = E_NOTIMPL;
  1344.             (*ppContainer) = NULL;
  1345.             if (m_spUnkSite)
  1346.                 hr = m_spUnkSite->QueryInterface(IID_IOleContainer, (void**)ppContainer);
  1347.             if (FAILED(hr))
  1348.                 hr = QueryInterface(IID_IOleContainer, (void**)ppContainer);
  1349.         }
  1350.         return hr;
  1351.     }
  1352.     STDMETHOD(ShowObject)()
  1353.     {
  1354.         ATLTRACE2(atlTraceHosting, 0, _T("IOleClientSite::ShowObject\r\n"));
  1355.  
  1356.         HDC hdc = CWindowImpl<CAxHostWindow>::GetDC();
  1357.         if (hdc == NULL)
  1358.             return E_FAIL;
  1359.         if (m_spViewObject)
  1360.             m_spViewObject->Draw(DVASPECT_CONTENT, -1, NULL, NULL, NULL, hdc, (RECTL*)&m_rcPos, (RECTL*)&m_rcPos, NULL, NULL); 
  1361.         CWindowImpl<CAxHostWindow>::ReleaseDC(hdc);
  1362.         return S_OK;
  1363.     }
  1364.     STDMETHOD(OnShowWindow)(BOOL /*fShow*/)
  1365.     {
  1366.         ATLTRACENOTIMPL(_T("IOleClientSite::OnShowWindow"));
  1367.     }
  1368.     STDMETHOD(RequestNewObjectLayout)()
  1369.     {
  1370.         ATLTRACENOTIMPL(_T("IOleClientSite::RequestNewObjectLayout"));
  1371.     }
  1372.  
  1373. // IOleInPlaceSite
  1374.     STDMETHOD(GetWindow)(HWND* phwnd)
  1375.     {
  1376.         *phwnd = m_hWnd;
  1377.         return S_OK;
  1378.     }
  1379.     STDMETHOD(ContextSensitiveHelp)(BOOL /*fEnterMode*/)
  1380.     {
  1381.         ATLTRACENOTIMPL(_T("IOleWindow::CanInPlaceActivate"));
  1382.     }
  1383.     STDMETHOD(CanInPlaceActivate)()
  1384.     {
  1385.         return S_OK;
  1386.     }
  1387.     STDMETHOD(OnInPlaceActivate)()
  1388.     {
  1389.         m_bInPlaceActive = TRUE;
  1390.         WCE_DEL OleLockRunning(m_spOleObject, TRUE, FALSE);
  1391.         m_bWindowless = FALSE;
  1392.         m_spOleObject->QueryInterface(IID_IOleInPlaceObject, (void**) &m_spInPlaceObjectWindowless);
  1393.         return S_OK;
  1394.     }
  1395.     STDMETHOD(OnUIActivate)()
  1396.     {
  1397.         ATLTRACE2(atlTraceHosting, 0, _T("IOleInPlaceSite::OnUIActivate\n"));
  1398.         m_bUIActive = TRUE;
  1399.         return S_OK;
  1400.     }
  1401.     STDMETHOD(GetWindowContext)(IOleInPlaceFrame** ppFrame, IOleInPlaceUIWindow** ppDoc, LPRECT lprcPosRect, LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO pFrameInfo)
  1402.     {
  1403.         HRESULT hr = S_OK;
  1404.         if (ppFrame == NULL || ppDoc == NULL || lprcPosRect == NULL || lprcClipRect == NULL)
  1405.             hr = E_POINTER;
  1406.         ATLASSERT(SUCCEEDED(hr));
  1407.         if (SUCCEEDED(hr))
  1408.         {
  1409.             if (!m_spInPlaceFrame)
  1410.             {
  1411.                 CComObject<CAxFrameWindow>* pFrameWindow;
  1412.                 CComObject<CAxFrameWindow>::CreateInstance(&pFrameWindow);
  1413.                 pFrameWindow->QueryInterface(IID_IOleInPlaceFrame, (void**) &m_spInPlaceFrame);
  1414.                 ATLASSERT(m_spInPlaceFrame);
  1415.             }
  1416.             if (!m_spInPlaceUIWindow)
  1417.             {
  1418.                 CComObject<CAxUIWindow>* pUIWindow;
  1419.                 CComObject<CAxUIWindow>::CreateInstance(&pUIWindow);
  1420.                 pUIWindow->QueryInterface(IID_IOleInPlaceUIWindow, (void**) &m_spInPlaceUIWindow);
  1421.                 ATLASSERT(m_spInPlaceUIWindow);
  1422.             }
  1423.             m_spInPlaceFrame.CopyTo(ppFrame);
  1424.             m_spInPlaceUIWindow.CopyTo(ppDoc);
  1425.             GetClientRect(lprcPosRect);
  1426.             GetClientRect(lprcClipRect);
  1427.  
  1428.             ACCEL ac = { 0,0,0 };
  1429.             HACCEL hac = CreateAcceleratorTable(&ac, 1);
  1430.             pFrameInfo->cb = sizeof(OLEINPLACEFRAMEINFO);
  1431.             pFrameInfo->fMDIApp = m_bMDIApp;
  1432.             pFrameInfo->hwndFrame = GetParent();
  1433.             pFrameInfo->haccel = hac;
  1434.             pFrameInfo->cAccelEntries = 1;
  1435.         }
  1436.         return hr;
  1437.     }
  1438.     STDMETHOD(Scroll)(SIZE /*scrollExtant*/)
  1439.     {
  1440.         ATLTRACENOTIMPL(_T("IOleInPlaceSite::Scroll"));
  1441.     }
  1442.     STDMETHOD(OnUIDeactivate)(BOOL /*fUndoable*/)
  1443.     {
  1444.         ATLTRACE2(atlTraceHosting, 0, _T("IOleInPlaceSite::OnUIDeactivate\n"));
  1445.         m_bUIActive = FALSE;
  1446.         return S_OK;
  1447.     }
  1448.     STDMETHOD(OnInPlaceDeactivate)()
  1449.     {
  1450.         m_bInPlaceActive = FALSE;
  1451.         m_spInPlaceObjectWindowless.Release();
  1452.         return S_OK;
  1453.     }
  1454.     STDMETHOD(DiscardUndoState)()
  1455.     {
  1456.         ATLTRACENOTIMPL(_T("IOleInPlaceSite::DiscardUndoState"));
  1457.     }
  1458.     STDMETHOD(DeactivateAndUndo)()
  1459.     {
  1460.         ATLTRACENOTIMPL(_T("IOleInPlaceSite::DeactivateAndUndo"));
  1461.     }
  1462.     STDMETHOD(OnPosRectChange)(LPCRECT /*lprcPosRect*/)
  1463.     {
  1464.         ATLTRACENOTIMPL(_T("IOleInPlaceSite::OnPosRectChange"));
  1465.     }
  1466.  
  1467. // IOleInPlaceSiteEx
  1468.     STDMETHOD(OnInPlaceActivateEx)(BOOL* /*pfNoRedraw*/, DWORD dwFlags)
  1469.     {
  1470.         m_bInPlaceActive = TRUE;
  1471.         WCE_DEL OleLockRunning(m_spOleObject, TRUE, FALSE);
  1472.         HRESULT hr = E_FAIL;
  1473.         if (dwFlags & ACTIVATE_WINDOWLESS)
  1474.         {
  1475.             m_bWindowless = TRUE;
  1476.             hr = m_spOleObject->QueryInterface(IID_IOleInPlaceObjectWindowless, (void**) &m_spInPlaceObjectWindowless);
  1477.         }
  1478.         if (FAILED(hr))
  1479.         {
  1480.             m_bWindowless = FALSE;
  1481.             hr = m_spOleObject->QueryInterface(IID_IOleInPlaceObject, (void**) &m_spInPlaceObjectWindowless);
  1482.         }
  1483.         if (m_spInPlaceObjectWindowless)
  1484.             m_spInPlaceObjectWindowless->SetObjectRects(&m_rcPos, &m_rcPos);
  1485.         return S_OK;
  1486.     }
  1487.     STDMETHOD(OnInPlaceDeactivateEx)(BOOL /*fNoRedraw*/)
  1488.     {
  1489.         return S_OK;
  1490.     }
  1491.     STDMETHOD(RequestUIActivate)()
  1492.     {
  1493.         return S_OK;
  1494.     }
  1495.  
  1496. // IOleInPlaceSiteWindowless
  1497.     STDMETHOD(CanWindowlessActivate)()
  1498.     {
  1499.         return m_bCanWindowlessActivate ? S_OK : S_FALSE;
  1500.     }
  1501.     STDMETHOD(GetCapture)()
  1502.     {
  1503.         return m_bCapture ? S_OK : S_FALSE;
  1504.     }
  1505.     STDMETHOD(SetCapture)(BOOL fCapture)
  1506.     {
  1507.         if (fCapture)
  1508.         {
  1509.             CWindow::SetCapture();
  1510.             m_bCapture = TRUE;
  1511.         }
  1512.         else
  1513.         {
  1514.             ReleaseCapture();
  1515.             m_bCapture = FALSE;
  1516.         }
  1517.         return S_OK;
  1518.     }
  1519.     STDMETHOD(GetFocus)()
  1520.     {
  1521.         return S_OK;
  1522.     }
  1523.     STDMETHOD(SetFocus)(BOOL /*fFocus*/)
  1524.     {
  1525.         return S_OK;
  1526.     }
  1527.     STDMETHOD(GetDC)(LPCRECT /*pRect*/, DWORD /*grfFlags*/, HDC* phDC)
  1528.     {
  1529.         if (phDC)
  1530.             return E_POINTER;
  1531.         *phDC = CWindowImpl<CAxHostWindow>::GetDC();
  1532.         return S_OK;
  1533.     }
  1534.     STDMETHOD(ReleaseDC)(HDC hDC)
  1535.     {
  1536.         CWindowImpl<CAxHostWindow>::ReleaseDC(hDC);
  1537.         return S_OK;
  1538.     }
  1539.     STDMETHOD(InvalidateRect)(LPCRECT pRect, BOOL fErase)
  1540.     {
  1541.         CWindowImpl<CAxHostWindow>::InvalidateRect(pRect, fErase);
  1542.         return S_OK;
  1543.     }
  1544.     STDMETHOD(InvalidateRgn)(HRGN hRGN, BOOL fErase)
  1545.     {
  1546.         WCE_DEL CWindowImpl<CAxHostWindow>::InvalidateRgn(hRGN, fErase);
  1547.         return S_OK;
  1548.     }
  1549.     STDMETHOD(ScrollRect)(INT /*dx*/, INT /*dy*/, LPCRECT /*pRectScroll*/, LPCRECT /*pRectClip*/)
  1550.     {
  1551.         return S_OK;
  1552.     }
  1553.     STDMETHOD(AdjustRect)(LPRECT /*prc*/)
  1554.     {
  1555.         return S_OK;
  1556.     }
  1557.     STDMETHOD(OnDefWindowMessage)(UINT msg, WPARAM wParam, LPARAM lParam, LRESULT* plResult)
  1558.     {
  1559.         *plResult = DefWindowProc(msg, wParam, lParam);
  1560.         return S_OK;
  1561.     }
  1562.  
  1563. // IOleControlSite
  1564.     STDMETHOD(OnControlInfoChanged)()
  1565.     {
  1566.         return S_OK;
  1567.     }
  1568.     STDMETHOD(LockInPlaceActive)(BOOL /*fLock*/)
  1569.     {
  1570.         return S_OK;
  1571.     }
  1572.     STDMETHOD(GetExtendedControl)(IDispatch** ppDisp)
  1573.     {
  1574.         if (ppDisp == NULL)
  1575.             return E_POINTER;
  1576. #if defined(_WIN32_WCE)
  1577.          return(m_spOleObject->QueryInterface(IID_IDispatch, (void**)ppDisp));
  1578. #else // _WIN32_WCE
  1579.         return m_spOleObject.QueryInterface(ppDisp);
  1580. #endif // _WIN32_WCE
  1581.     }
  1582.     STDMETHOD(TransformCoords)(POINTL* /*pPtlHimetric*/, POINTF* /*pPtfContainer*/, DWORD /*dwFlags*/)
  1583.     {
  1584.         return S_OK;
  1585.     }
  1586.     STDMETHOD(TranslateAccelerator)(LPMSG /*lpMsg*/, DWORD /*grfModifiers*/)
  1587.     {
  1588.         return S_FALSE;
  1589.     }
  1590.     STDMETHOD(OnFocus)(BOOL /*fGotFocus*/)
  1591.     {
  1592.         return S_OK;
  1593.     }
  1594.     STDMETHOD(ShowPropertyFrame)()
  1595.     {
  1596.         return E_NOTIMPL;
  1597.     }
  1598.  
  1599. // IAdviseSink
  1600.     STDMETHOD_(void, OnDataChange)(FORMATETC* /*pFormatetc*/, STGMEDIUM* /*pStgmed*/)
  1601.     {
  1602.     }
  1603.     STDMETHOD_(void, OnViewChange)(DWORD /*dwAspect*/, LONG /*lindex*/)
  1604.     {
  1605.     }
  1606.     STDMETHOD_(void, OnRename)(IMoniker* /*pmk*/)
  1607.     {
  1608.     }
  1609.     STDMETHOD_(void, OnSave)()
  1610.     {
  1611.     }
  1612.     STDMETHOD_(void, OnClose)()
  1613.     {
  1614.     }
  1615.  
  1616. // IOleContainer
  1617.     STDMETHOD(ParseDisplayName)(IBindCtx* /*pbc*/, LPOLESTR /*pszDisplayName*/, ULONG* /*pchEaten*/, IMoniker** /*ppmkOut*/)
  1618.     {
  1619.         return E_NOTIMPL;
  1620.     }
  1621.     STDMETHOD(EnumObjects)(DWORD /*grfFlags*/, IEnumUnknown** ppenum)
  1622.     {
  1623.         if (ppenum == NULL)
  1624.             return E_POINTER;
  1625.         *ppenum = NULL;
  1626.         typedef CComObject<CComEnum<IEnumUnknown, &IID_IEnumUnknown, IUnknown*, _CopyInterface<IUnknown> > > enumunk;
  1627.         enumunk* p = NULL;
  1628.         ATLTRY(p = new enumunk);
  1629.         if(p == NULL)
  1630.             return E_OUTOFMEMORY;
  1631.         HRESULT hRes = p->Init(reinterpret_cast<IUnknown**>(&m_spUnknown), reinterpret_cast<IUnknown**>(&m_spOleObject), GetControllingUnknown(), AtlFlagCopy);
  1632.         if (SUCCEEDED(hRes))
  1633.             hRes = p->QueryInterface(IID_IEnumUnknown, (void**)ppenum);
  1634.         if (FAILED(hRes))
  1635.             delete p;
  1636.         return hRes;
  1637.     }
  1638.     STDMETHOD(LockContainer)(BOOL fLock)
  1639.     {
  1640.         m_bLocked = fLock;
  1641.         return S_OK;
  1642.     }
  1643.  
  1644.     HRESULT ActivateAx(IUnknown* pUnkControl, bool bInited, IStream* pStream)
  1645.     {
  1646.         if (pUnkControl == NULL)
  1647.             return S_OK;
  1648.  
  1649.         m_spUnknown = pUnkControl;
  1650.  
  1651.         HRESULT hr = S_OK;
  1652.         pUnkControl->QueryInterface(IID_IOleObject, (void**)&m_spOleObject);
  1653.         if (m_spOleObject)
  1654.         {
  1655.             m_spOleObject->GetMiscStatus(DVASPECT_CONTENT, &m_dwMiscStatus);
  1656.             if(m_dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST)
  1657.             {
  1658.                 CComQIPtr<IOleClientSite> spClientSite(GetControllingUnknown());
  1659.                 m_spOleObject->SetClientSite(spClientSite);
  1660.             }
  1661.  
  1662.             CComQIPtr<IPersistStreamInit, &IID_IPersistStreamInit> spPSI(m_spOleObject);
  1663.             if (!bInited && spPSI)
  1664.             {
  1665.                 if (pStream)
  1666.                     spPSI->Load(pStream);
  1667.                 else
  1668.                     spPSI->InitNew();
  1669.             }
  1670.  
  1671.             if(0 == (m_dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST))
  1672.             {
  1673.                 CComQIPtr<IOleClientSite> spClientSite(GetControllingUnknown());
  1674.                 m_spOleObject->SetClientSite(spClientSite);
  1675.             }
  1676.  
  1677.             m_dwViewObjectType = 0;
  1678.             HRESULT hr;
  1679.             hr = m_spOleObject->QueryInterface(IID_IViewObjectEx, (void**) &m_spViewObject);
  1680.             if (FAILED(hr))
  1681.             {
  1682.                 hr = m_spOleObject->QueryInterface(IID_IViewObject2, (void**) &m_spViewObject);
  1683.                 m_dwViewObjectType = 3;
  1684.             } else
  1685.                 m_dwViewObjectType = 7;
  1686.  
  1687.             if (FAILED(hr))
  1688.             {
  1689.                 hr = m_spOleObject->QueryInterface(IID_IViewObject, (void**) &m_spViewObject);
  1690.                 m_dwViewObjectType = 1;
  1691.             }
  1692.             CComQIPtr<IAdviseSink> spAdviseSink(GetControllingUnknown());
  1693.             m_spOleObject->Advise(spAdviseSink, &m_dwOleObject);
  1694.             if (m_dwViewObjectType)
  1695.                 m_spViewObject->SetAdvise(DVASPECT_CONTENT, 0, spAdviseSink);
  1696.             m_spOleObject->SetHostNames(OLESTR("AXWIN"), NULL);
  1697.             GetClientRect(&m_rcPos);
  1698.             m_pxSize.cx = m_rcPos.right - m_rcPos.left;
  1699.             m_pxSize.cy = m_rcPos.bottom - m_rcPos.top;
  1700.             AtlPixelToHiMetric(&m_pxSize, &m_hmSize);
  1701.             m_spOleObject->SetExtent(DVASPECT_CONTENT, &m_hmSize);
  1702.             m_spOleObject->GetExtent(DVASPECT_CONTENT, &m_hmSize);
  1703.             AtlHiMetricToPixel(&m_hmSize, &m_pxSize);
  1704.             m_rcPos.right = m_rcPos.left + m_pxSize.cx;
  1705.             m_rcPos.bottom = m_rcPos.top + m_pxSize.cy;
  1706.  
  1707.             CComQIPtr<IOleClientSite> spClientSite(GetControllingUnknown());
  1708.             hr = m_spOleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL, spClientSite, 0, m_hWnd, &m_rcPos);
  1709.             RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_INTERNALPAINT | RDW_FRAME);
  1710.         }
  1711.         CComPtr<IObjectWithSite> spSite;
  1712.         pUnkControl->QueryInterface(IID_IObjectWithSite, (void**)&spSite);
  1713.         if (spSite != NULL)
  1714.             spSite->SetSite(GetControllingUnknown());
  1715.  
  1716.         return hr;
  1717.     }
  1718.  
  1719. // pointers
  1720.     CComPtr<IUnknown> m_spUnknown;
  1721.     CComPtr<IOleObject> m_spOleObject;
  1722.     CComPtr<IOleInPlaceFrame> m_spInPlaceFrame;
  1723.     CComPtr<IOleInPlaceUIWindow> m_spInPlaceUIWindow;
  1724.     CComPtr<IViewObjectEx> m_spViewObject;
  1725.     CComPtr<IOleInPlaceObjectWindowless> m_spInPlaceObjectWindowless;
  1726.     CComPtr<IDispatch> m_spExternalDispatch;
  1727. #if !defined(_WIN32_WCE)
  1728. #ifndef _ATL_NO_DOCHOSTUIHANDLER
  1729.     CComPtr<IDocHostUIHandlerDispatch> m_spIDocHostUIHandlerDispatch;
  1730. #endif
  1731. #endif // _WIN32_WCE
  1732.     IID m_iidSink;
  1733.     DWORD m_dwViewObjectType;
  1734.     DWORD m_dwAdviseSink;
  1735.  
  1736. // state
  1737.     unsigned long m_bInPlaceActive:1;
  1738.     unsigned long m_bUIActive:1;
  1739.     unsigned long m_bMDIApp:1;
  1740.     unsigned long m_bWindowless:1;
  1741.     unsigned long m_bCapture:1;
  1742.     unsigned long m_bHaveFocus:1;
  1743.     unsigned long m_bReleaseAll:1;
  1744.     unsigned long m_bLocked:1;
  1745.  
  1746.     DWORD m_dwOleObject;
  1747.     DWORD m_dwMiscStatus;
  1748.     SIZEL m_hmSize;
  1749.     SIZEL m_pxSize;
  1750.     RECT m_rcPos;
  1751.  
  1752.     // Ambient property storage
  1753.     unsigned long m_bCanWindowlessActivate:1;
  1754.     unsigned long m_bUserMode:1;
  1755.     unsigned long m_bDisplayAsDefault:1;
  1756.     unsigned long m_bMessageReflect:1;
  1757.     unsigned long m_bSubclassed:1;
  1758.     unsigned long m_bAllowContextMenu:1;
  1759.     unsigned long m_bAllowShowUI:1;
  1760.     OLE_COLOR m_clrBackground;
  1761.     OLE_COLOR m_clrForeground;
  1762.     LCID m_lcidLocaleID;
  1763.     CComPtr<IFontDisp> m_spFont;
  1764.     WCE_DEL CComPtr<IServiceProvider>  m_spServices;
  1765.     DWORD m_dwDocHostFlags;
  1766.     DWORD m_dwDocHostDoubleClickFlags;
  1767.     CComBSTR m_bstrOptionKeyPath;
  1768.  
  1769.     void SubclassWindow(HWND hWnd)
  1770.     {
  1771.         m_bSubclassed = CWindowImpl<CAxHostWindow>::SubclassWindow(hWnd);
  1772.     }
  1773.  
  1774.     void ReleaseWindow()
  1775.     {
  1776.         if (m_bSubclassed)
  1777.         {
  1778.             if(UnsubclassWindow(TRUE) != NULL)
  1779.                 m_bSubclassed = FALSE;
  1780.         }
  1781.         else
  1782.             DestroyWindow();
  1783.     }
  1784.  
  1785.     // Reflection
  1786.     LRESULT ReflectNotifications(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
  1787.     {
  1788.         HWND hWndChild = NULL;
  1789.  
  1790.         switch(uMsg)
  1791.         {
  1792.         case WM_COMMAND:
  1793.             if(lParam != NULL)    // not from a menu
  1794.                 hWndChild = (HWND)lParam;
  1795.             break;
  1796.         case WM_NOTIFY:
  1797.             hWndChild = ((LPNMHDR)lParam)->hwndFrom;
  1798.             break;
  1799. #if !defined(_WIN32_WCE)
  1800.         case WM_PARENTNOTIFY:
  1801.             switch(LOWORD(wParam))
  1802.             {
  1803.             case WM_CREATE:
  1804.             case WM_DESTROY:
  1805.                 hWndChild = (HWND)lParam;
  1806.                 break;
  1807.             default:
  1808.                 hWndChild = GetDlgItem(HIWORD(wParam));
  1809.                 break;
  1810.             }
  1811.             break;
  1812. #endif // _WIN32_WCE
  1813.         case WM_DRAWITEM:
  1814.             if(wParam)    // not from a menu
  1815.                 hWndChild = ((LPDRAWITEMSTRUCT)lParam)->hwndItem;
  1816.             break;
  1817.         case WM_MEASUREITEM:
  1818.             if(wParam)    // not from a menu
  1819.                 hWndChild = GetDlgItem(((LPMEASUREITEMSTRUCT)lParam)->CtlID);
  1820.             break;
  1821.         case WM_COMPAREITEM:
  1822.             if(wParam)    // not from a menu
  1823.                 hWndChild = GetDlgItem(((LPCOMPAREITEMSTRUCT)lParam)->CtlID);
  1824.             break;
  1825.         case WM_DELETEITEM:
  1826.             if(wParam)    // not from a menu
  1827.                 hWndChild = GetDlgItem(((LPDELETEITEMSTRUCT)lParam)->CtlID);
  1828.             break;
  1829.         case WM_VKEYTOITEM:
  1830.         case WM_CHARTOITEM:
  1831.         case WM_HSCROLL:
  1832.         case WM_VSCROLL:
  1833.             hWndChild = (HWND)lParam;
  1834.             break;
  1835.         case WM_CTLCOLORBTN:
  1836.         case WM_CTLCOLORDLG:
  1837.         case WM_CTLCOLOREDIT:
  1838.         case WM_CTLCOLORLISTBOX:
  1839.         case WM_CTLCOLORMSGBOX:
  1840.         case WM_CTLCOLORSCROLLBAR:
  1841.         case WM_CTLCOLORSTATIC:
  1842.             hWndChild = (HWND)lParam;
  1843.             break;
  1844.         default:
  1845.             break;
  1846.         }
  1847.  
  1848.         if(hWndChild == NULL)
  1849.         {
  1850.             bHandled = FALSE;
  1851.             return 1;
  1852.         }
  1853.  
  1854.         ATLASSERT(::IsWindow(hWndChild));
  1855.         return ::SendMessage(hWndChild, OCM__BASE + uMsg, wParam, lParam);
  1856.     }
  1857.  
  1858.     STDMETHOD(QueryService)( REFGUID rsid, REFIID riid, void** ppvObj) 
  1859.     {
  1860.         HRESULT hr = E_NOINTERFACE;
  1861.         // Try for service on this object
  1862.  
  1863.         // No services currently
  1864.  
  1865.         // If that failed try to find the service on the outer object
  1866. #if !defined(_WIN32_WCE)
  1867.         if (FAILED(hr) && m_spServices)
  1868.             hr = m_spServices->QueryService(rsid, riid, ppvObj);
  1869. #endif // _WIN32_WCE
  1870.  
  1871.         return hr;
  1872.     }
  1873. };
  1874.  
  1875.  
  1876. /////////////////////////////////////////////////////////////////////////////
  1877. // Helper functions for cracking dialog templates
  1878.  
  1879.  
  1880.  
  1881. #define _ATL_RT_DLGINIT  MAKEINTRESOURCE(240)
  1882.  
  1883. #if defined(_WIN32_WCE) && (_WIN32_WCE <= 201)
  1884. #if defined(_AFXDLL)
  1885. // WinCE: The MFCCE headers for H/PC 2.0 define these, so we need to undefine them.
  1886. #undef DISPID_DATASOURCE
  1887. #undef DISPID_DATAFIELD
  1888. #endif // _AFXDLL
  1889. #endif // _WIN32_WCE
  1890.  
  1891. class _DialogSplitHelper
  1892. {
  1893. public:
  1894.     // Constants used in DLGINIT resources for OLE control containers
  1895.     // NOTE: These are NOT real Windows messages they are simply tags
  1896.     // used in the control resource and are never used as 'messages'
  1897.     enum
  1898.     {
  1899.         WM_OCC_LOADFROMSTREAM = 0x0376,
  1900.         WM_OCC_LOADFROMSTORAGE = 0x0377,
  1901.         WM_OCC_INITNEW = 0x0378,
  1902.         WM_OCC_LOADFROMSTREAM_EX = 0x037A,
  1903.         WM_OCC_LOADFROMSTORAGE_EX = 0x037B,
  1904.         DISPID_DATASOURCE = 0x80010001,
  1905.         DISPID_DATAFIELD = 0x80010002,
  1906.     };
  1907.  
  1908. //local struct used for implementation
  1909. #pragma pack(push, 1)
  1910.     struct DLGINITSTRUCT
  1911.     {
  1912.         WORD nIDC;
  1913.         WORD message;
  1914.         DWORD dwSize;
  1915.     };
  1916.     struct DLGTEMPLATEEX
  1917.     {
  1918.         WORD dlgVer;
  1919.         WORD signature;
  1920.         DWORD helpID;
  1921.         DWORD exStyle;
  1922.         DWORD style;
  1923.         WORD cDlgItems;
  1924.         short x;
  1925.         short y;
  1926.         short cx;
  1927.         short cy;
  1928.  
  1929.         // Everything else in this structure is variable length,
  1930.         // and therefore must be determined dynamically
  1931.  
  1932.         // sz_Or_Ord menu;            // name or ordinal of a menu resource
  1933.         // sz_Or_Ord windowClass;    // name or ordinal of a window class
  1934.         // WCHAR title[titleLen];    // title string of the dialog box
  1935.         // short pointsize;            // only if DS_SETFONT is set
  1936.         // short weight;            // only if DS_SETFONT is set
  1937.         // short bItalic;            // only if DS_SETFONT is set
  1938.         // WCHAR font[fontLen];        // typeface name, if DS_SETFONT is set
  1939.     };
  1940.     struct DLGITEMTEMPLATEEX
  1941.     {
  1942.         DWORD helpID;
  1943.         DWORD exStyle;
  1944.         DWORD style;
  1945.         short x;
  1946.         short y;
  1947.         short cx;
  1948.         short cy;
  1949.         DWORD id;
  1950.  
  1951.         // Everything else in this structure is variable length,
  1952.         // and therefore must be determined dynamically
  1953.  
  1954.         // sz_Or_Ord windowClass;    // name or ordinal of a window class
  1955.         // sz_Or_Ord title;            // title string or ordinal of a resource
  1956.         // WORD extraCount;            // bytes following creation data
  1957.     };
  1958. #pragma pack(pop)
  1959.  
  1960.     static BOOL IsDialogEx(const DLGTEMPLATE* pTemplate)
  1961.     {
  1962.         return ((DLGTEMPLATEEX*)pTemplate)->signature == 0xFFFF;
  1963.     }
  1964.  
  1965.     inline static WORD& DlgTemplateItemCount(DLGTEMPLATE* pTemplate)
  1966.     {
  1967.         if (IsDialogEx(pTemplate))
  1968.             return reinterpret_cast<DLGTEMPLATEEX*>(pTemplate)->cDlgItems;
  1969.         else
  1970.             return pTemplate->cdit;
  1971.     }
  1972.  
  1973.     inline static const WORD& DlgTemplateItemCount(const DLGTEMPLATE* pTemplate)
  1974.     {
  1975.         if (IsDialogEx(pTemplate))
  1976.             return reinterpret_cast<const DLGTEMPLATEEX*>(pTemplate)->cDlgItems;
  1977.         else
  1978.             return pTemplate->cdit;
  1979.     }
  1980.  
  1981.     static DLGITEMTEMPLATE* FindFirstDlgItem(const DLGTEMPLATE* pTemplate)
  1982.     {
  1983.         BOOL bDialogEx = IsDialogEx(pTemplate);
  1984.  
  1985.         WORD* pw;
  1986.         DWORD dwStyle;
  1987.         if (bDialogEx)
  1988.         {
  1989.             pw = (WORD*)((DLGTEMPLATEEX*)pTemplate + 1);
  1990.             dwStyle = ((DLGTEMPLATEEX*)pTemplate)->style;
  1991.         }
  1992.         else
  1993.         {
  1994.             pw = (WORD*)(pTemplate + 1);
  1995.             dwStyle = pTemplate->style;
  1996.         }
  1997.  
  1998.         // Check for presence of menu and skip it if there is one
  1999.         // 0x0000 means there is no menu
  2000.         // 0xFFFF means there is a menu ID following
  2001.         // Everything else means that this is a NULL terminated Unicode string
  2002.         // which identifies the menu resource
  2003.         if (*pw == 0xFFFF)
  2004.             pw += 2;                // Has menu ID, so skip 2 words
  2005.         else
  2006.             while (*pw++);            // Either No menu, or string, skip past terminating NULL
  2007.  
  2008.         // Check for presence of class name string
  2009.         // 0x0000 means "Use system dialog class name"
  2010.         // 0xFFFF means there is a window class (atom) specified
  2011.         // Everything else means that this is a NULL terminated Unicode string
  2012.         // which identifies the menu resource
  2013.         if (*pw == 0xFFFF)
  2014.             pw += 2;                // Has class atom, so skip 2 words
  2015.         else
  2016.             while (*pw++);            // Either No class, or string, skip past terminating NULL
  2017.  
  2018.         // Skip caption string
  2019.         while (*pw++);
  2020.  
  2021.         // If we have DS_SETFONT, there is extra font information which we must now skip
  2022.         if (dwStyle & DS_SETFONT)
  2023.         {
  2024.             // If it is a regular DLGTEMPLATE there is only a short for the point size
  2025.             // and a string specifying the font (typefacename).  If this is a DLGTEMPLATEEX
  2026.             // then there is also the font weight, and bItalic which must be skipped
  2027.             if (bDialogEx)
  2028.                 pw += 3;            // Skip font size, weight, (italic, charset)
  2029.             else
  2030.                 pw += 1;            // Skip font size
  2031.             while (*pw++);            // Skip typeface name
  2032.         }
  2033.  
  2034.         // Dword-align and return
  2035.         return (DLGITEMTEMPLATE*)(((DWORD)pw + 3) & ~3);
  2036.     }
  2037.  
  2038.     // Given the current dialog item and whether this is an extended dialog
  2039.     // return a pointer to the next DLGITEMTEMPLATE*
  2040.     static DLGITEMTEMPLATE* FindNextDlgItem(DLGITEMTEMPLATE* pItem, BOOL bDialogEx)
  2041.     {
  2042.         WORD* pw;
  2043.  
  2044.         // First skip fixed size header information, size of which depends
  2045.         // if this is a DLGITEMTEMPLATE or DLGITEMTEMPLATEEX
  2046.         if (bDialogEx)
  2047.             pw = (WORD*)((DLGITEMTEMPLATEEX*)pItem + 1);
  2048.         else
  2049.             pw = (WORD*)(pItem + 1);
  2050.  
  2051.         if (*pw == 0xFFFF)            // Skip class name ordinal or string
  2052.             pw += 2; // (WORDs)
  2053.         else
  2054.             while (*pw++);
  2055.  
  2056.         if (*pw == 0xFFFF)            // Skip title ordinal or string
  2057.             pw += 2; // (WORDs)
  2058.         else
  2059.             while (*pw++);
  2060.  
  2061.         WORD cbExtra = *pw++;        // Skip extra data
  2062.  
  2063.         // Dword-align and return
  2064.         return (DLGITEMTEMPLATE*)(((DWORD)pw + cbExtra + 3) & ~3);
  2065.     }
  2066.  
  2067.     // Find the initialization data (Stream) for the control specified by the ID
  2068.     // If found, return the pointer into the data and the length of the data
  2069.     static DWORD FindCreateData(DWORD dwID, BYTE* pInitData, BYTE** pData)
  2070.     {
  2071.         while (pInitData)
  2072.         {
  2073.             // Read the DLGINIT header
  2074.             WORD nIDC = *((UNALIGNED WORD*)pInitData);
  2075.             pInitData += sizeof(WORD);
  2076.             WORD nMsg = *((UNALIGNED WORD*)pInitData);
  2077.             pInitData += sizeof(WORD);
  2078.             DWORD dwLen = *((UNALIGNED DWORD*)pInitData);
  2079.             pInitData += sizeof(DWORD);
  2080.  
  2081.             // If the header is for the control specified get the other info
  2082.             if (nIDC == dwID)
  2083.             {
  2084.                 DWORD cchLicKey = *((UNALIGNED DWORD*)pInitData);
  2085.                 pInitData += sizeof(DWORD);
  2086.                 dwLen -= sizeof(DWORD);
  2087.                 if (cchLicKey > 0)
  2088.                 {
  2089.                     CComBSTR bstrLicKey;
  2090.                     bstrLicKey.m_str = SysAllocStringLen((LPCOLESTR)pInitData, cchLicKey);
  2091.                     pInitData += cchLicKey * sizeof(OLECHAR);
  2092.                     dwLen -= cchLicKey * sizeof(OLECHAR);
  2093.                 }
  2094.  
  2095.                 // Extended (DATABINDING) stream format is not supported,
  2096.                 // we reject databinding info but preserve other information
  2097.                 if (nMsg == WM_OCC_LOADFROMSTREAM_EX ||
  2098.                     nMsg == WM_OCC_LOADFROMSTORAGE_EX)
  2099.                 {
  2100.                     // Read the size of the section
  2101.                     ULONG cbOffset = *(UNALIGNED ULONG*)pInitData;
  2102.  
  2103.                     // and simply skip past it
  2104.                     *pData = pInitData + cbOffset;
  2105.                     dwLen = dwLen - cbOffset;
  2106.                     return dwLen;
  2107.                 }
  2108.                 if (nMsg == WM_OCC_LOADFROMSTREAM)
  2109.                     *pData = pInitData;
  2110.                 return dwLen;
  2111.             }
  2112.  
  2113.             // It's not the right control, skip past data
  2114.             pInitData += dwLen;
  2115.         }
  2116.         return 0;
  2117.     }
  2118.  
  2119. #if defined(_WIN32_WCE)
  2120.     static BYTE* wce_convertDialogTemplate(DLGTEMPLATE* pNewTemplate, DLGTEMPLATEEX* pOldTemplate, ULONG nOldLen) 
  2121.     {
  2122.         ATLASSERT((sizeof(DLGTEMPLATE)%2) == 0);   // check to see if structure is WORD-aligned
  2123.         ATLASSERT((sizeof(DLGTEMPLATEEX)%2) == 0); // check to see if structure is WORD-aligned
  2124.  
  2125.         BYTE* pNew = (BYTE*)pNewTemplate;
  2126.         BYTE* pOld = (BYTE*)pOldTemplate;
  2127.         int nLen;
  2128.  
  2129.         pNewTemplate->style = pOldTemplate->style;
  2130.         pNewTemplate->dwExtendedStyle = 0;
  2131.         pNewTemplate->cdit = 0;
  2132.         pNewTemplate->x    = pOldTemplate->x;
  2133.         pNewTemplate->y    = pOldTemplate->x;
  2134.         pNewTemplate->cx   = pOldTemplate->cx;
  2135.         pNewTemplate->cy   = pOldTemplate->cy;
  2136.  
  2137.         nLen = nOldLen - sizeof(DLGTEMPLATEEX); // get everything after DLGTEMPLATEEX
  2138.         memcpy(pNew + sizeof(DLGTEMPLATE), 
  2139.                pOld + sizeof(DLGTEMPLATEEX), 
  2140.             nLen);                          // and shift it over in a memcpy
  2141.         pNew += sizeof(DLGTEMPLATE);
  2142.  
  2143.         if(!(pNewTemplate->style & DS_SETFONT))
  2144.             pNew += nLen; // No DS_SETFONT, so we're done. Point pNew at the end. 
  2145.         else
  2146.         {
  2147.             // There are two additional members (weight and italics) before the font name 
  2148.             // that needs removal. Find it by looking for the end of the title. (In this
  2149.             // case, we memcpy'd too much, but the excess will be written over here.)
  2150.             WORD *pw = (WORD*)pNew; 
  2151.             if (*pw == (WORD)-1)        // Skip menu name ordinal or string
  2152.                 pw += 2; // WORDs
  2153.             else
  2154.                 while (*pw++);
  2155.  
  2156.             if (*pw == (WORD)-1)        // Skip class name ordinal or string
  2157.                 pw += 2; // WORDs
  2158.             else
  2159.                 while (*pw++);
  2160.  
  2161.             while (*pw++);              // Skip caption string
  2162.  
  2163.             pw++;                       // Skip pointsize
  2164.             pw++;                       // Skip weight (will be deleted)
  2165.             pw++;                       // Skip italics (will be deleted)
  2166.  
  2167.             // We're at the font name, so shift it over.
  2168.             do
  2169.             {
  2170.                 *(pw-2) = *pw;
  2171.             } 
  2172.             while(*pw++);
  2173.             pw -= 2; // move to the new end of the font name
  2174.  
  2175.             // We're now at the end, so we're done!  Get the new pNew.
  2176.             pNew = (BYTE*)pw;
  2177.         }
  2178.         return pNew;
  2179.     }
  2180.  
  2181.     static BYTE* wce_convertDialogItemTemplate(DLGITEMTEMPLATE* pNewItemTemplate, DLGITEMTEMPLATEEX* pOldItemTemplate, ULONG nOldLen)
  2182.     {
  2183.         const int DLGITEMTEMPLATEEX_ERROR = 2;
  2184.         BYTE* pNew = (BYTE*)pNewItemTemplate;
  2185.         BYTE* pOld = (BYTE*)pOldItemTemplate;
  2186.         int nLen;
  2187.  
  2188.         pNewItemTemplate->style = pOldItemTemplate->style;
  2189.         pNewItemTemplate->dwExtendedStyle = 0;
  2190.         pNewItemTemplate->x  = pOldItemTemplate->x;
  2191.         pNewItemTemplate->y  = pOldItemTemplate->y;
  2192.         pNewItemTemplate->cx = pOldItemTemplate->cx;
  2193.         pNewItemTemplate->cy = pOldItemTemplate->cy;
  2194.         pNewItemTemplate->id = LOWORD(pOldItemTemplate->id);
  2195.  
  2196.         nLen = nOldLen - sizeof(DLGITEMTEMPLATEEX);
  2197.         memcpy(pNew + sizeof(DLGITEMTEMPLATE), 
  2198.             pOld + sizeof(DLGITEMTEMPLATEEX), 
  2199.             nLen);
  2200.         pNew += sizeof(DLGITEMTEMPLATE) + nLen + DLGITEMTEMPLATEEX_ERROR;
  2201.  
  2202.         return pNew;
  2203.     }
  2204. #endif // _WIN32_WCE
  2205.  
  2206.     // Convert MSDEV (MFC) style DLGTEMPLATE with controls to regular DLGTEMPLATE
  2207.     // Changing all ActiveX Controls to use ATL AxWin hosting code
  2208.     static DLGTEMPLATE* SplitDialogTemplate(DLGTEMPLATE* pTemplate, BYTE* pInitData)
  2209.     {
  2210.         USES_CONVERSION;
  2211.         LPCWSTR lpstrAxWndClassNameW = T2CW(CAxWindow::GetWndClassName());
  2212.  
  2213.         // Calculate the size of the DLGTEMPLATE for allocating the new one
  2214.         DLGITEMTEMPLATE* pFirstItem = FindFirstDlgItem(pTemplate);
  2215.         ULONG cbHeader = (BYTE*)pFirstItem - (BYTE*)pTemplate;
  2216.         ULONG cbNewTemplate = cbHeader;
  2217.  
  2218.         BOOL bDialogEx = IsDialogEx(pTemplate);
  2219.  
  2220.         int iItem;
  2221.         int nItems = (int)DlgTemplateItemCount(pTemplate);
  2222. #ifndef OLE2ANSI
  2223.         LPWSTR pszClassName;
  2224. #else
  2225.         LPSTR pszClassName;
  2226. #endif
  2227.         BOOL bHasOleControls = FALSE;
  2228.  
  2229.         // Make first pass through the dialog template.  On this pass, we're
  2230.         // interested in determining:
  2231.         //    1. Does this template contain any ActiveX Controls?
  2232.         //    2. If so, how large a buffer is needed for a template containing
  2233.         //       only the non-OLE controls?
  2234.  
  2235.         DLGITEMTEMPLATE* pItem = pFirstItem;
  2236.         DLGITEMTEMPLATE* pNextItem = pItem;
  2237.         for (iItem = 0; iItem < nItems; iItem++)
  2238.         {
  2239.             pNextItem = FindNextDlgItem(pItem, bDialogEx);
  2240.  
  2241.             pszClassName = bDialogEx ?
  2242. #ifndef OLE2ANSI
  2243.                 (LPWSTR)(((DLGITEMTEMPLATEEX*)pItem) + 1) :
  2244.                 (LPWSTR)(pItem + 1);
  2245. #else
  2246.                 (LPSTR)(((DLGITEMTEMPLATEEX*)pItem) + 1) :
  2247.                 (LPSTR)(pItem + 1);
  2248. #endif
  2249.  
  2250.             // Check if the class name begins with a '{'
  2251.             // If it does, that means it is an ActiveX Control in MSDEV (MFC) format
  2252. #ifndef OLE2ANSI
  2253.             if (pszClassName[0] == L'{')
  2254. #else
  2255.             if (pszClassName[0] == '{')
  2256. #endif
  2257.             {
  2258.                 // Item is an ActiveX control.
  2259.                 bHasOleControls = TRUE;
  2260.  
  2261.                 cbNewTemplate += (bDialogEx ? sizeof(DLGITEMTEMPLATEEX) : sizeof(DLGITEMTEMPLATE));
  2262.  
  2263.                 // Length of className including NULL terminator
  2264.                 cbNewTemplate += (lstrlenW(lpstrAxWndClassNameW) + 1) * sizeof(WCHAR);
  2265.                 
  2266.                 // Add length for the title CLSID in the form "{00000010-0000-0010-8000-00AA006D2EA4}"
  2267.                 // plus room for terminating NULL and an extra WORD for cbExtra
  2268.                 cbNewTemplate += 80;
  2269.  
  2270.                 // Get the Control ID
  2271.                 DWORD wID = bDialogEx ? ((DLGITEMTEMPLATEEX*)pItem)->id : pItem->id;
  2272.                 BYTE* pData;
  2273.                 cbNewTemplate += FindCreateData(wID, pInitData, &pData);
  2274.                 
  2275.                 // Align to next DWORD
  2276.                 cbNewTemplate = ((cbNewTemplate + 3) & ~3);
  2277.             }
  2278.             else
  2279.             {
  2280.                 // Item is not an ActiveX Control: make room for it in new template.
  2281.                 cbNewTemplate += (BYTE*)pNextItem - (BYTE*)pItem;
  2282.             }
  2283.  
  2284.             pItem = pNextItem;
  2285.         }
  2286.  
  2287.         // No OLE controls were found, so there's no reason to go any further.
  2288.         WCE_INS if(!bDialogEx && !bHasOleControls)
  2289.         WCE_DEL if (!bHasOleControls)
  2290.             return pTemplate;
  2291.  
  2292.         // Copy entire header into new template.
  2293.         BYTE* pNew = (BYTE*)GlobalAlloc(GMEM_FIXED, cbNewTemplate);
  2294.         DLGTEMPLATE* pNewTemplate = (DLGTEMPLATE*)pNew;
  2295. #if defined(_WIN32_WCE)
  2296.         if(bDialogEx)
  2297.             // At this point, cbNewTemplate is bigger than needed, but that's okay.
  2298.             pNew = wce_convertDialogTemplate((DLGTEMPLATE*)pNewTemplate,
  2299.                                             (DLGTEMPLATEEX*)pTemplate,cbHeader); 
  2300.         else
  2301.         {
  2302.             memcpy(pNew, pTemplate, cbHeader);
  2303.             pNew += cbHeader;
  2304.         }
  2305. #else // _WIN32_WCE
  2306.         memcpy(pNew, pTemplate, cbHeader);
  2307.         pNew += cbHeader;
  2308. #endif // _WIN32_WCE
  2309.  
  2310.         // Initialize item count in new header to zero.
  2311.         DlgTemplateItemCount(pNewTemplate) = 0;
  2312.  
  2313.         pItem = pFirstItem;
  2314.         pNextItem = pItem;
  2315.  
  2316.         // Second pass through the dialog template.  On this pass, we want to:
  2317.         //    1. Copy all the non-OLE controls into the new template.
  2318.         //    2. Build an array of item templates for the OLE controls.
  2319.  
  2320.         for (iItem = 0; iItem < nItems; iItem++)
  2321.         {
  2322.             pNextItem = FindNextDlgItem(pItem, bDialogEx);
  2323.  
  2324.             pszClassName = bDialogEx ?
  2325. #ifndef OLE2ANSI
  2326.                 (LPWSTR)(((DLGITEMTEMPLATEEX*)pItem) + 1) :
  2327.                 (LPWSTR)(pItem + 1);
  2328.  
  2329.             if (pszClassName[0] == L'{')
  2330. #else
  2331.                 (LPSTR)(((DLGITEMTEMPLATEEX*)pItem) + 1) :
  2332.                 (LPSTR)(pItem + 1);
  2333.  
  2334.             if (pszClassName[0] == '{')
  2335. #endif
  2336.             {
  2337.                 // Item is OLE control: add it to template as custom control
  2338.  
  2339.                 // Copy the dialog item template
  2340. #if defined(_WIN32_WCE)
  2341.                 DWORD nSizeElement;
  2342.                 if(bDialogEx)
  2343.                 {
  2344.                     ULONG cbItem = (BYTE*)pNextItem - (BYTE*)pItem;
  2345.                     BYTE* bTmp = pNew;
  2346.                     pNew = wce_convertDialogItemTemplate((DLGITEMTEMPLATE*)pNew,
  2347.                                                         (DLGITEMTEMPLATEEX*)pItem,cbItem);
  2348.                     pNew = bTmp + sizeof(DLGITEMTEMPLATE);
  2349.                 }
  2350.                 else
  2351.                 {
  2352.                     DWORD nSizeElement = bDialogEx ? sizeof(DLGITEMTEMPLATEEX) : sizeof(DLGITEMTEMPLATE);
  2353.                     memcpy(pNew, pItem, nSizeElement);
  2354.                     pNew += nSizeElement;
  2355.                 }
  2356. #else // _WIN32_WCE
  2357.                 DWORD nSizeElement = bDialogEx ? sizeof(DLGITEMTEMPLATEEX) : sizeof(DLGITEMTEMPLATE);
  2358.                 memcpy(pNew, pItem, nSizeElement);
  2359.                 pNew += nSizeElement;
  2360. #endif // _WIN32_WCE
  2361.  
  2362.                 // Copy ClassName
  2363.                 DWORD nClassName = (lstrlenW(lpstrAxWndClassNameW) + 1) * sizeof(WCHAR);
  2364.                 memcpy(pNew, lpstrAxWndClassNameW, nClassName);
  2365.                 pNew += nClassName;
  2366.  
  2367.                 // Title (CLSID)
  2368.                 memcpy(pNew, pszClassName, 78);
  2369.                 pNew += 78; // sizeof(L"{00000010-0000-0010-8000-00AA006D2EA4}") - A CLSID
  2370.  
  2371.                 DWORD wID = bDialogEx ? ((DLGITEMTEMPLATEEX*)pItem)->id : pItem->id;
  2372.                 BYTE* pData;
  2373.                 nSizeElement = FindCreateData(wID, pInitData, &pData);
  2374.  
  2375.                 // cbExtra
  2376.                 *((WORD*)pNew) = (WORD) nSizeElement;
  2377.                 pNew += sizeof(WORD);
  2378.  
  2379.                 memcpy(pNew, pData, nSizeElement);
  2380.                 pNew += nSizeElement;
  2381.                 //Align to DWORD
  2382.                 pNew += (((~((DWORD)pNew)) + 1) & 3);
  2383.  
  2384.                 // Incrememt item count in new header.
  2385.                 ++DlgTemplateItemCount(pNewTemplate);
  2386.             }
  2387.             else
  2388.             {
  2389.                 // Item is not an OLE control: copy it to the new template.
  2390.                 ULONG cbItem = (BYTE*)pNextItem - (BYTE*)pItem;
  2391.                 ATLASSERT(cbItem >= (size_t)(bDialogEx ?
  2392.                     sizeof(DLGITEMTEMPLATEEX) :
  2393.                     sizeof(DLGITEMTEMPLATE)));
  2394. #if defined(_WIN32_WCE)
  2395.                 if(bDialogEx) 
  2396.                 {
  2397.                     BYTE* bTmp = pNew;
  2398.                     pNew = wce_convertDialogItemTemplate((DLGITEMTEMPLATE*)pNew,
  2399.                                                         (DLGITEMTEMPLATEEX*)pItem,cbItem);
  2400.                     // find next dialog data assuming we have non-EX dialog item
  2401.                     pNew = (BYTE*)FindNextDlgItem((DLGITEMTEMPLATE*)bTmp, FALSE);
  2402.                 }
  2403.                 else
  2404.                 {
  2405.                     memcpy(pNew, pItem, cbItem);
  2406.                     pNew += cbItem;
  2407.                 }
  2408. #else // _WIN32_WCE
  2409.                 memcpy(pNew, pItem, cbItem);
  2410.                 pNew += cbItem;
  2411. #endif // _WIN32_WCE
  2412.  
  2413.                 // Incrememt item count in new header.
  2414.                 ++DlgTemplateItemCount(pNewTemplate);
  2415.             }
  2416.  
  2417.             pItem = pNextItem;
  2418.         }
  2419.         //ppOleDlgItems[nItems] = (DLGITEMTEMPLATE*)(-1);
  2420.  
  2421.         return pNewTemplate;
  2422.     }
  2423. };
  2424.  
  2425. static LRESULT CALLBACK AtlAxWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  2426. {
  2427.     switch(uMsg)
  2428.     {
  2429.     case WM_CREATE:
  2430.         {
  2431.         // create control from a PROGID in the title
  2432.             // This is to make sure drag drop works
  2433. #if defined(_WIN32_WCE)
  2434.             CoInitializeEx(NULL, COINIT_MULTITHREADED);
  2435. #else // _WIN32_WCE
  2436.             ::OleInitialize(NULL);
  2437. #endif // _WIN32_WCE
  2438.  
  2439.             CREATESTRUCT* lpCreate = (CREATESTRUCT*)lParam;
  2440.             int nLen = ::GetWindowTextLength(hWnd);
  2441.             LPTSTR lpstrName = (LPTSTR)_alloca((nLen + 1) * sizeof(TCHAR));
  2442.             ::GetWindowText(hWnd, lpstrName, nLen + 1);
  2443.             ::SetWindowText(hWnd, _T(""));
  2444.             IAxWinHostWindow* pAxWindow = NULL;
  2445.             int nCreateSize = 0;
  2446.             if (lpCreate && lpCreate->lpCreateParams)
  2447.                 nCreateSize = *((WORD*)lpCreate->lpCreateParams);
  2448.             HGLOBAL h = GlobalAlloc(GHND, nCreateSize);
  2449.             CComPtr<IStream> spStream;
  2450.             if (h && nCreateSize)
  2451.             {
  2452.                 BYTE* pBytes = (BYTE*) GlobalLock(h);
  2453.                 BYTE* pSource = ((BYTE*)(lpCreate->lpCreateParams)) + sizeof(WORD); 
  2454.                 //Align to DWORD
  2455.                 //pSource += (((~((DWORD)pSource)) + 1) & 3);
  2456.                 memcpy(pBytes, pSource, nCreateSize);
  2457.                 GlobalUnlock(h);
  2458.                 WCE_FCTN(CreateStreamOnHGlobal)(h, TRUE, &spStream);
  2459.             }
  2460.             USES_CONVERSION;
  2461.             CComPtr<IUnknown> spUnk;
  2462.             HRESULT hRet = AtlAxCreateControl(T2COLE(lpstrName), hWnd, spStream, &spUnk);
  2463.             if(FAILED(hRet))
  2464.                 return -1;    // abort window creation
  2465.             hRet = spUnk->QueryInterface(IID_IAxWinHostWindow, (void**)&pAxWindow);
  2466.             if(FAILED(hRet))
  2467.                 return -1;    // abort window creation
  2468.             ::SetWindowLong(hWnd, GWL_USERDATA, (DWORD)pAxWindow);
  2469. #if !defined(_WIN32_WCE)
  2470.             // check for control parent style if control has a window
  2471.             HWND hWndChild = ::GetWindow(hWnd, GW_CHILD);
  2472.             if(hWndChild != NULL)
  2473.             {
  2474.                 if(::GetWindowLong(hWndChild, GWL_EXSTYLE) & WS_EX_CONTROLPARENT)
  2475.                 {
  2476.                     DWORD dwExStyle = ::GetWindowLong(hWnd, GWL_EXSTYLE);
  2477.                     dwExStyle |= WS_EX_CONTROLPARENT;
  2478.                     ::SetWindowLong(hWnd, GWL_EXSTYLE, dwExStyle);
  2479.                 }
  2480.             }
  2481. #endif // _WIN32_WCE
  2482.         // continue with DefWindowProc
  2483.         }
  2484.         break;
  2485.     case WCE_IF(WM_DESTROY, WM_NCDESTROY):
  2486.         {
  2487.             IAxWinHostWindow* pAxWindow = (IAxWinHostWindow*)::GetWindowLong(hWnd, GWL_USERDATA);
  2488.             if(pAxWindow != NULL)
  2489.                 pAxWindow->Release();
  2490.             WCE_IF(CoUninitialize(), OleUninitialize());
  2491.         }
  2492.         break;
  2493.     default:
  2494.         break;
  2495.     }
  2496.  
  2497.     return ::DefWindowProc(hWnd, uMsg, wParam, lParam);
  2498. }
  2499.  
  2500.  
  2501.  
  2502.  
  2503. }; //namespace ATL
  2504.  
  2505. #endif  // __ATLHOST_H__
  2506.  
  2507. #ifndef _ATL_DLL_IMPL
  2508. #ifndef _ATL_DLL
  2509. #define _ATLHOST_IMPL
  2510. #endif
  2511. #endif
  2512.  
  2513. #ifdef _ATLHOST_IMPL
  2514.  
  2515. #ifndef _ATL_DLL_IMPL
  2516. namespace ATL
  2517. {
  2518. #endif
  2519.  
  2520.  
  2521. //All exports go here
  2522. ATLINLINE ATLAPI_(int) AtlAxDialogBoxW(HINSTANCE hInstance, LPCWSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogProc, LPARAM dwInitParam)
  2523. {
  2524.     AtlAxWinInit();
  2525.     HRSRC hDlg = ::FindResourceW(hInstance, lpTemplateName, (LPWSTR)RT_DIALOG);
  2526.     HRSRC hDlgInit = ::FindResourceW(hInstance, lpTemplateName, (LPWSTR)_ATL_RT_DLGINIT);
  2527.     HGLOBAL hData = NULL;
  2528.     BYTE* pInitData = NULL;
  2529.     int nRet = -1;
  2530.  
  2531.     if (hDlgInit)
  2532.     {
  2533.         hData = ::LoadResource(hInstance, hDlgInit);
  2534.         pInitData = (BYTE*) ::LockResource(hData);
  2535.     }
  2536.     if (hDlg)
  2537.     {
  2538.         HGLOBAL hResource = LoadResource(hInstance, hDlg);
  2539.         DLGTEMPLATE* pDlg = (DLGTEMPLATE*) LockResource(hResource);
  2540.         LPCDLGTEMPLATE lpDialogTemplate;
  2541.         lpDialogTemplate = _DialogSplitHelper::SplitDialogTemplate(pDlg, pInitData);
  2542.         nRet = ::DialogBoxIndirectParamW(hInstance, lpDialogTemplate, hWndParent, lpDialogProc, dwInitParam);
  2543.         if (lpDialogTemplate != pDlg)
  2544.             GlobalFree(GlobalHandle(lpDialogTemplate));
  2545.         UnlockResource(hResource);
  2546.         FreeResource(hResource);
  2547.     }
  2548.     if (pInitData && hDlgInit)
  2549.     {
  2550.         UnlockResource(hData);
  2551.         FreeResource(hData);
  2552.     }
  2553.     return nRet;
  2554. }
  2555.  
  2556. #if !defined(_WIN32_WCE)
  2557. ATLINLINE ATLAPI_(int) AtlAxDialogBoxA(HINSTANCE hInstance, LPCSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogProc, LPARAM dwInitParam)
  2558. {
  2559.     AtlAxWinInit();
  2560.     HRSRC hDlg = ::FindResourceA(hInstance, lpTemplateName, (LPSTR)RT_DIALOG);
  2561.     HRSRC hDlgInit = ::FindResourceA(hInstance, lpTemplateName, (LPSTR)_ATL_RT_DLGINIT);
  2562.     HGLOBAL hData = NULL;
  2563.     BYTE* pInitData = NULL;
  2564.     int nRet = -1;
  2565.  
  2566.     if (hDlgInit)
  2567.     {
  2568.         hData = ::LoadResource(hInstance, hDlgInit);
  2569.         pInitData = (BYTE*) ::LockResource(hData);
  2570.     }
  2571.     if (hDlg)
  2572.     {
  2573.         HGLOBAL hResource = LoadResource(hInstance, hDlg);
  2574.         DLGTEMPLATE* pDlg = (DLGTEMPLATE*) LockResource(hResource);
  2575.         LPCDLGTEMPLATE lpDialogTemplate;
  2576.         lpDialogTemplate = _DialogSplitHelper::SplitDialogTemplate(pDlg, pInitData);
  2577.         nRet = ::DialogBoxIndirectParamA(hInstance, lpDialogTemplate, hWndParent, lpDialogProc, dwInitParam);
  2578.         if (lpDialogTemplate != pDlg)
  2579.             GlobalFree(GlobalHandle(lpDialogTemplate));
  2580.         UnlockResource(hResource);
  2581.         FreeResource(hResource);
  2582.     }
  2583.     if (pInitData && hDlgInit)
  2584.     {
  2585.         UnlockResource(hData);
  2586.         FreeResource(hData);
  2587.     }
  2588.     return nRet;
  2589. }
  2590. #endif // _WIN32_WCE
  2591.  
  2592. ATLINLINE ATLAPI_(HWND) AtlAxCreateDialogW(HINSTANCE hInstance, LPCWSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogProc, LPARAM dwInitParam)
  2593. {
  2594.     AtlAxWinInit();
  2595.     HRSRC hDlg = ::FindResourceW(hInstance, lpTemplateName, (LPWSTR)RT_DIALOG);
  2596.     HRSRC hDlgInit = ::FindResourceW(hInstance, lpTemplateName, (LPWSTR)_ATL_RT_DLGINIT);
  2597.     HGLOBAL hData = NULL;
  2598.     BYTE* pInitData = NULL;
  2599.     HWND hWnd = NULL;
  2600.  
  2601.     if (hDlgInit)
  2602.     {
  2603.         hData = ::LoadResource(hInstance, hDlgInit);
  2604.         pInitData = (BYTE*) ::LockResource(hData);
  2605.     }
  2606.     if (hDlg)
  2607.     {
  2608.         HGLOBAL hResource = LoadResource(hInstance, hDlg);
  2609.         DLGTEMPLATE* pDlg = (DLGTEMPLATE*) LockResource(hResource);
  2610.         LPCDLGTEMPLATE lpDialogTemplate;
  2611.         lpDialogTemplate = _DialogSplitHelper::SplitDialogTemplate(pDlg, pInitData);
  2612.         hWnd = ::CreateDialogIndirectParamW(hInstance, lpDialogTemplate, hWndParent, lpDialogProc, dwInitParam);
  2613.         if (lpDialogTemplate != pDlg)
  2614.             GlobalFree(GlobalHandle(lpDialogTemplate));
  2615.         UnlockResource(hResource);
  2616.         FreeResource(hResource);
  2617.     }
  2618.     if (pInitData && hDlgInit)
  2619.     {
  2620.         UnlockResource(hData);
  2621.         FreeResource(hData);
  2622.     }
  2623.     return hWnd;
  2624. }
  2625.  
  2626. #if !defined(_WIN32_WCE)
  2627. ATLINLINE ATLAPI_(HWND) AtlAxCreateDialogA(HINSTANCE hInstance, LPCSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogProc, LPARAM dwInitParam)
  2628. {
  2629.     AtlAxWinInit();
  2630.     HRSRC hDlg = ::FindResourceA(hInstance, lpTemplateName, (LPSTR)RT_DIALOG);
  2631.     HRSRC hDlgInit = ::FindResourceA(hInstance, lpTemplateName, (LPSTR)_ATL_RT_DLGINIT);
  2632.     HGLOBAL hData = NULL;
  2633.     BYTE* pInitData = NULL;
  2634.     HWND hWnd = NULL;
  2635.  
  2636.     if (hDlgInit)
  2637.     {
  2638.         hData = ::LoadResource(hInstance, hDlgInit);
  2639.         pInitData = (BYTE*) ::LockResource(hData);
  2640.     }
  2641.     if (hDlg)
  2642.     {
  2643.         HGLOBAL hResource = LoadResource(hInstance, hDlg);
  2644.         DLGTEMPLATE* pDlg = (DLGTEMPLATE*) LockResource(hResource);
  2645.         LPCDLGTEMPLATE lpDialogTemplate;
  2646.         lpDialogTemplate = _DialogSplitHelper::SplitDialogTemplate(pDlg, pInitData);
  2647.         hWnd = ::CreateDialogIndirectParamA(hInstance, lpDialogTemplate, hWndParent, lpDialogProc, dwInitParam);
  2648.         if (lpDialogTemplate != pDlg)
  2649.             GlobalFree(GlobalHandle(lpDialogTemplate));
  2650.         UnlockResource(hResource);
  2651.         FreeResource(hResource);
  2652.     }
  2653.     if (pInitData && hDlgInit)
  2654.     {
  2655.         UnlockResource(hData);
  2656.         FreeResource(hData);
  2657.     }
  2658.     return hWnd;
  2659. }
  2660. #endif // _WIN32_WCE
  2661.  
  2662. ATLINLINE ATLAPI AtlAxCreateControl(LPCOLESTR lpszName, HWND hWnd, IStream* pStream, IUnknown** ppUnkContainer)
  2663. {
  2664.     return AtlAxCreateControlEx(lpszName, hWnd, pStream, ppUnkContainer, NULL, IID_NULL, NULL);
  2665. }
  2666.  
  2667. ATLINLINE ATLAPI AtlAxCreateControlEx(LPCOLESTR lpszName, HWND hWnd, IStream* pStream, 
  2668.         IUnknown** ppUnkContainer, IUnknown** ppUnkControl, REFIID iidSink, IUnknown* punkSink)
  2669. {
  2670.     AtlAxWinInit();
  2671.     HRESULT hr;
  2672.     CComPtr<IUnknown> spUnkContainer;
  2673.     CComPtr<IUnknown> spUnkControl;
  2674.  
  2675.     hr = CAxHostWindow::_CreatorClass::CreateInstance(NULL, IID_IUnknown, (void**)&spUnkContainer);
  2676.     if (SUCCEEDED(hr))
  2677.     {
  2678.         CComPtr<IAxWinHostWindow> pAxWindow;
  2679.         spUnkContainer->QueryInterface(IID_IAxWinHostWindow, (void**)&pAxWindow);
  2680.         CComBSTR bstrName(lpszName);
  2681.         hr = pAxWindow->CreateControlEx(bstrName, hWnd, pStream, &spUnkControl, iidSink, punkSink);
  2682.     }
  2683.     if (ppUnkContainer != NULL)
  2684.     {
  2685.         if (SUCCEEDED(hr))
  2686.         {
  2687.             *ppUnkContainer = spUnkContainer.p;
  2688.             spUnkContainer.p = NULL;
  2689.         }
  2690.         else
  2691.             *ppUnkContainer = NULL;
  2692.     }
  2693.     if (ppUnkControl != NULL)
  2694.     {
  2695.         if (SUCCEEDED(hr))
  2696.         {
  2697.             *ppUnkControl = SUCCEEDED(hr) ? spUnkControl.p : NULL;
  2698.             spUnkControl.p = NULL;
  2699.         }
  2700.         else
  2701.             *ppUnkControl = NULL;
  2702.     }
  2703.     return hr;
  2704. }
  2705.  
  2706. ATLINLINE ATLAPI AtlAxAttachControl(IUnknown* pControl, HWND hWnd, IUnknown** ppUnkContainer)
  2707. {
  2708.     AtlAxWinInit();
  2709.     HRESULT hr;
  2710.     if (pControl == NULL)
  2711.         return E_INVALIDARG;
  2712.     CComPtr<IUnknown> spUnkContainer;
  2713.     hr = CAxHostWindow::_CreatorClass::CreateInstance(NULL, IID_IUnknown, (void**)&spUnkContainer);
  2714.     if (SUCCEEDED(hr))
  2715.     {
  2716.         CComPtr<IAxWinHostWindow> pAxWindow;
  2717.         spUnkContainer->QueryInterface(IID_IAxWinHostWindow, (void**)&pAxWindow);
  2718.         hr = pAxWindow->AttachControl(pControl, hWnd);
  2719.     }
  2720.     if (ppUnkContainer != NULL)
  2721.     {
  2722.         *ppUnkContainer = SUCCEEDED(hr) ? spUnkContainer.p : NULL;
  2723.         spUnkContainer.p = NULL;
  2724.     }
  2725.     return hr;
  2726. }
  2727.  
  2728. //This either registers a global class (if AtlAxWinInit is in ATL.DLL)
  2729. // or it registers a local class
  2730. ATLINLINE ATLAPI_(BOOL) AtlAxWinInit()
  2731. {
  2732.     EnterCriticalSection(&_Module.m_csWindowCreate);
  2733.     WM_ATLGETHOST = RegisterWindowMessage(_T("WM_ATLGETHOST"));
  2734.     WM_ATLGETCONTROL = RegisterWindowMessage(_T("WM_ATLGETCONTROL"));
  2735.     WCE_INS WNDCLASS wc;
  2736.     WCE_DEL WNDCLASSEX wc;
  2737. // first check if the class is already registered
  2738.     WCE_DEL wc.cbSize = sizeof(WNDCLASSEX);
  2739.     BOOL bRet = ::WCE_IF(GetClassInfo,GetClassInfoEx)(_Module.GetModuleInstance(), CAxWindow::GetWndClassName(), &wc);
  2740.  
  2741. // register class if not
  2742.  
  2743.     if(!bRet)
  2744.     {
  2745.         WCE_DEL wc.cbSize = sizeof(WNDCLASSEX);
  2746. #ifdef _ATL_DLL_IMPL
  2747.         wc.style = CS_GLOBALCLASS;
  2748. #else
  2749.         wc.style = 0;
  2750. #endif
  2751.         wc.lpfnWndProc = AtlAxWindowProc;
  2752.         wc.cbClsExtra = 0;
  2753.         wc.cbWndExtra = 0;
  2754.         wc.hInstance = _Module.GetModuleInstance();
  2755.         wc.hIcon = NULL;
  2756.         WCE_INS wc.hCursor = NULL;
  2757.         WCE_DEL wc.hCursor = ::LoadCursor(NULL, IDC_ARROW);
  2758.         wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
  2759.         wc.lpszMenuName = NULL;
  2760.         wc.lpszClassName = CAxWindow::GetWndClassName();
  2761.         WCE_DEL wc.hIconSm = NULL;
  2762.         bRet = (BOOL)::WCE_IF(RegisterClass,RegisterClassEx)(&wc);
  2763.     }
  2764.     LeaveCriticalSection(&_Module.m_csWindowCreate);
  2765.     return bRet;
  2766. }
  2767.  
  2768.  
  2769. ATLINLINE ATLAPI AtlAxGetControl(HWND h, IUnknown** pp)
  2770. {
  2771.     ATLASSERT(WM_ATLGETCONTROL != 0);
  2772.     if (pp == NULL)
  2773.         return E_POINTER;
  2774.     *pp = (IUnknown*)SendMessage(h, WM_ATLGETCONTROL, 0, 0);
  2775.     return (*pp) ? S_OK : E_FAIL;
  2776. }
  2777.  
  2778. ATLINLINE ATLAPI AtlAxGetHost(HWND h, IUnknown** pp)
  2779. {
  2780.     ATLASSERT(WM_ATLGETHOST != 0);
  2781.     if (pp == NULL)
  2782.         return E_POINTER;
  2783.     *pp = (IUnknown*)SendMessage(h, WM_ATLGETHOST, 0, 0);
  2784.     return (*pp) ? S_OK : E_FAIL;
  2785. }
  2786.  
  2787. #ifndef _ATL_DLL_IMPL
  2788. }; //namespace ATL
  2789. #endif
  2790.  
  2791. //Prevent pulling in second time 
  2792. #undef _ATLHOST_IMPL
  2793.  
  2794. #endif  // __ATLHOST_H__
  2795.