//+---------------------------------------------------------------------------- // // File: ctr.h // // Module: CMDIAL32.DLL // // Synopsis: Header for the Ole Container object to host the future splash // Animation control. // // Copyright (c) 1998 Microsoft Corporation // // Author: nickball Created 02/10/98 // //+---------------------------------------------------------------------------- #ifndef __CTR_H_DEFINED__ #define __CTR_H_DEFINED__ #include "state.h" // // Typedefs for OLE32 APIs // typedef HRESULT (STDAPICALLTYPE *pfnOle32Initialize)(LPVOID); typedef HRESULT (STDAPICALLTYPE *pfnOle32Uninitialize)(); typedef HRESULT (STDAPICALLTYPE *pfnOle32SetContainedObject) (LPUNKNOWN, BOOL); typedef HRESULT (STDAPICALLTYPE *pfnOle32CoCreateInstance) (REFCLSID, LPUNKNOWN, DWORD, REFIID, LPVOID *); typedef struct _Ole32LinkageStruct { HINSTANCE hInstOle32; union { struct { pfnOle32Initialize pfnOleInitialize; pfnOle32Uninitialize pfnOleUninitialize; pfnOle32SetContainedObject pfnOleSetContainedObject; pfnOle32CoCreateInstance pfnCoCreateInstance; }; void *apvPfnOle32[5]; }; } Ole32LinkageStruct; // // Typedefs for OLEAUT32 APIs // typedef HRESULT (STDAPICALLTYPE *pfnOleAutVariantClear) (VARIANTARG FAR*); typedef HRESULT (STDAPICALLTYPE *pfnOleAutVariantCopy) (VARIANTARG FAR*, VARIANTARG FAR*); typedef VOID (STDAPICALLTYPE *pfnOleAutVariantInit) (VARIANTARG FAR*); typedef HRESULT (STDAPICALLTYPE *pfnOleAutVariantChangeType) (VARIANTARG FAR*, VARIANTARG FAR*, unsigned short, VARTYPE); typedef BSTR (STDAPICALLTYPE *pfnOleAutSysAllocString) (OLECHAR FAR*); typedef VOID (STDAPICALLTYPE *pfnOleAutSysFreeString) (BSTR); typedef struct _OleAutLinkageStruct { HINSTANCE hInstOleAut; union { struct { pfnOleAutVariantClear pfnVariantClear; pfnOleAutVariantCopy pfnVariantCopy; pfnOleAutVariantInit pfnVariantInit; pfnOleAutVariantChangeType pfnVariantChangeType; pfnOleAutSysAllocString pfnSysAllocString; pfnOleAutSysFreeString pfnSysFreeString; }; void *apvPfnOleAut[7]; }; } OleAutLinkageStruct; // // Simple wrapper class for dynamic access to OleAut32 APIs that we care about // class CDynamicOleAut { public: CDynamicOleAut(VOID); ~CDynamicOleAut(VOID); BOOL Initialized(VOID); HRESULT DynVariantClear(VARIANTARG FAR*); HRESULT DynVariantCopy(VARIANTARG FAR*, VARIANTARG FAR*); VOID DynVariantInit(VARIANTARG FAR*); HRESULT DynVariantChangeType(VARIANTARG FAR*, VARIANTARG FAR*, unsigned short, VARTYPE); BSTR DynSysAllocString(OLECHAR FAR*); VOID DynSysFreeString(BSTR); private: OleAutLinkageStruct m_OleAutLink; }; //--------------------------------------------------------------- // IOleObject //--------------------------------------------------------------- enum OLE_SERVER_STATE { OS_PASSIVE, OS_LOADED, // handler but no server OS_RUNNING, // server running, invisible OS_INPLACE, // server running, inplace-active, no U.I. OS_UIACTIVE, // server running, inplace-active, w/ U.I. OS_OPEN // server running, open-edited }; struct BagProp { BSTR bstrName; // name of property VARIANT varValue; // value of property }; typedef BagProp FAR * LPBAGPROP; DECLARE_FORMSDATAARY(CAryBagProps, BagProp, LPBAGPROP); // prototypes for HIMETRIC stuff. // void InitPixelsPerInch(VOID); int HPixFromHimetric(long lHi); int VPixFromHimetric(long lHi); long HimetricFromHPix(int iPix); long HimetricFromVPix(int iPix); class CICMOCCtr; typedef CICMOCCtr FAR * LPICMOCCtr; //+--------------------------------------------------------------------------- // // Class: COleContainer () // // Purpose: our implementation of IOleContainer. does nothing. Not sure // if we need it for FutureSplash - needed it for Web Browser // OC // //---------------------------------------------------------------------------- class COleContainer : public IOleContainer { public: // IUnknown stuff STDMETHOD(QueryInterface)(REFIID riid, LPVOID FAR * ppv); STDMETHOD_(ULONG, AddRef)(VOID); STDMETHOD_(ULONG, Release)(VOID); STDMETHOD(EnumObjects)(DWORD grfFlags, IEnumUnknown **ppenum); STDMETHOD(LockContainer)(BOOL fLock); STDMETHOD(ParseDisplayName)( IBindCtx *pbc, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut); COleContainer(LPICMOCCtr pCtr); protected: LPICMOCCtr m_pCtr; }; //+--------------------------------------------------------------------------- // // Class: COleClientSite () // // Purpose: our implementation of IOleClientSite // // Interface: COleClientSite -- ctor // QueryInterface -- gimme an interface! // AddRef -- bump up refcount // Release -- bump down refcount // SaveObject -- returns E_FAIL // GetMoniker -- E_NOTIMPL // GetContainer -- returns our COleContainer impl // ShowObject -- just say OK // OnShowWindow -- just say OK // RequestNewObjectLayout -- E_NOTIMPL // // Notes: probably the most important thing our IOleClientSite // implementation does is hand off our IOleContainer // implementation when GetContainer() is called. // //---------------------------------------------------------------------------- class COleClientSite : public IOleClientSite { public: COleClientSite(LPICMOCCtr pCtr); // IUnknown stuff STDMETHOD(QueryInterface)(REFIID riid, LPVOID FAR * ppv); STDMETHOD_(ULONG, AddRef)(VOID); STDMETHOD_(ULONG, Release)(VOID); // IOleClientSite stuff STDMETHOD(SaveObject)(VOID); STDMETHOD(GetMoniker)( DWORD dwAssign, DWORD dwWhichMoniker, LPMONIKER FAR * ppmk); STDMETHOD(GetContainer)(LPOLECONTAINER FAR * pOleCtr); STDMETHOD(ShowObject)(VOID); STDMETHOD(OnShowWindow)(BOOL bShow); STDMETHOD(RequestNewObjectLayout)(VOID); protected: LPICMOCCtr m_pCtr; // pointer to the CICMOCCtr object. }; //+--------------------------------------------------------------------------- // // Class: CAdviseSink () // // Purpose: IAdviseSink implementation // //---------------------------------------------------------------------------- class CAdviseSink : public IAdviseSink { public: CAdviseSink(LPICMOCCtr pCtr); // IUnknown stuff STDMETHOD(QueryInterface)(REFIID riid, LPVOID FAR * ppv); STDMETHOD_(ULONG, AddRef)(VOID); STDMETHOD_(ULONG, Release)(VOID); // IAdviseSink stuff STDMETHOD_(VOID, OnDataChange)(LPFORMATETC pFE, LPSTGMEDIUM pStgMedium); STDMETHOD_(VOID, OnViewChange)(DWORD dwAspect, LONG lIndex); STDMETHOD_(VOID, OnRename)(LPMONIKER pmkNew); STDMETHOD_(VOID, OnSave)(VOID); STDMETHOD_(VOID, OnClose)(VOID); protected: LPICMOCCtr m_pCtr; // pointer to the CICMOCCtr object. LPUNKNOWN m_pUnkOuter; // pointer to CICMOCCtr's IUnknown }; //+--------------------------------------------------------------------------- // // Class: CInPlaceFrame () // // Purpose: // // Interface: CInPlaceFrame -- ctor // QueryInterface -- gimme an interface! // AddRef -- bump up refcount // Release -- decrement refcount // GetWindow -- from IOleWindow - returns frame hWnd // ContextSensitiveHelp -- never implemented by design // GetBorder -- for toolbar negotiation // RequestBorderSpace -- ditto // SetBorderSpace -- ditto // SetActiveObject -- called whenever URL changes // InsertMenus -- menu negotiation // SetMenu -- ditto // RemoveMenus -- ditto // SetStatusText -- called by OC to set status text // EnableModeless -- we have no modeless dlgs. // TranslateAccelerator -- calls ::TranslateAccelerator // //---------------------------------------------------------------------------- class CInPlaceFrame : public IOleInPlaceFrame { public: CInPlaceFrame(LPICMOCCtr pCtr); // IUnknown stuff STDMETHOD(QueryInterface)(REFIID riid, LPVOID FAR * ppv); STDMETHOD_(ULONG, AddRef)(VOID); STDMETHOD_(ULONG, Release)(VOID); // IOleWindow stuff STDMETHOD(GetWindow)(HWND * phwnd); STDMETHOD(ContextSensitiveHelp)(BOOL fEnterMode); // IOleInPlaceUIWindow stuff STDMETHOD(GetBorder)(LPRECT lprectBorder); STDMETHOD(RequestBorderSpace)(LPCBORDERWIDTHS pborderwidths); STDMETHOD(SetBorderSpace)(LPCBORDERWIDTHS pborderwidths); STDMETHOD(SetActiveObject)( IOleInPlaceActiveObject * pActiveObject, LPCOLESTR pszObjName); // IOleInPlaceFrame stuff STDMETHOD(InsertMenus)( HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths); STDMETHOD(SetMenu)( HMENU hmenuShared, HOLEMENU holemenu, HWND hwndActiveObject); STDMETHOD(RemoveMenus)(HMENU hmenuShared); STDMETHOD(SetStatusText)(LPCOLESTR pszStatusText); STDMETHOD(EnableModeless)(BOOL fEnable); STDMETHOD(TranslateAccelerator)(LPMSG lpmsg, WORD wID); protected: LPICMOCCtr m_pCtr; // pointer to the CICMOCCtr object. }; //+--------------------------------------------------------------------------- // // Class: CInPlaceSite () // // Purpose: IOleInPlaceSite implementation. // // Interface: CInPlaceSite -- ctor // QueryInterface -- get a new interface // AddRef -- bump ref count // Release -- decrement ref count // GetWindow -- returns frame window // ContextSensitiveHelp -- never implemented by design // CanInPlaceActivate -- returns S_OK. // OnInPlaceActivate -- caches IOleInPlaceObject ptr // OnUIActivate -- returns S_OK - sets state // GetWindowContext -- returns IOleInPlaceFrame, // IOleInPlaceUIWindow, // PosRect and ClipRect // Scroll -- never implemented by design. // OnUIDeactivate -- obvious // OnInPlaceDeactivate -- releases cached IOleInPlaceObject // DiscardUndoState -- returns S_OK. // DeactivateAndUndo -- deactivates in place active object // OnPosRectChange -- never implemented by design // //---------------------------------------------------------------------------- class CInPlaceSite : public IOleInPlaceSite { public: CInPlaceSite(LPICMOCCtr pCtr); // IUnknown stuff STDMETHOD(QueryInterface)(REFIID riid, LPVOID FAR * ppv); STDMETHOD_(ULONG, AddRef)(VOID); STDMETHOD_(ULONG, Release)(VOID); // IOleWindow stuff STDMETHOD(GetWindow)(HWND * phwnd); STDMETHOD(ContextSensitiveHelp)(BOOL fEnterMode); // IOleInPlaceSite stuff STDMETHOD(CanInPlaceActivate)(VOID); STDMETHOD(OnInPlaceActivate)(VOID); STDMETHOD(OnUIActivate)(VOID); STDMETHOD(GetWindowContext)( IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT prcPosRect, LPRECT prcClipRect, LPOLEINPLACEFRAMEINFO pFrameInfo); STDMETHOD(Scroll)(SIZE scrollExtant); STDMETHOD(OnUIDeactivate)(BOOL fUndoable); STDMETHOD(OnInPlaceDeactivate)(VOID); STDMETHOD(DiscardUndoState)(VOID); STDMETHOD(DeactivateAndUndo)(VOID); STDMETHOD(OnPosRectChange)(LPCRECT lprcPosRect); protected: LPICMOCCtr m_pCtr; // pointer to the CICMOCCtr object. }; class CPropertyBag : public IPropertyBag { public: CPropertyBag(LPICMOCCtr pCtr); ~CPropertyBag(VOID); // IUnknown stuff STDMETHOD(QueryInterface)(REFIID riid, LPVOID FAR * ppv); STDMETHOD_(ULONG, AddRef)(VOID); STDMETHOD_(ULONG, Release)(VOID); // IPropertyBag methods. STDMETHOD(Read)(LPCOLESTR pszName, LPVARIANT pVar, LPERRORLOG pErrorLog); STDMETHOD(Write)(LPCOLESTR pszName, LPVARIANT pVar) { return E_NOTIMPL; } HRESULT AddPropertyToBag(LPTSTR szName, LPTSTR szValue); protected: CAryBagProps m_aryBagProps; LPICMOCCtr m_pCtr; }; //+--------------------------------------------------------------------------- // // Class: CICMOCCtr () // // Purpose: This is the one, the big kahuna. CICMOCCtr is the // ICM OLE Controls container that contains a single // OLE Control, the FutureSplash OC. It contains // sub-objects which implement the various interfaces // we have to support (could have used multiple inheritance, // but this seemed more straightforward for our needs). // // Conventions: Interfaces we implement are contained objects // of a class trivially derived from the interface, // e.g., IOleInPlaceFrame is a contained // instance of CInPlaceFrame called m_IPF. // // Interfaces we hold on the Future Splash OC // are pointers to the actual OLE interface. // e.g., our pointer to the control's // IOleControl interface is m_pOC. // // The contained sub-objects are all friends // of the container - they are all conceptually // the same object, but are implemented // separately so as to cause the compiler to // generate the correct vtable. // //---------------------------------------------------------------------------- class CICMOCCtr : public IUnknown { public: friend CInPlaceSite; friend CInPlaceFrame; friend COleClientSite; friend CPropertyBag; // IUnknown stuff STDMETHOD(QueryInterface)(REFIID riid, LPVOID FAR * ppv); STDMETHOD_(ULONG, AddRef)(VOID); STDMETHOD_(ULONG, Release)(VOID); VOID Paint(HDC hDC, LPRECT lpr); VOID Paint(VOID); HRESULT CreateFSOC(Ole32LinkageStruct *pOle32Link); HRESULT GetSize(LPRECT prc); HRESULT SetSize(LPRECT prc, BOOL fMoveFrameWindow = TRUE); HWND GetMainWindow(VOID) { MYDBGASSERT(m_hWndMainDlg && ::IsWindow(m_hWndMainDlg)); return m_hWndMainDlg; } HWND GetFrameWindow(VOID) { MYDBGASSERT(m_hWndFrame && ::IsWindow(m_hWndFrame)); return m_hWndFrame; } LRESULT OnActivateApp(WPARAM wParam, LPARAM lParam); // // Whenever we display a modal dialog, we need to let // our embeddings (the WebBrowser OC) know to disable // any modeless dialogs the embedding is displaying. // VOID EnableEmbeddingModelessDlgs(BOOL fEnable) { LPOLEINPLACEACTIVEOBJECT pIPAO = GetIPAObject(); if (pIPAO) pIPAO->EnableModeless(fEnable); } VOID DoLayout(INT cxMain, INT cyMain); CICMOCCtr(const HWND hWndMainDlg, const HWND hWndFrame); ~CICMOCCtr(VOID); VOID ShutDown(VOID); BOOL Initialized(VOID); OLE_SERVER_STATE GetState(VOID) {return m_state;} VOID SetState(OLE_SERVER_STATE state) {m_state = state;} HRESULT EnableModeless(BOOL fEnable); BOOL ModelessEnabled(VOID){return m_fModelessEnabled;} LRESULT SetFocus(VOID); HRESULT AddPropertyToBag(LPTSTR szName, LPTSTR szValue) { return m_PB.AddPropertyToBag(szName, szValue); } VOID MapStateToFrame(ProgState ps); HRESULT SetFrame(LONG lFrame); VOID SetFrameMapping(ProgState ps, LONG lFrame) { m_alStateMappings[ps] = lFrame; } LPOLEINPLACEACTIVEOBJECT GetIPAObject(VOID) {return m_pActiveObj;} protected: HRESULT _SetExtent(LPRECT prc); HRESULT _DisplayStatusText(LPCOLESTR pStrStatusText); VOID _ResetToolSpace(VOID) { ::memset(&m_rcToolSpace, 0, sizeof m_rcToolSpace); } VOID _AdjustForTools(LPRECT prc); VOID _DeactivateControl(VOID); HRESULT _TransAccelerator(LPMSG lpmsg, WORD wID); VOID _GetDoVerbRect(LPRECT prc); // map states to frames. LONG m_alStateMappings[NUMSTATES]; BORDERWIDTHS m_rcToolSpace; // for FS OC COleClientSite m_CS; // clientsite CAdviseSink m_AS; // advise sink CInPlaceFrame m_IPF; // inplace frame CInPlaceSite m_IPS; // inplace site object COleContainer m_OCtr; // IOleContainer CDynamicOleAut m_DOA; // Dynamic OLEAUT32 CPropertyBag m_PB; // IPropertyBag - Must never precede CDynamicOleAut HWND m_hWndMainDlg; // hwnd for ICM dialog HWND m_hWndFrame; // hWnd that contains OC Site LPUNKNOWN m_pUnk; // the object itself. LPVIEWOBJECT m_pVO; // pointer to IViewObject LPOLEOBJECT m_pOO; // pointer to IOleObject LPOLEINPLACEOBJECT m_pIPO; // pointer to InPlaceActiveObject LPDISPATCH m_pDisp; // IDispatch to FS OC LPOLEINPLACEACTIVEOBJECT m_pActiveObj; // current active object LPOLECONTROL m_pOC; // IOleControl interface for OC ULONG m_Ref; // refcount OLE_SERVER_STATE m_state; // current OLE state of OC DWORD m_dwMiscStatus;// misc status bits for OC BOOL m_fModelessEnabled; // OC is putting up modal dlg? }; extern "C" CLSID const CLSID_FS; #endif