cOleControl.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cOleControl_H
#define _INC_cOleControl_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "../WinAPI/WinTypes.h"
 
#if defined(_WIN32) && defined(_MSC_VER)
#include "../Windows/cWindow.h"
#include "../WinAPI/cWinVariant.h"
#include "../Geometry/cRectI.h"
#include "../Input/cInputBase.h"                // VK_ESCAPE
#include "GrayCore/include/cIUnkPtr.h"
#include "GrayCore/include/cThreadLock.h"
#include "GrayCore/include/cOSModule.h"
 
#include <DocObj.h>     // IOleCommandTarget
#include <mshtmhst.h>   // Defines of stuff like IDocHostUIHandler. This is an include file with Visual C 6 and above
 
//MIDL_INTERFACE("00000112-0000-0000-C000-000000000046") IOleObject;            // related to USE_DX_SHOW
//MIDL_INTERFACE("3AF24292-0C96-11CE-A0CF-00AA00600AB8") IViewObjectEx;
//MIDL_INTERFACE("D30C1661-CDAF-11d0-8A3E-00C04FC9E26E") IWebBrowser2;
 
#ifdef USE_DX9          // IDirect3DSurface9
MIDL_INTERFACE("0CFBAF3A-9FF6-429a-99B3-A2796AF8B89B") IDirect3DSurface9;       // USE_DX9 <d3d9.h>
#endif
 
enum tagREADYSTATE;
 
// #define USE_DRAW_RECTDIRTY   // try to track dirty parts of the window for optimized drawing.
 
namespace GrayLib
{
        class cOleWebBrowserRedir;
        class cOleControl;
        class cOleClientSite;
 
        enum OLE_WINDOW_TYPE
        {
 
                OLE_WINDOW_Unknown = 0,
                OLE_WINDOW_Less,        
                OLE_WINDOW_Proxy,       
                OLE_WINDOW_Child,       
                OLE_WINDOW_Popup,       
        };
 
        class GRAYLIB_LINK cOleWindowBase
                : public cRefBase
        {
 
        protected:
                cOleControl* m_pParentControl;          
                MSG m_MsgLast;                  
 
                cRectI m_rectDirty;             
 
        public:
                cOleWindowBase(cOleControl* pParentControl)
                        : m_pParentControl(pParentControl)
                {
                        ASSERT(!isDisposed());
                        cMem::Zero(&m_MsgLast, sizeof(m_MsgLast));
                        ASSERT(m_rectDirty.isRectNull());
                }
 
                bool isDisposed() const noexcept
                {
                        return m_pParentControl == nullptr;
                }
                virtual void DisposeThis()
                {
                        m_pParentControl = nullptr;
                }
 
                bool isRectDirty() const
                {
                        return(!m_rectDirty.IsRectEmpty());
                }
                const cRectI& get_RectDirty() const
                {
                        return m_rectDirty;
                }
                void addRectDirty(const RECT* pRect = nullptr);
 
                virtual HRESULT InitInstance() = 0;
                virtual bool CheckRectDirty()
                {
                        return isRectDirty();
                }
                virtual HRESULT DrawControl(HDC hDC, DWORD dwDrawAspect) = 0;
                virtual LRESULT OnWindowMessage1(MSG& sMsg);
        };
 
        class GRAYLIB_LINK cOleControl
                : public cRefBase
        {
 
                friend class cOleWindowless;
                friend class cOleWindowProxy;
                friend class cOleClientSite; 
 
        public:
                cIUnkPtr<IOleObject> m_pOleObject;      
 
                HWND m_hWndParent;                                      
                const INT_PTR m_nChildId;                       
                cRectI m_rectClient;                            
 
        protected:
                cOSModule m_OleLib;                     
                THREADID_t m_nThreadIdCreated;  
 
                // Interfaces derived from m_pOleObject
                cIUnkPtr<IOleInPlaceObject> m_pInPlaceObject;   
                cIUnkPtr<IViewObjectEx> m_pViewObject;                  
                DWORD m_uViewStatus;            
 
                OLE_WINDOW_TYPE m_eWindowType;                                  
                cWindow m_wndFrame;                                                             
                cRefPtr<cOleWindowBase> m_pOleWindowBase;               
                cRefPtr<cOleClientSite> m_pOleClientSite;               
 
                cOleWebBrowserRedir* m_pWebBrowserRedir;        
                OLE_WINDOW_TYPE m_eDesireWindowType;            
                bool m_bDesireTransparent;                                      
 
        private:
                cStringA m_sName; 
 
        protected:
                cOleControl(INT_PTR nChildId, cOleWebBrowserRedir* pBrowserRedir);
                virtual ~cOleControl();
 
                HRESULT ActivateOleControl();
                HRESULT LoadOleControl(const GUID& rguid, const FILECHAR_t* pszDllName);
                HRESULT CreateWindowFrame(const GChar_t* pszClassName, const GChar_t* pszFullPath);
 
                cOleWindowless* get_OleWindowless() const;
                cOleWindowProxy* get_OleWindowProxy() const;
 
                HRESULT ReturnError(HRESULT hRes) const;
 
        public:
                virtual HRESULT InitOleControl(OLE_WINDOW_TYPE eDesireWindowType, bool bDesireTransparent = false) = 0;
                virtual HRESULT LoadOleContent(const FILECHAR_t* pszFullPath) = 0;
 
                virtual bool isDisposed() const = 0;
                virtual void DisposeThis();
 
                cStringA get_Name() const
                {
                        return m_sName;
                }
                virtual void put_Name(const char* pszName);
                void put_Name(BSTR bsName);
                void put_Name(VARIANT* pvName);
 
                HWND get_WndParent() const
                {
                        return m_hWndParent;
                }
                void put_WndParent(HWND hWndParent);
 
                HWND get_WndFrame() const;
 
                const cRectI& get_Rect() const
                {
                        return m_rectClient;
                }
                HRESULT SetRect(const cRectI& rectNew, int iForceChange=0);
                HRESULT put_Rect(const cRectI& rectNew)
                {
                        return SetRect(rectNew, 1);
                }
 
                bool CheckRectDirty();
                HRESULT TestViewStatus();
 
                virtual tagREADYSTATE get_ReadyState() const;
                HRESULT WaitForReadyState(TIMESYSD_t nTimeMax, bool bMsgLoop, int eReadyStateMin);
 
                virtual HRESULT DrawControl(HDC hDC, DWORD dwDrawAspect = DVASPECT_CONTENT);
 
#ifdef USE_DX9
                virtual HRESULT DrawControl(IDirect3DSurface9* pSurface);
#endif
 
                virtual LRESULT OnWindowMessage1(MSG& msg);
                LRESULT OnWindowMessage(HWND hWndSrc, WINMSG_t msg, WPARAM wParam, LPARAM lParam);
 
                bool isMouseHit(const POINT& pt) const;
                virtual void OnMouseMove(MBUTTON_TYPE button, const POINT& pt);
 
                bool isCreationThread() const
                {
                        if (m_nThreadIdCreated == cThreadId::k_NULL)
                                return true;
                        if (m_nThreadIdCreated == cThreadId::GetCurrentId())
                                return true;
                        return false;
                }
        };
 
        typedef cRefPtr<cOleControl> cOleControlPtr;
}
#endif
#endif