home *** CD-ROM | disk | FTP | other *** search
/ PC Format (South-Africa) 2001 May / PCFMay2001.iso / Xenon / C++ / FreeCommandLineTools.exe / Include / dxatlpb.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-31  |  11.1 KB  |  408 lines
  1. #ifndef dxatlpb_h
  2. #pragma option push -b -a8 -pc -A- /*P_O_Push*/
  3. #define dxatlpb_h
  4.  
  5. #include <atlctl.h>
  6.  
  7. #ifndef DXTDbg_h
  8. #include <dxtdbg.h>
  9. #endif
  10.  
  11. #define COM_INTERFACE_ENTRY_DXIMPL(x)\
  12.     COM_INTERFACE_ENTRY_IID(IID_##x, x##DXImpl<_ComMapClass>)
  13.  
  14. /*** IOleObjectDXImpl
  15. *   This is a simplified version used to allow a transform
  16. *   to be hosted by IE
  17. */
  18. template <class T>
  19. class ATL_NO_VTABLE IOleObjectDXImpl
  20. {
  21.   public:
  22.     // IUnknown
  23.     //
  24.     STDMETHOD(QueryInterface)(REFIID riid, void ** ppvObject) = 0;
  25.         STDMETHOD_(ULONG,AddRef)() = 0;
  26.         STDMETHOD_(ULONG,Release)() = 0;
  27.  
  28.     // IOleObject
  29.     //
  30.     STDMETHOD(SetClientSite)(IOleClientSite *pClientSite)
  31.     {
  32.         DXTDBG_FUNC( "IOleObjectDXImpl::SetClientSite" );
  33.         HRESULT hr = S_OK;
  34.         if( pClientSite && DXIsBadInterfacePtr( pClientSite ) )
  35.         {
  36.             hr = E_INVALIDARG;
  37.         }
  38.         else
  39.         {
  40.             T* pT = static_cast<T*>(this);
  41.             pT->m_cpOleClientSite = pClientSite;
  42.         }
  43.         return hr;
  44.     }
  45.  
  46.     STDMETHOD(GetClientSite)(IOleClientSite **ppClientSite)
  47.     {
  48.         DXTDBG_FUNC( "IOleObjectDXImpl::GetClientSite" );
  49.         HRESULT hr = S_OK;
  50.         if( DXIsBadWritePtr( ppClientSite, sizeof( *ppClientSite )) )
  51.         {
  52.             hr = E_POINTER;
  53.         }
  54.         else
  55.         {
  56.             T* pT = static_cast<T*>(this);
  57.             *ppClientSite = pT->m_cpOleClientSite;
  58.         }
  59.         return hr;
  60.     }
  61.  
  62.     STDMETHOD(SetHostNames)(LPCOLESTR /* szContainerApp */, LPCOLESTR /* szContainerObj */)
  63.     {
  64.         DXTDBG_FUNC( "IOleObjectDXImpl::SetHostNames" );
  65.         return S_OK;
  66.     }
  67.     STDMETHOD(Close)(DWORD dwSaveOption)
  68.     {
  69.         DXTDBG_FUNC( "IOleObjectDXImpl::Close" );
  70.         return S_OK;
  71.     }
  72.     STDMETHOD(SetMoniker)(DWORD /* dwWhichMoniker */, IMoniker* /* pmk */)
  73.     {
  74.         DXTDBG_FUNC( "IOleObjectDXImpl::SetMoniker" );
  75.         return E_NOTIMPL;
  76.     }
  77.     STDMETHOD(GetMoniker)(DWORD /* dwAssign */, DWORD /* dwWhichMoniker */, IMoniker** /* ppmk */)
  78.     {
  79.         DXTDBG_FUNC( "IOleObjectDXImpl::GetMoniker" );
  80.         return E_NOTIMPL;
  81.     }
  82.     STDMETHOD(InitFromData)(IDataObject* /* pDataObject */, BOOL /* fCreation */, DWORD /* dwReserved */)
  83.     {
  84.         DXTDBG_FUNC( "IOleObjectDXImpl::InitFromData" );
  85.         return E_NOTIMPL;
  86.     }
  87.     STDMETHOD(GetClipboardData)(DWORD /* dwReserved */, IDataObject** /* ppDataObject */)
  88.     {
  89.         DXTDBG_FUNC( "IOleObjectDXImpl::GetClipboardData" );
  90.         return E_NOTIMPL;
  91.     }
  92.  
  93.     STDMETHOD(DoVerb)(LONG iVerb, LPMSG /* lpmsg */, IOleClientSite* /* pActiveSite */, LONG /* lindex */,
  94.                                      HWND hwndParent, LPCRECT lprcPosRect)
  95.     {
  96.         DXTDBG_FUNC( "IOleObjectDXImpl::DoVerb" );
  97.         return S_OK;
  98.     }
  99.     STDMETHOD(EnumVerbs)(IEnumOLEVERB **ppEnumOleVerb)
  100.     {
  101.         DXTDBG_FUNC( "IOleObjectDXImpl::DoVerb" );
  102.         return OLEOBJ_E_NOVERBS;
  103.     }
  104.     STDMETHOD(Update)(void)
  105.     {
  106.         DXTDBG_FUNC( "IOleObjectDXImpl::Update" );
  107.         return S_OK;
  108.     }
  109.     STDMETHOD(IsUpToDate)(void)
  110.     {
  111.         DXTDBG_FUNC( "IOleObjectDXImpl::IsUpToDate" );
  112.         return S_OK;
  113.     }
  114.     STDMETHOD(GetUserClassID)(CLSID *pClsid)
  115.     {
  116.         DXTDBG_FUNC( "IOleObjectDXImpl::GetUserClassID" );
  117.         _ASSERTE(pClsid);
  118.         if( DXIsBadWritePtr( pClsid, sizeof( *pClsid ) ) )
  119.         {
  120.             return E_POINTER;
  121.         }
  122.         else
  123.         {
  124.             *pClsid = T::GetObjectCLSID();
  125.             return S_OK;
  126.         }
  127.     }
  128.     STDMETHOD(GetUserType)(DWORD dwFormOfType, LPOLESTR *pszUserType)
  129.     {
  130.         DXTDBG_FUNC( "IOleObjectDXImpl::GetUserType" );
  131.         return OLE_S_USEREG;
  132.     }
  133.     STDMETHOD(SetExtent)(DWORD dwDrawAspect, SIZEL *psizel)
  134.     {
  135.         DXTDBG_FUNC( "IOleObjectDXImpl::SetExtent" );
  136.         return S_OK;
  137.     }
  138.     STDMETHOD(GetExtent)(DWORD dwDrawAspect, SIZEL *psizel)
  139.     {
  140.         DXTDBG_FUNC( "IOleObjectDXImpl::GetExtent" );
  141.         HRESULT hr = S_OK;
  142.         if( DXIsBadWritePtr( psizel, sizeof( *psizel ) ) )
  143.         {
  144.             hr = E_POINTER;
  145.         }
  146.         else
  147.         {
  148.             psizel->cx = 0;
  149.             psizel->cy = 0;
  150.         }
  151.         return hr;
  152.     }
  153.     STDMETHOD(Advise)(IAdviseSink *pAdvSink, DWORD *pdwConnection)
  154.     {
  155.         DXTDBG_FUNC( "IOleObjectDXImpl::Advise" );
  156.         return S_OK;
  157.     }
  158.     STDMETHOD(Unadvise)(DWORD dwConnection)
  159.     {
  160.         DXTDBG_FUNC( "IOleObjectDXImpl::Unadvise" );
  161.         return S_OK;
  162.     }
  163.     STDMETHOD(EnumAdvise)(IEnumSTATDATA **ppenumAdvise)
  164.     {
  165.         DXTDBG_FUNC( "IOleObjectDXImpl::EnumAdvise" );
  166.         return E_FAIL;
  167.     }
  168.     STDMETHOD(GetMiscStatus)(DWORD dwAspect, DWORD *pdwStatus)
  169.     {
  170.         DXTDBG_FUNC( "IOleObjectDXImpl::GetMiscStatus" );
  171.         return OLE_S_USEREG;
  172.     }
  173.     STDMETHOD(SetColorScheme)(LOGPALETTE* /* pLogpal */)
  174.     {
  175.         DXTDBG_FUNC( "IOleObjectDXImpl::SetColorScheme" );
  176.         return E_NOTIMPL;
  177.     }
  178. };
  179.  
  180. /*** CComPropBase
  181. *
  182. */
  183. class ATL_NO_VTABLE CComPropBase
  184. {
  185. public:
  186.     HRESULT IPersistPropertyBag_Load(LPPROPERTYBAG pPropBag,
  187.         LPERRORLOG pErrorLog, ATL_PROPMAP_ENTRY* pMap)
  188.     {
  189.         USES_CONVERSION;
  190.         CComPtr<IDispatch> pDispatch;
  191.         const IID* piidOld = NULL;
  192.         for(int i = 0; pMap[i].pclsidPropPage != NULL; i++)
  193.         {
  194.             if (pMap[i].szDesc == NULL)
  195.                 continue;
  196.             CComVariant var;
  197.  
  198.             if(pMap[i].piidDispatch != piidOld)
  199.             {
  200.                 pDispatch.Release();
  201.                 if(FAILED(PropQueryInterface(*pMap[i].piidDispatch, (void**)&pDispatch)))
  202.                 {
  203.                     ATLTRACE(_T("Failed to get a dispatch pointer for property #%i\n"), i);
  204.                     return E_FAIL;
  205.                 }
  206.                 piidOld = pMap[i].piidDispatch;
  207.             }
  208.  
  209.             if (FAILED(CComDispatchDriver::GetProperty(pDispatch, pMap[i].dispid, &var)))
  210.             {
  211.                 ATLTRACE(_T("Invoked failed on DISPID %x\n"), pMap[i].dispid);
  212.                 return E_FAIL;
  213.             }
  214.  
  215.             HRESULT hr = pPropBag->Read(pMap[i].szDesc, &var, pErrorLog);
  216.             if (FAILED(hr))
  217.             {
  218.                 if (hr == E_INVALIDARG)
  219.                 {
  220.                     ATLTRACE(_T("Property %s not in Bag\n"), OLE2CT(pMap[i].szDesc));
  221.                 }
  222.                 else
  223.                 {
  224.                     // Many containers return different ERROR values for Member not found
  225.                     ATLTRACE(_T("Error attempting to read Property %s from PropertyBag \n"), OLE2CT(pMap[i].szDesc));
  226.                 }
  227.                 continue;
  228.             }
  229.  
  230.             if (FAILED(CComDispatchDriver::PutProperty(pDispatch, pMap[i].dispid, &var)))
  231.             {
  232.                 ATLTRACE(_T("Invoked failed on DISPID %x\n"), pMap[i].dispid);
  233.                 return E_FAIL;
  234.             }
  235.         }
  236.         return S_OK;
  237.  
  238.     }
  239.  
  240.     HRESULT IPersistPropertyBag_Save(LPPROPERTYBAG pPropBag,
  241.         BOOL fClearDirty, BOOL /*fSaveAllProperties*/, ATL_PROPMAP_ENTRY* pMap)
  242.     {
  243.         if (pPropBag == NULL)
  244.         {
  245.             ATLTRACE(_T("PropBag pointer passed in was invalid\n"));
  246.             return E_POINTER;
  247.         }
  248.  
  249.         CComPtr<IDispatch> pDispatch;
  250.         const IID* piidOld = NULL;
  251.         for(int i = 0; pMap[i].pclsidPropPage != NULL; i++)
  252.         {
  253.             if (pMap[i].szDesc == NULL)
  254.                 continue;
  255.             CComVariant var;
  256.  
  257.             if(pMap[i].piidDispatch != piidOld)
  258.             {
  259.                 pDispatch.Release();
  260.                 if(FAILED(PropQueryInterface(*pMap[i].piidDispatch, (void**)&pDispatch)))
  261.                 {
  262.                     ATLTRACE(_T("Failed to get a dispatch pointer for property #%i\n"), i);
  263.                     return E_FAIL;
  264.                 }
  265.                 piidOld = pMap[i].piidDispatch;
  266.             }
  267.  
  268.             if (FAILED(CComDispatchDriver::GetProperty(pDispatch, pMap[i].dispid, &var)))
  269.             {
  270.                 ATLTRACE(_T("Invoked failed on DISPID %x\n"), pMap[i].dispid);
  271.                 return E_FAIL;
  272.             }
  273.  
  274.             if (var.vt == VT_UNKNOWN || var.vt == VT_DISPATCH)
  275.             {
  276.                 if (var.punkVal == NULL)
  277.                 {
  278.                     ATLTRACE(_T("Warning skipping empty IUnknown in Save\n"));
  279.                     continue;
  280.                 }
  281.             }
  282.  
  283.             HRESULT hr = pPropBag->Write(pMap[i].szDesc, &var);
  284.             if (FAILED(hr))
  285.                 return hr;
  286.         }
  287.         m_bRequiresSave = FALSE;
  288.         return S_OK;
  289.     }
  290.  
  291.     HRESULT ISpecifyPropertyPages_GetPages(CAUUID* pPages,
  292.         ATL_PROPMAP_ENTRY* pMap)
  293.     {
  294.         _ASSERTE(pMap != NULL);
  295.         int nCnt = 0;
  296.         // Get count of unique pages
  297.         for(int i = 0; pMap[i].pclsidPropPage != NULL; i++)
  298.         {
  299.             if (!InlineIsEqualGUID(*pMap[i].pclsidPropPage, CLSID_NULL))
  300.                 nCnt++;
  301.         }
  302.         pPages->pElems = NULL;
  303.         pPages->pElems = (GUID*) CoTaskMemAlloc(sizeof(CLSID)*nCnt);
  304.         if (pPages->pElems == NULL)
  305.             return E_OUTOFMEMORY;
  306.         nCnt = 0;
  307.         for(i = 0; pMap[i].pclsidPropPage != NULL; i++)
  308.         {
  309.             if (!InlineIsEqualGUID(*pMap[i].pclsidPropPage, CLSID_NULL))
  310.             {
  311.                 BOOL bMatch = FALSE;
  312.                 for (int j=0;j<nCnt;j++)
  313.                 {
  314.                     if (InlineIsEqualGUID(*(pMap[i].pclsidPropPage), pPages->pElems[j]))
  315.                     {
  316.                         bMatch = TRUE;
  317.                         break;
  318.                     }
  319.                 }
  320.                 if (!bMatch)
  321.                     pPages->pElems[nCnt++] = *pMap[i].pclsidPropPage;
  322.             }
  323.         }
  324.         pPages->cElems = nCnt;
  325.         return S_OK;
  326.     }
  327.     virtual HRESULT PropQueryInterface(const IID& iid, void** ppv) = 0;
  328.     BOOL m_bRequiresSave;
  329. };
  330.  
  331.  
  332. template <class T>
  333. class ATL_NO_VTABLE CComPropertySupport :  public CComPropBase
  334. {
  335. public:
  336.     virtual HRESULT PropQueryInterface(const IID& iid, void** ppv)
  337.     {
  338.         T* pT = static_cast<T*>(this);
  339.     return pT->_InternalQueryInterface(iid, ppv);
  340.     }
  341. };
  342.  
  343.  
  344. //////////////////////////////////////////////////////////////////////////////
  345. // IObjectSafety
  346. //
  347.  
  348. template <class T> 
  349. class ATL_NO_VTABLE IObjectSafetyImpl2
  350. {
  351. public:
  352.         DWORD m_dwSafety[4];
  353.         const IID *m_pIID[4];
  354.  
  355.         IObjectSafetyImpl2()
  356.     {
  357.             m_pIID[0] = &IID_IDispatch;
  358.             m_pIID[1] = &IID_IPersistPropertyBag;
  359.             m_pIID[2] = &IID_IPersistStorage;
  360.             m_pIID[3] = &IID_IPersistStream;
  361.             for (int i = 0; i < 4; i++)
  362.             {
  363.         m_dwSafety[i] = 0;
  364.             }
  365.     }
  366.  
  367.     // IUnknown
  368.     //
  369.     STDMETHOD(QueryInterface)(REFIID riid, void ** ppvObject) = 0;
  370.     _ATL_DEBUG_ADDREF_RELEASE_IMPL(IObjectSafetyImpl2)
  371.  
  372.     // IObjectSafety
  373.     //
  374.     STDMETHOD(GetInterfaceSafetyOptions)(REFIID riid, DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions)
  375.     {
  376.         ATLTRACE(_T("IObjectSafetyImpl::GetInterfaceSafetyOptions\n"));
  377.         if (pdwSupportedOptions == NULL || pdwEnabledOptions == NULL)
  378.             return E_POINTER;
  379.                 for (int i = 0; i < 4 && m_pIID[i]; i++)
  380.                 {
  381.                     if (riid == *m_pIID[i]) {
  382.             *pdwSupportedOptions = INTERFACESAFE_FOR_UNTRUSTED_CALLER;
  383.             *pdwEnabledOptions = m_dwSafety[i] & INTERFACESAFE_FOR_UNTRUSTED_CALLER;
  384.                         return S_OK;
  385.                     }
  386.         }
  387.                 *pdwSupportedOptions = 0;
  388.         *pdwEnabledOptions = 0;
  389.         return E_NOINTERFACE;
  390.     }
  391.     STDMETHOD(SetInterfaceSafetyOptions)(REFIID riid, DWORD dwOptionSetMask, DWORD dwEnabledOptions)
  392.     {
  393.         ATLTRACE(_T("IObjectSafetyImpl::SetInterfaceSafetyOptions\n"));
  394.         // If we're being asked to set our safe for scripting option then oblige
  395.                 for (int i = 0; i < 4 && m_pIID[i]; i++)
  396.                 {
  397.                     if (riid == *m_pIID[i]) {
  398.             m_dwSafety[i] = dwEnabledOptions & dwOptionSetMask;
  399.                         return S_OK;
  400.                     }
  401.         }
  402.         return E_NOINTERFACE;
  403.     }
  404.  
  405. };
  406.  
  407. #pragma option pop /*P_O_Pop*/
  408. #endif // This must be the last line in the file