Category

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

Windows Kernel

Development Platform:

Visual C++

dvoc.cpp：Code Content
  1. #include "stdafx.h"
  2. #pragma hdrstop
  4. #include "stdenum.h"
  5. #include <mshtmdid.h>
  7. #define SZ_ATL_SHEMBEDDING_WNDCLASS         TEXT("ATL Shell Embedding")
  9. HRESULT MakeSafeForScripting(IUnknown** ppDisp);
  11. class ATL_NO_VTABLE CWebViewFolderContents
  12.                     : public CComObjectRootEx<CComSingleThreadModel>
  13.                     , public CComCoClass<CWebViewFolderContents, &CLSID_WebViewFolderContents>
  14.                     , public CComControl<CWebViewFolderContents>
  15.                     , public IDispatchImpl<IShellFolderViewDual, &IID_IShellFolderViewDual, &LIBID_Shell32, 1, 0, CComTypeInfoHolder>
  16.                     , public IProvideClassInfo2Impl<&CLSID_WebViewFolderContents, NULL, &LIBID_Shell32, 1, 0, CComTypeInfoHolder>
  17.                     , public IPersistImpl<CWebViewFolderContents>
  18.                     , public IOleControlImpl<CWebViewFolderContents>
  19.                     , public IOleObjectImpl<CWebViewFolderContents>
  20.                     , public IViewObjectExImpl<CWebViewFolderContents>
  21.                     , public IOleInPlaceActiveObjectImpl<CWebViewFolderContents>
  22.                     , public IDataObjectImpl<CWebViewFolderContents>
  23.                     , public IObjectSafetyImpl<CWebViewFolderContents>
  24.                     , public IConnectionPointContainer
  25.                     , public IOleInPlaceObject
  26.                     , public IInternetSecurityMgrSite
  27.                     , public IWebViewOCWinMan
  28. {
  29. public:
  30.     CWebViewFolderContents();
  31.     ~CWebViewFolderContents();
  33.     DECLARE_POLY_AGGREGATABLE(CWebViewFolderContents);
  34.     DECLARE_NO_REGISTRY();
  35.     DECLARE_WND_CLASS(SZ_ATL_SHEMBEDDING_WNDCLASS)
  37. BEGIN_COM_MAP(CWebViewFolderContents)
  38.     // ATL Uses these in IUnknown::QueryInterface()
  39.     COM_INTERFACE_ENTRY_IMPL_IID(IID_IViewObject, IViewObjectEx)
  40.     COM_INTERFACE_ENTRY_IMPL_IID(IID_IViewObject2, IViewObjectEx)
  41.     COM_INTERFACE_ENTRY_IMPL(IViewObjectEx)
  42.     COM_INTERFACE_ENTRY_IMPL_IID(IID_IOleWindow, IOleInPlaceActiveObject)
  43.     COM_INTERFACE_ENTRY_IMPL(IOleInPlaceActiveObject)
  44.     COM_INTERFACE_ENTRY(IOleInPlaceObject)
  45.     COM_INTERFACE_ENTRY(IDispatch)
  46.     COM_INTERFACE_ENTRY(IProvideClassInfo2)
  47.     COM_INTERFACE_ENTRY(IProvideClassInfo)
  48.     COM_INTERFACE_ENTRY_IMPL(IOleControl)
  49.     COM_INTERFACE_ENTRY_IMPL(IOleObject)
  50.     COM_INTERFACE_ENTRY_IMPL(IDataObject)
  51.     COM_INTERFACE_ENTRY_IMPL(IObjectSafety)
  52.     COM_INTERFACE_ENTRY(IConnectionPointContainer)
  53.     COM_INTERFACE_ENTRY(IShellFolderViewDual)
  54.     COM_INTERFACE_ENTRY_IMPL(IPersist)
  55.     COM_INTERFACE_ENTRY(IInternetSecurityMgrSite)
  56.     COM_INTERFACE_ENTRY(IWebViewOCWinMan)
  57. END_COM_MAP()
  59.  
  60. // Declare the default message map
  61. BEGIN_MSG_MAP(CWebViewFolderContents)
  62.     MESSAGE_HANDLER(WM_SIZE, _OnSizeMessage) 
  63.     MESSAGE_HANDLER(WM_NOTIFY, _OnMessageForwarder) 
  64.     MESSAGE_HANDLER(WM_CONTEXTMENU, _OnMessageForwarder)
  65.     MESSAGE_HANDLER(WM_SETCURSOR, _OnMessageForwarder)
  66.     MESSAGE_HANDLER(WM_ERASEBKGND, _OnEraseBkgndMessage)
  67. END_MSG_MAP()
  70.     // *** IDispatch ***
  71.     virtual STDMETHODIMP Invoke(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pdispparams, VARIANT * pvarResult, EXCEPINFO * pexcepinfo, UINT * puArgErr);
  72.     virtual STDMETHODIMP GetTypeInfo(UINT itinfo, LCID lcid, ITypeInfo** pptinfo);
  73.     virtual STDMETHODIMP GetIDsOfNames(REFIID riid, OLECHAR **rgszNames, UINT cNames, LCID lcid, DISPID * rgdispid);
  75.     // *** IProvideClassInfo ***
  76.     virtual STDMETHODIMP GetClassInfo(ITypeInfo** pptinfo);
  78.     // *** IInternetSecurityMgrSite ***
  79.     // virtual STDMETHODIMP GetWindow(HWND * lphwnd);              // Also in IOleWindow
  80.     virtual STDMETHODIMP EnableModeless(BOOL fEnable) { return IOleInPlaceActiveObjectImpl<CWebViewFolderContents>::EnableModeless(fEnable); };     // Also in IOleInPlaceActiveObject
  82.     // *** ShellFolderView ***
  83.     virtual STDMETHODIMP get_Application(IDispatch **ppid);
  84.     virtual STDMETHODIMP get_Parent (IDispatch **ppid);
  85.     virtual STDMETHODIMP get_Folder(Folder **ppid);
  86.     virtual STDMETHODIMP SelectedItems(FolderItems **ppid);
  87.     virtual STDMETHODIMP get_FocusedItem(FolderItem **ppid);
  88.     virtual STDMETHODIMP SelectItem(VARIANT *pvfi, int dwFlags);
  89.     virtual STDMETHODIMP PopupItemMenu(FolderItem * pfi, VARIANT vx, VARIANT vy, BSTR * pbs);
  90.     virtual STDMETHODIMP get_Script(IDispatch **ppid);
  91.     virtual STDMETHODIMP get_ViewOptions(long *plSetting);
  93.     // *** IOleWindow ***
  94.     virtual STDMETHODIMP GetWindow(HWND * lphwnd) { return IOleInPlaceActiveObjectImpl<CWebViewFolderContents>::GetWindow(lphwnd); };
  95.     virtual STDMETHODIMP ContextSensitiveHelp(BOOL fEnterMode) { return IOleInPlaceActiveObjectImpl<CWebViewFolderContents>::ContextSensitiveHelp(fEnterMode); };
  97.     // *** IOleObject ***
  98.     virtual STDMETHODIMP GetMiscStatus(DWORD dwAspect, DWORD *pdwStatus);
  100.     // *** IOleInPlaceObject ***
  101.     virtual STDMETHODIMP InPlaceDeactivate(void);
  102.     virtual STDMETHODIMP UIDeactivate(void) { return IOleInPlaceObject_UIDeactivate(); };
  103.     virtual STDMETHODIMP SetObjectRects(LPCRECT lprcPosRect, LPCRECT lprcClipRect);
  104.     virtual STDMETHODIMP ReactivateAndUndo(void)  { return E_NOTIMPL; };
  106.     // *** IOleInPlaceActiveObject ***
  107.     // our frame was activated, better do the activation thing.
  108.     STDMETHODIMP OnFrameWindowActivate(BOOL fActivate)
  109.     {
  110.         if (_hwndLV && fActivate)
  111.             ::SetFocus(_hwndLV);
  112.         return S_OK;
  113.     };
  114.     virtual STDMETHODIMP TranslateAccelerator(LPMSG pMsg);
  116.     // *** IWebViewOCWinMan ***
  117.     STDMETHODIMP SwapWindow(HWND hwndLV, IWebViewOCWinMan **pocWinMan);
  119.     // *** IConnectionPointContainer ***
  120.     STDMETHODIMP EnumConnectionPoints(IEnumConnectionPoints **ppEnum);
  121.     STDMETHODIMP FindConnectionPoint(REFIID riid, IConnectionPoint **ppCP);
  123.     // Over ride ATL functions.
  124.     LRESULT _OnMessageForwarder(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
  125.     LRESULT _OnEraseBkgndMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
  126.     LRESULT _OnSizeMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled);
  127.     HRESULT DoVerbUIActivate(LPCRECT prcPosRect, HWND hwndParent);
  128.     HRESULT DoVerbInPlaceActivate(LPCRECT prcPosRect, HWND hwndParent);
  129.     virtual STDMETHODIMP Close(DWORD dwSaveOption);
  131. protected:
  132.     // Helper functions;
  133.     HRESULT _SetupAutomationForwarders(void);
  134.     HRESULT _ReleaseAutomationForwarders(void);
  135.     HRESULT _OnInPlaceActivate(void);
  136.     void _ReleaseWindow(void);
  137.     void _ShowWindowLV(HWND hwndLV);
  138.     void _UnadviseAll();
  140.     class CConnectionPointForwarder : public IConnectionPoint
  141.     {
  142.         // IUnknown methods
  143.         //
  144.         virtual STDMETHODIMP QueryInterface(REFIID riid, LPVOID * ppvObj);
  145.         virtual STDMETHODIMP_(ULONG) AddRef(void);
  146.         virtual STDMETHODIMP_(ULONG) Release(void);
  147.         // IConnectionPoint methods
  148.         //
  149.         virtual STDMETHODIMP GetConnectionInterface(IID * pIID);
  150.         virtual STDMETHODIMP GetConnectionPointContainer(IConnectionPointContainer ** ppCPC);
  151.         virtual STDMETHODIMP Advise(LPUNKNOWN pUnkSink, DWORD * pdwCookie);
  152.         virtual STDMETHODIMP Unadvise(DWORD dwCookie);
  153.         virtual STDMETHODIMP EnumConnections(LPENUMCONNECTIONS * ppEnum) { return _pcpAuto->EnumConnections(ppEnum); }
  155.         IConnectionPoint *  _pcpAuto;
  156.         HDSA                _dsaCookies;
  157.         IUnknown*           _punkParent;
  158.         friend class CWebViewFolderContents;
  159.     };
  160.     friend class CConnectionPointForwarder;
  161.     CConnectionPointForwarder m_cpEvents;
  163.     IDefViewFrame2 *    _pdvf2;   // defview
  164.     BOOL                _fClientEdge;
  165.     BOOL                _fTabRecieved;
  166.     BOOL                _fCalledAutoArrange;
  167.     HWND                _hwndLV;
  168.     HWND                _hwndLVParent;
  170.     ITypeInfo *         _pClassTypeInfo; // ITypeInfo of class
  172.     // stuff added to delegate all of our work up to DefViews automation
  173.     IShellFolderViewDual *_pdispAuto;
  174. };
  177. LCID g_lcidLocaleUnicpp = MAKELCID(LANG_USER_DEFAULT, SORT_DEFAULT);
  179. // Helper function that can be used here and in main shell folder view window to get the
  180. // current view options...
  181. DWORD GetViewOptionsForDispatch()
  182. {
  183.     SHELLSTATE ss = {0};
  184.     DWORD dwSetting = 0;
  186.     // Get the view options to return...
  188.     SHGetSetSettings(&ss, 
  189.         SSF_SHOWALLOBJECTS|SSF_SHOWEXTENSIONS|SSF_SHOWCOMPCOLOR|
  190.             SSF_SHOWSYSFILES|SSF_DOUBLECLICKINWEBVIEW|SSF_DESKTOPHTML|SSF_WIN95CLASSIC,
  191.         FALSE);
  193.     // Aarg: mnuch the Bool:1 fields into a dword...
  194.     if (ss.fShowAllObjects) dwSetting |= SFVVO_SHOWALLOBJECTS;
  195.     if (ss.fShowExtensions) dwSetting |= SFVVO_SHOWEXTENSIONS;
  196.     if (ss.fShowCompColor) dwSetting |= SFVVO_SHOWCOMPCOLOR;
  197.     if (ss.fShowSysFiles) dwSetting |= SFVVO_SHOWSYSFILES;
  198.     if (ss.fDoubleClickInWebView) dwSetting |= SFVVO_DOUBLECLICKINWEBVIEW;
  199.     if (ss.fDesktopHTML) dwSetting |= SFVVO_DESKTOPHTML;
  200.     if (ss.fWin95Classic) dwSetting |= SFVVO_WIN95CLASSIC;
  201.     
  202.     return dwSetting;
  203. }
  207. CWebViewFolderContents::CWebViewFolderContents()
  208. {
  209.     DllAddRef();
  211.     // This allocator should have zero inited the memory, so assert the member variables are empty.
  212.     ASSERT(!_pdvf2);
  213.     ASSERT(!_hwndLV);
  214.     ASSERT(!_hwndLVParent);
  215.     ASSERT(!_fClientEdge);
  216.     ASSERT(!_fTabRecieved);
  217.     ASSERT(!_pClassTypeInfo);
  218.     ASSERT(!m_cpEvents._dsaCookies);
  219.     ASSERT(!_fCalledAutoArrange);
  220.     
  221.     m_bWindowOnly = TRUE;
  222.     m_bEnabled = TRUE;
  223.     m_bResizeNatural = TRUE;
  224.     m_cpEvents._punkParent = SAFECAST(this, IWebViewOCWinMan *);
  225.     GetWndClassInfo().m_wc.style &= ~(CS_HREDRAW|CS_VREDRAW);
  226. }
  228. CWebViewFolderContents::~CWebViewFolderContents()
  229. {
  230.     _UnadviseAll();
  231.     ASSERT(NULL == _pdvf2);
  232.     ASSERT(NULL == _hwndLV);
  234.     if (_pClassTypeInfo)
  235.         _pClassTypeInfo->Release();
  237.     ATOMICRELEASE(_pdvf2);
  238.     _ReleaseAutomationForwarders();
  240.     DllRelease();
  241. }
  244. // ATL maintainence functions
  245. LRESULT CWebViewFolderContents::_OnMessageForwarder(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled)
  246. {
  247.     if (_hwndLVParent)
  248.     {
  249.         bHandled = TRUE;
  250.         HWND hwnd = NULL;
  252.         // Forward these messages directly to DefView (don't let MSHTML eat them)
  253.         return ::SendMessage(_hwndLVParent, uMsg, wParam, lParam);
  254.     }
  255.     else
  256.         return 0;
  257. }
  260. LRESULT CWebViewFolderContents::_OnEraseBkgndMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled)
  261. {
  262.     // This function will just tell the default handler not to do anything and we
  263.     // will handle it.
  265.     // This is done in the case of WM_ERASEBKGND to...
  266.     // Avoid flicker by not erasing the background. This OC doesn't care
  267.     // about design-time issues - just usage on a Web View page.
  268.     bHandled = TRUE;
  269.     return 1;
  270. }
  273. LRESULT CWebViewFolderContents::_OnSizeMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL & bHandled)
  274. {
  275.     // Now resize the DefView ListView window because ATL isn't very reliable at it.
  276.     if (_hwndLV)
  277.     {
  278.         // During re-parenting of _hwndLV by Trident, the size of the OC is not known to Trident.
  279.         // So, initially we get this message with 1 and 1 for the width and height, from it.
  280.         // And once Trident knows it's correct dimensions, we again get this message with the proper dim.
  281.         // We get a performance gain by not passing the first no-sense 1 x 1 dimension to _hwndLV.
  282.         //
  283.         if (m_rcPos.right - m_rcPos.left != 1 || m_rcPos.bottom - m_rcPos.top != 1)
  284.         {
  285.             ::SetWindowPos(_hwndLV, 0, 0, 0, m_rcPos.right - m_rcPos.left, m_rcPos.bottom - m_rcPos.top, SWP_NOZORDER);
  286.         }
  287.     }
  289.     bHandled = FALSE;
  290.     return 0;
  291. }
  294. HRESULT CWebViewFolderContents::DoVerbUIActivate(LPCRECT prcPosRect, HWND hwndParent)
  295. {
  296.     HRESULT hr = IOleObjectImpl<CWebViewFolderContents>::DoVerbUIActivate(prcPosRect, hwndParent);
  298.     if (SUCCEEDED(hr))
  299.     {
  300.         hr = _OnInPlaceActivate();
  301.     }
  303.     if (_hwndLV)
  304.     {
  305.         ::SetFocus(_hwndLV);
  306.     }
  307.     return hr;
  308. }
  311. // move from de-active to in-place-active
  312. HRESULT CWebViewFolderContents::_OnInPlaceActivate(void)
  313. {
  314.     HRESULT hr = S_OK;
  316.     if (_pdvf2 == NULL)
  317.     {
  318.         hr = IUnknown_QueryService(m_spClientSite, SID_DefView, IID_IDefViewFrame2, (void **)&_pdvf2);
  319.         if (EVAL(SUCCEEDED(hr)))
  320.         {
  321.             hr = _pdvf2->GetWindowLV2(&_hwndLV, SAFECAST(this, IWebViewOCWinMan *));
  322.             if (SUCCEEDED(hr))
  323.             {
  324.                 _ShowWindowLV(_hwndLV); // we got it -- show the listview
  325.             }
  326.         }
  327.     }
  328.     return hr;
  329. }
  331. HRESULT CWebViewFolderContents::DoVerbInPlaceActivate(LPCRECT prcPosRect, HWND hwndParent)
  332. {
  333.     HRESULT hr = IOleObjectImpl<CWebViewFolderContents>::DoVerbInPlaceActivate(prcPosRect, hwndParent);
  334.     if (EVAL(SUCCEEDED(hr)))
  335.     {
  336.         hr = _OnInPlaceActivate();
  337.     }
  338.     return hr;
  339. }
  341. HRESULT CWebViewFolderContents::InPlaceDeactivate(void)
  342. {
  343.     _ReleaseWindow();
  344.     ATOMICRELEASE(_pdvf2);
  346.     return IOleInPlaceObject_InPlaceDeactivate();
  347. }
  349. HRESULT CWebViewFolderContents::SetObjectRects(LPCRECT prcPosRect, LPCRECT prcClipRect)
  350. {
  352. //  WARNING: Do NOT move the EqualRect() comparison to after the
  353. //  IOleInPlaceObject_SetObjectRects declaration. The EqualRect()
  354. //  will always return an equal result then.
  356.     bool    bPositionRectDifferent = (EqualRect(&m_rcPos, prcPosRect) == 0);
  357.     HRESULT hres = IOleInPlaceObject_SetObjectRects(prcPosRect, prcClipRect);
  359. //  99/02/23 #294278 vtan: Trident did not call this routine when
  360. //  marquee selecting but it now does. The jumpy scrolling now
  361. //  manifests. Check that posRect has not changed before making
  362. //  any scroll position adjustments.
  364.     if (_hwndLV && _pdvf2 && (!_fCalledAutoArrange || bPositionRectDifferent))
  365.     {
  366.         _pdvf2->AutoAutoArrange(0);
  367.         _fCalledAutoArrange = TRUE;
  368.     }
  370.     return hres;
  371. }
  373. // *** IOleInPlaceActiveObject ***
  374. HRESULT CWebViewFolderContents::TranslateAccelerator(LPMSG pMsg)
  375. {
  376.     HRESULT hres = S_OK;
  377.     if (!_fTabRecieved)
  378.     {
  379.         hres = IOleInPlaceActiveObjectImpl<CWebViewFolderContents>::TranslateAccelerator(pMsg);
  381.         // If we did not handle this and if it is a tab (and we are not getting it in a cycle), forward it to trident, if present.
  382.         if (hres != S_OK && pMsg && (pMsg->wParam == VK_TAB || pMsg->wParam == VK_F6) && m_spClientSite)
  383.         {
  384.             IOleControlSite* pocs = NULL;
  385.             if (SUCCEEDED(m_spClientSite->QueryInterface(IID_IOleControlSite, (void **)&pocs)))
  386.             {
  387.                 DWORD grfModifiers = 0;
  388.                 if (GetKeyState(VK_SHIFT) & 0x8000)
  389.                 {
  390.                     grfModifiers |= 0x1;    //KEYMOD_SHIFT
  391.                 }
  392.                 if (GetKeyState(VK_CONTROL) & 0x8000)
  393.                 {
  394.                     grfModifiers |= 0x2;    //KEYMOD_CONTROL;
  395.                 }
  396.                 if (GetKeyState(VK_MENU) & 0x8000)
  397.                 {
  398.                     grfModifiers |= 0x4;    //KEYMOD_ALT;
  399.                 }
  400.                 _fTabRecieved = TRUE;
  401.                 hres = pocs->TranslateAccelerator(pMsg, grfModifiers);
  402.                 _fTabRecieved = FALSE;
  403.             }
  404.         }
  405.     }
  406.     return hres;
  407. }
  409. // *** IProvideClassInfo ***
  410. HRESULT CWebViewFolderContents::GetClassInfo(ITypeInfo ** ppTI)
  411. {
  412.     if (!_pClassTypeInfo) 
  413.         Shell32GetTypeInfo(LANGIDFROMLCID(g_lcidLocaleUnicpp), CLSID_WebViewFolderContents, &_pClassTypeInfo);
  415.     if (EVAL(_pClassTypeInfo))
  416.     {
  417.         _pClassTypeInfo->AddRef();
  418.         *ppTI = _pClassTypeInfo;
  419.         return S_OK;
  420.     }
  422.     *ppTI = NULL;
  423.     return E_FAIL;
  424. }
  426. HRESULT CWebViewFolderContents::GetTypeInfo(UINT itinfo, LCID lcid, ITypeInfo** ppITypeInfo)
  427. {
  428.     HRESULT hr = S_OK;
  430.     *ppITypeInfo = NULL;
  432.     if (0 != itinfo)
  433.         return TYPE_E_ELEMENTNOTFOUND;
  435.     //Load a type lib if we don't have the information already.
  436.     if (NULL == *ppITypeInfo)
  437.     {
  438.         ITypeInfo * pITIDisp;
  440.         hr = Shell32GetTypeInfo(lcid, IID_IShellFolderViewDual, &pITIDisp);
  442.         if (SUCCEEDED(hr))
  443.         {
  444.             HRESULT hrT;
  445.             HREFTYPE hrefType;
  447.             // All our IDispatch implementations are DUAL. GetTypeInfoOfGuid
  448.             // returns the ITypeInfo of the IDispatch-part only. We need to
  449.             // find the ITypeInfo for the dual interface-part.
  450.             //
  451.             hrT = pITIDisp->GetRefTypeOfImplType(0xffffffff, &hrefType);
  452.             if (SUCCEEDED(hrT))
  453.                 hrT = pITIDisp->GetRefTypeInfo(hrefType, ppITypeInfo);
  455.             ASSERT(SUCCEEDED(hrT));
  456.             pITIDisp->Release();
  457.         }
  458.     }
  460.     return hr;
  461. }
  464. HRESULT CWebViewFolderContents::GetIDsOfNames(REFIID /*riid*/, LPOLESTR* rgszNames,
  465.     UINT cNames, LCID lcid, DISPID* rgdispid)
  466. {
  467.     ITypeInfo* pInfo;
  468.     HRESULT hr = GetTypeInfo(0, lcid, &pInfo);
  470.     if (pInfo != NULL)
  471.     {
  472.         hr = pInfo->GetIDsOfNames(rgszNames, cNames, rgdispid);
  473.         pInfo->Release();
  474.     }
  476.     TraceMsg(TF_DEFVIEW, "CWebViewFolderContents::GetIDsOfNames(DISPID=%ls, lcid=%d, cNames=%d) returned hr=%#08lx", *rgszNames, lcid, cNames, hr);
  477.     return hr;
  478. }
  480. HRESULT CWebViewFolderContents::Invoke(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pdispparams, VARIANT * pvarResult, EXCEPINFO * pexcepinfo, UINT * puArgErr)
  481. {
  482.     HRESULT hr = E_FAIL;
  483.     DISPPARAMS dispparams = {0};
  485.     if (!pdispparams)
  486.         pdispparams = &dispparams;  // otherwise OLE Fails when passed NULL.
  488.     if (dispidMember == DISPID_WINDOWOBJECT)
  489.     {
  490.         IDispatch * pdisp;
  491.         if (SUCCEEDED(get_Script(&pdisp)))
  492.         {
  493.             hr = pdisp->Invoke(dispidMember, riid, lcid, wFlags, pdispparams, pvarResult, pexcepinfo, puArgErr);
  494.             pdisp->Release();
  495.             return hr;
  496.         }
  497.         else
  498.             return DISP_E_MEMBERNOTFOUND;
  499.     }
  501.     // Make sure we are connected up to defviews automation.
  502.     hr = _SetupAutomationForwarders();
  503.     if (SUCCEEDED(hr))
  504.         hr = _pdispAuto->Invoke(dispidMember, riid, lcid, wFlags, pdispparams, pvarResult, pexcepinfo, puArgErr);
  506.     TraceMsg(TF_DEFVIEW, "CWebViewFolderContents::Invoke(DISPID=%#08lx, lcid=%d, wFlags=%d, pvarResult=%#08lx) returned hr=%#08lx", dispidMember, lcid, wFlags, pvarResult, hr);
  507.     return hr;
  508. }
  510. #define DW_MISC_STATUS (OLEMISC_SETCLIENTSITEFIRST | OLEMISC_ACTIVATEWHENVISIBLE | OLEMISC_CANTLINKINSIDE | OLEMISC_INSIDEOUT)
  512. HRESULT CWebViewFolderContents::GetMiscStatus(DWORD dwAspect, DWORD *pdwStatus)
  513. {
  514.     *pdwStatus = DW_MISC_STATUS;
  515.     return S_OK;
  516. }
  517.  
  518. // IWebViewOCWinMan
  520. HRESULT CWebViewFolderContents::SwapWindow(HWND hwndLV, IWebViewOCWinMan **ppocWinMan)
  521. {
  522.     *ppocWinMan = NULL;
  524.     _ReleaseWindow();
  526.     if (hwndLV)
  527.     {
  528.         _ShowWindowLV(hwndLV);
  530.         _InternalQueryInterface(IID_IWebViewOCWinMan, (void **)ppocWinMan);
  531.     }
  532.     return S_OK;
  533. }
  536. void CWebViewFolderContents::_ShowWindowLV(HWND hwndLV)
  537. {
  538.     if (!hwndLV)
  539.         return;
  540.     _hwndLV = hwndLV;
  541.     _hwndLVParent = ::GetParent(_hwndLV);
  543.     SHSetParentHwnd(_hwndLV, m_hWnd);
  545.     LONG lExStyle = ::GetWindowLong(_hwndLV, GWL_EXSTYLE);
  546.     _fClientEdge = lExStyle & WS_EX_CLIENTEDGE ? TRUE : FALSE;
  547.     if (_fClientEdge)
  548.     {
  549.         lExStyle &= ~WS_EX_CLIENTEDGE;
  550.         ::SetWindowLong(_hwndLV, GWL_EXSTYLE, lExStyle);
  551.     }
  553.     ::SetWindowPos(_hwndLV, 0, 0, 0, m_rcPos.right - m_rcPos.left
  554.                     , m_rcPos.bottom - m_rcPos.top
  555.                     , SWP_NOZORDER | SWP_SHOWWINDOW);
  557.     // BUGBUG kenwic 060399 #258594 We need to autoautoarrange the sfvext listview after we size it FIXED kenwic 060399
  558.     _pdvf2->AutoAutoArrange(0);
  559. }
  561. void CWebViewFolderContents::_ReleaseWindow()
  562. {
  563.     if (_hwndLV)
  564.     {
  565.         if (_fClientEdge)
  566.             SetWindowBits(_hwndLV, GWL_EXSTYLE, WS_EX_CLIENTEDGE, WS_EX_CLIENTEDGE);
  568.         ::ShowWindow(_hwndLV, SW_HIDE);       // HIDE IT SO IT doesn't flash before switching.
  569.         SHSetParentHwnd(_hwndLV, _hwndLVParent);
  570.         ::SetWindowPos(_hwndLV, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
  571.         _pdvf2->ReleaseWindowLV();
  572.         _hwndLV = NULL;
  573.     }
  574. }
  577. // *** IConnectionPointContainer ***
  578. HRESULT CWebViewFolderContents::EnumConnectionPoints(IEnumConnectionPoints **ppEnum)
  579. {
  580.     HRESULT hr = _SetupAutomationForwarders();
  581.     if (SUCCEEDED(hr))
  582.         hr = CreateInstance_IEnumConnectionPoints(ppEnum, 1, SAFECAST(&m_cpEvents, IConnectionPoint*));
  584.     return hr;
  585. }
  587. HRESULT CWebViewFolderContents::FindConnectionPoint(REFIID iid, IConnectionPoint **ppCP)
  588. {
  589.     *ppCP = NULL;
  590.     HRESULT hr = _SetupAutomationForwarders();
  591.     if (SUCCEEDED(hr))
  592.     {
  593.         if (IsEqualIID(iid, DIID_DShellFolderViewEvents) || IsEqualIID(iid, IID_IDispatch))
  594.         {
  595.             *ppCP = SAFECAST(&m_cpEvents, IConnectionPoint*);
  596.             (*ppCP)->AddRef();
  597.             hr = S_OK;
  598.         }
  599.         else
  600.         {
  601.             hr = E_NOINTERFACE;
  602.         }
  603.     }
  604.     return hr;
  605. }
  607. // *** IConnectionPoint ***
  608. //
  609. // Our IConnectionPoint is really implemented by defview's CFolder's connection point.
  610. // We just need to keep a count of outstanding references so we can force Unadvise
  611. // calls during "implicit unadvise during shutdown" cases like Trident.
  612. // (Is this really the spec?  It doesn't sound very robust...)
  613. //
  614. HRESULT CWebViewFolderContents::CConnectionPointForwarder::QueryInterface(REFIID riid, void **ppvObj)
  615. {
  616.     static const QITAB qit[] = {
  617.         QITABENT(CConnectionPointForwarder, IConnectionPoint),                  // IID_IConnectionPoint
  618.         { 0 }
  619.     };
  620.     return QISearch(this, qit, riid, ppvObj);
  621. }
  623. STDMETHODIMP_(ULONG) CWebViewFolderContents::CConnectionPointForwarder::AddRef(void)
  624. {
  625.     return _punkParent->AddRef();
  626. }
  627. STDMETHODIMP_(ULONG) CWebViewFolderContents::CConnectionPointForwarder::Release(void)
  628. {
  629.     return _punkParent->Release();
  630. }
  631.         
  632. HRESULT CWebViewFolderContents::CConnectionPointForwarder::GetConnectionInterface(IID * pIID)
  633. {
  634.     HRESULT hr = _pcpAuto->GetConnectionInterface(pIID);
  635.     if (SUCCEEDED(hr))
  636.     {
  637.         ASSERT(IsEqualIID(*pIID, DIID_DShellFolderViewEvents));
  638.     }
  639.     return hr;
  640. }
  642. HRESULT CWebViewFolderContents::CConnectionPointForwarder::GetConnectionPointContainer(IConnectionPointContainer ** ppCPC)
  643. {
  644.     return _punkParent->QueryInterface(IID_IConnectionPointContainer, (void**)ppCPC);
  645. }
  647. HRESULT CWebViewFolderContents::CConnectionPointForwarder::Advise(IUnknown * pUnkSink, DWORD * pdwCookie)
  648. {
  649.     if (!_dsaCookies)
  650.     {
  651.         _dsaCookies = DSA_Create(sizeof(*pdwCookie), 4);
  652.         if (!_dsaCookies)
  653.         {
  654.             *pdwCookie = 0;
  655.             return E_OUTOFMEMORY;
  656.         }
  657.     }
  659.     HRESULT hr = _pcpAuto->Advise(pUnkSink, pdwCookie);
  661.     if (SUCCEEDED(hr))
  662.     {
  663.         if (-1 == DSA_AppendItem(_dsaCookies, pdwCookie))
  664.         {
  665.             _pcpAuto->Unadvise(*pdwCookie);
  666.             *pdwCookie = 0;
  667.             hr = E_OUTOFMEMORY;
  668.         }
  669.     }
  671.     return hr;
  672. }
  674. HRESULT CWebViewFolderContents::CConnectionPointForwarder::Unadvise(DWORD dwCookie)
  675. {
  676.     int i = 0;
  677.     DWORD dw;
  679.     if (_dsaCookies)
  680.     {
  681.         while (DSA_GetItem(_dsaCookies, i++, &dw))
  682.         {
  683.             if (dw == dwCookie)
  684.             {
  685.                 DSA_DeleteItem(_dsaCookies, --i);
  686.                 return _pcpAuto->Unadvise(dwCookie);
  687.             }
  688.         }
  689.     }
  691.     // BUGBUG: we should probably shassert here
  692.     return E_FAIL;
  693. }
  695. void CWebViewFolderContents::_UnadviseAll()
  696. {
  697.     if (m_cpEvents._dsaCookies)
  698.     {
  699.         if (m_cpEvents._pcpAuto)
  700.         {
  701.             DWORD dw;
  702.             for (int i = 0; DSA_GetItem(m_cpEvents._dsaCookies, i, &dw); i++)
  703.             {
  704.                 m_cpEvents._pcpAuto->Unadvise(dw);
  705.             }
  706.         }
  707.         DSA_Destroy(m_cpEvents._dsaCookies);
  708.         m_cpEvents._dsaCookies = NULL;
  709.     }
  710. }
  712. HRESULT CWebViewFolderContents::Close(DWORD dwSaveOption)
  713. {
  714.     _UnadviseAll();
  715.     HRESULT hr = IOleObjectImpl<CWebViewFolderContents>::Close(dwSaveOption);
  716.     _ReleaseAutomationForwarders();
  717.     return hr;
  718. }
  720. HRESULT CWebViewFolderContents::_SetupAutomationForwarders(void)
  721. {
  722.     HRESULT hr = S_OK;
  723.     if (!m_cpEvents._pcpAuto)
  724.     {
  725.         IShellView *psv;
  726.         hr = IUnknown_QueryService(m_spClientSite, SID_DefView, IID_IShellView, (void **)&psv);
  727.         if (SUCCEEDED(hr))
  728.         {
  729.             IUnknown *punk;
  730.             hr = psv->GetItemObject(SVGIO_BACKGROUND, IID_IDispatch, (void**)&punk);
  731.             if (SUCCEEDED(hr))
  732.             {
  733.                 hr = punk->QueryInterface(IID_IShellFolderViewDual, (void**)&_pdispAuto);
  734.                 if (SUCCEEDED(hr))
  735.                 {
  736.                     if (SUCCEEDED(MakeSafeForScripting((IUnknown**)&_pdispAuto)))
  737.                     {
  738.                         IUnknown_SetSite(_pdispAuto, m_spClientSite);
  740.                         // Need to get the right interfaces
  741.                         IConnectionPointContainer* pcpcAuto;
  742.                         hr = _pdispAuto->QueryInterface(IID_IConnectionPointContainer, (void**)&pcpcAuto);
  743.                         if (SUCCEEDED(hr))
  744.                         {
  745.                             hr = pcpcAuto->FindConnectionPoint(IID_IDispatch, &m_cpEvents._pcpAuto);
  746.                             pcpcAuto->Release();
  747.                         }
  749.                         if (FAILED(hr))
  750.                         {
  751.                             IUnknown_SetSite(_pdispAuto, NULL);
  752.                             ATOMICRELEASE(_pdispAuto);
  753.                         }
  754.                     }
  755.                 }
  756.                 punk->Release();
  757.             }
  758.             psv->Release();
  759.         }
  760.     }
  761.     return hr;
  762. }
  764. HRESULT CWebViewFolderContents::_ReleaseAutomationForwarders(void)
  765. {
  766.     ATOMICRELEASE(m_cpEvents._pcpAuto);
  767.     if (_pdispAuto)
  768.         IUnknown_SetSite(_pdispAuto, NULL);
  770.     ATOMICRELEASE(_pdispAuto);
  771.     return S_OK;
  772. }
  774. // IShellFolderViewDual
  776. // We will let the folder object get created and have it maintain that we only have one
  777. // application object (with the site) set properly...
  779. HRESULT CWebViewFolderContents::get_Application(IDispatch **ppid)
  780. {
  781.     *ppid = NULL;
  782.     HRESULT hr = _SetupAutomationForwarders();
  783.     if (SUCCEEDED(hr))
  784.         hr = _pdispAuto->get_Application(ppid);
  785.     return hr;
  786. }
  788. HRESULT CWebViewFolderContents::get_Parent(IDispatch **ppid)
  789. {
  790.     *ppid = NULL;
  791.     HRESULT hr = _SetupAutomationForwarders();
  792.     if (SUCCEEDED(hr))
  793.         hr = _pdispAuto->get_Parent(ppid);
  794.     return hr;
  795. }
  797. HRESULT CWebViewFolderContents::get_Folder(Folder **ppid)
  798. {
  799.     *ppid = NULL;
  800.     HRESULT hr = _SetupAutomationForwarders();
  801.     if (SUCCEEDED(hr))
  802.         hr = _pdispAuto->get_Folder(ppid);
  803.     return hr;
  804. }
  806. HRESULT CWebViewFolderContents::SelectedItems(FolderItems **ppid)
  807. {
  808.     // We need to talk to the actual window under us
  809.     *ppid = NULL;
  810.     HRESULT hr = _SetupAutomationForwarders();
  811.     if (SUCCEEDED(hr))
  812.         hr = _pdispAuto->SelectedItems(ppid);
  813.     return hr;
  814. }
  816. HRESULT CWebViewFolderContents::get_FocusedItem(FolderItem **ppid)
  817. {
  818.     *ppid = NULL;
  819.     HRESULT hr = _SetupAutomationForwarders();
  820.     if (SUCCEEDED(hr))
  821.         hr = _pdispAuto->get_FocusedItem(ppid);
  822.     return hr;
  823. }
  825. HRESULT CWebViewFolderContents::SelectItem(VARIANT *pvfi, int dwFlags)
  826. {
  827.     HRESULT hr = _SetupAutomationForwarders();
  828.     if (SUCCEEDED(hr))
  829.         hr = _pdispAuto->SelectItem(pvfi, dwFlags);
  830.     return hr;
  831. }
  833. HRESULT CWebViewFolderContents::PopupItemMenu(FolderItem *pfi, VARIANT vx, VARIANT vy, BSTR * pbs)
  834. {
  835.     HRESULT hr = _SetupAutomationForwarders();
  836.     if (SUCCEEDED(hr))
  837.         hr = _pdispAuto->PopupItemMenu(pfi, vx, vy, pbs);
  838.     return hr;
  839. }
  841. HRESULT CWebViewFolderContents::get_Script(IDispatch **ppid)
  842. {
  843.     *ppid = NULL;
  844.     HRESULT hr = _SetupAutomationForwarders();
  845.     if (SUCCEEDED(hr))
  846.         hr = _pdispAuto->get_Script(ppid);
  847.     return hr;
  848. }
  850. HRESULT CWebViewFolderContents::get_ViewOptions(long *plSetting)
  851. {
  852.     HRESULT hr = _SetupAutomationForwarders();
  853.     if (SUCCEEDED(hr))
  854.         hr = _pdispAuto->get_ViewOptions(plSetting);
  855.     return hr;
  856. }
  859. STDAPI CWebViewFolderContents_CreateInstance(IUnknown *punkOuter, REFIID riid, void **ppvOut)
  860. {
  861.     return CComCreator< CComPolyObject< CWebViewFolderContents > >::CreateInstance((void *) punkOuter, riid, ppvOut);
  862. }