---

wxactivex.h

Go to the documentation of this file.

#ifndef WX_ACTIVE_X
#define WX_ACTIVE_X
#pragma warning( disable : 4101 4786)
#pragma warning( disable : 4786)


#include <wx/setup.h>
#include <wx/wx.h>
#include <wx/variant.h>
#include <wx/datetime.h>
#include <oleidl.h>
#include <exdisp.h>
#include <docobj.h>
#include <iostream>
#include <vector>
#include <map>
using namespace std;

namespace NS_wxActiveX
{
        struct less_wxStringI
        {
                bool operator()(const wxString& x, const wxString& y) const
                {
                        return x.CmpNoCase(y) < 0;
                };
        };
};


template <class I> class wxAutoOleInterface
{
        protected:
    I *m_interface;

        public:
    explicit wxAutoOleInterface(I *pInterface = NULL) : m_interface(pInterface) {}

    wxAutoOleInterface(REFIID riid, IUnknown *pUnk) : m_interface(NULL)
        {
                QueryInterface(riid, pUnk);
        };
    wxAutoOleInterface(REFIID riid, IDispatch *pDispatch) : m_interface(NULL)
        {
                QueryInterface(riid, pDispatch);
        };

        wxAutoOleInterface(REFCLSID clsid, REFIID riid) : m_interface(NULL)
        {
                CreateInstance(clsid, riid);
        };

    wxAutoOleInterface(const wxAutoOleInterface<I>& ti) : m_interface(NULL)
    {
                operator = (ti);
    }

    wxAutoOleInterface<I>& operator = (const wxAutoOleInterface<I>& ti)
    {
                if (ti.m_interface)
                        ti.m_interface->AddRef();
        Free();
        m_interface = ti.m_interface;
        return *this;
    }

    wxAutoOleInterface<I>& operator = (I *&ti)
    {
        Free();
        m_interface = ti;
        return *this;
    }

    ~wxAutoOleInterface()
    {
        Free();
    };


    inline void Free()
    {
        if (m_interface)
                m_interface->Release();
        m_interface = NULL;
    };

    HRESULT QueryInterface(REFIID riid, IUnknown *pUnk)
        {
                Free();
                wxASSERT(pUnk != NULL);
            return pUnk->QueryInterface(riid, (void **) &m_interface);
        };

    HRESULT CreateInstance(REFCLSID clsid, REFIID riid)
    {
                Free();
            return CoCreateInstance(clsid, NULL, CLSCTX_ALL, riid, (void **) &m_interface);
    };


    inline operator I *() const {return m_interface;}

    inline I* operator ->() {return m_interface;}
        inline I** GetRef()     {return &m_interface;}
        inline bool Ok() const  {return m_interface != NULL;}
};


wxString OLEHResultToString(HRESULT hr);
wxString GetIIDName(REFIID riid);

//#define __WXOLEDEBUG


#ifdef __WXOLEDEBUG
    #define WXOLE_TRACE(str) {OutputDebugString(str);OutputDebugString("\r\n");}
    #define WXOLE_TRACEOUT(stuff)\
    {\
        wxString os;\
        os << stuff << "\r\n";\
        WXOLE_TRACE(os.mb_str());\
    }

    #define WXOLE_WARN(__hr,msg)\
    {\
        if (__hr != S_OK)\
        {\
            wxString s = "*** ";\
            s += msg;\
            s += " : "+ OLEHResultToString(__hr);\
            WXOLE_TRACE(s.c_str());\
        }\
    }
#else
    #define WXOLE_TRACE(str)
    #define WXOLE_TRACEOUT(stuff)
    #define WXOLE_WARN(_proc,msg) {_proc;}
#endif

class wxOleInit
{
        public:
    static IMalloc *GetIMalloc();

    wxOleInit();
    ~wxOleInit();
};

#define DECLARE_OLE_UNKNOWN(cls)\
        private:\
    class TAutoInitInt\
    {\
        public:\
        LONG l;\
        TAutoInitInt() : l(0) {}\
    };\
    TAutoInitInt refCount, lockCount;\
    wxOleInit oleInit;\
        static void _GetInterface(cls *self, REFIID iid, void **_interface, const char *&desc);\
    public:\
    LONG GetRefCount();\
        HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void ** ppvObject);\
        ULONG STDMETHODCALLTYPE AddRef();\
        ULONG STDMETHODCALLTYPE Release();\
    ULONG STDMETHODCALLTYPE AddLock();\
        ULONG STDMETHODCALLTYPE ReleaseLock()

#define DEFINE_OLE_TABLE(cls)\
        LONG cls::GetRefCount() {return refCount.l;}\
    HRESULT STDMETHODCALLTYPE cls::QueryInterface(REFIID iid, void ** ppvObject)\
    {\
        if (! ppvObject)\
        {\
            WXOLE_TRACE("*** NULL POINTER ***");\
            return E_FAIL;\
        };\
        const char *desc = NULL;\
        cls::_GetInterface(this, iid, ppvObject, desc);\
        if (! *ppvObject)\
        {\
            WXOLE_TRACEOUT("<" << GetIIDName(iid).c_str() << "> Not Found");\
            return E_NOINTERFACE;\
        };\
        WXOLE_TRACEOUT("QI : <" << desc <<">");\
        ((IUnknown * )(*ppvObject))->AddRef();\
        return S_OK;\
    };\
    ULONG STDMETHODCALLTYPE cls::AddRef()\
    {\
        WXOLE_TRACEOUT(# cls << "::Add ref(" << refCount.l << ")");\
        InterlockedIncrement(&refCount.l);\
        return refCount.l;\
    };\
    ULONG STDMETHODCALLTYPE cls::Release()\
    {\
        if (refCount.l > 0)\
        {\
                InterlockedDecrement(&refCount.l);\
                WXOLE_TRACEOUT(# cls << "::Del ref(" << refCount.l << ")");\
            if (refCount.l == 0)\
                {\
                delete this;\
                    return 0;\
                };\
                return refCount.l;\
        }\
        else\
                return 0;\
    }\
    ULONG STDMETHODCALLTYPE cls::AddLock()\
    {\
        WXOLE_TRACEOUT(# cls << "::Add Lock(" << lockCount.l << ")");\
        InterlockedIncrement(&lockCount.l);\
        return lockCount.l;\
    };\
    ULONG STDMETHODCALLTYPE cls::ReleaseLock()\
    {\
        if (lockCount.l > 0)\
        {\
                InterlockedDecrement(&lockCount.l);\
                WXOLE_TRACEOUT(# cls << "::Del Lock(" << lockCount.l << ")");\
            return lockCount.l;\
        }\
        else\
                return 0;\
    }\
    DEFINE_OLE_BASE(cls)

#define DEFINE_OLE_BASE(cls)\
        void cls::_GetInterface(cls *self, REFIID iid, void **_interface, const char *&desc)\
        {\
                *_interface = NULL;\
            desc = NULL;

#define OLE_INTERFACE(_iid, _type)\
    if (IsEqualIID(iid, _iid))\
    {\
        WXOLE_TRACE("Found Interface <" # _type ">");\
        *_interface = (IUnknown *) (_type *) self;\
        desc = # _iid;\
        return;\
    }

#define OLE_IINTERFACE(_face) OLE_INTERFACE(IID_##_face, _face)

#define OLE_INTERFACE_CUSTOM(func)\
    if (func(self, iid, _interface, desc))\
        {\
        return;\
        }

#define END_OLE_TABLE\
        }



class wxActiveX : public wxWindow {
public:
        class ParamX 
        {
        public:
                USHORT      flags;
        bool isPtr, isSafeArray;
                VARTYPE     vt;
        wxString    name;

        ParamX() : vt(VT_EMPTY) {}
                inline bool IsIn() const                {return (flags & IDLFLAG_FIN) != 0;}
                inline bool IsOut() const               {return (flags & IDLFLAG_FOUT) != 0;}
                inline bool IsRetVal() const    {return (flags & IDLFLAG_FRETVAL) != 0;}
        };
        typedef vector<ParamX>  ParamXArray;

    class FuncX 
    {
    public:
        wxString    name;
        MEMBERID    memid;
                bool            hasOut;

        ParamX      retType;
                ParamXArray     params;
    };

        class PropX
        {
        public:
                wxString        name;
        MEMBERID    memid;
        ParamX      type;
        ParamX      arg;
                bool            putByRef;

                PropX() : putByRef (false) {}
                inline bool CanGet() const {return type.vt != VT_EMPTY;}
                inline bool CanSet() const {return arg.vt != VT_EMPTY;}
        };

    wxActiveX(wxWindow * parent, REFCLSID clsid, wxWindowID id = -1,
        const wxPoint& pos = wxDefaultPosition,
        const wxSize& size = wxDefaultSize,
        long style = 0,
        const wxString& name = wxPanelNameStr);
    wxActiveX(wxWindow * parent, wxString progId, wxWindowID id = -1,
        const wxPoint& pos = wxDefaultPosition,
        const wxSize& size = wxDefaultSize,
        long style = 0,
        const wxString& name = wxPanelNameStr);
        virtual ~wxActiveX();

    inline int GetEventCount() const {return m_events.size();}
    const FuncX& GetEventDesc(int idx) const;

    inline int GetPropCount() const {return m_props.size();}
    const PropX& GetPropDesc(int idx) const;
    const PropX& GetPropDesc(wxString name) const;

    inline int GetMethodCount() const {return m_methods.size();}
    const FuncX& GetMethodDesc(int idx) const;
    const FuncX& GetMethodDesc(wxString name) const;

    void SetProp(MEMBERID name, VARIANTARG& value);
    void SetProp(const wxString &name, const wxVariant &value);
    
    class wxPropertySetter
    {
    public:
        wxActiveX *m_ctl;
        wxString m_propName;

        wxPropertySetter(wxActiveX *ctl, wxString propName) : 
            m_ctl(ctl), m_propName(propName) {}
        
        inline const wxPropertySetter& operator = (wxVariant v) const
        {
            m_ctl->SetProp(m_propName, v);
            return *this;
        };

        inline operator wxVariant() const   {return m_ctl->GetPropAsWxVariant(m_propName);};
        inline operator wxString() const    {return m_ctl->GetPropAsString(m_propName);};
        inline operator char() const        {return m_ctl->GetPropAsChar(m_propName);};
        inline operator long() const        {return m_ctl->GetPropAsLong(m_propName);};
        inline operator bool() const        {return m_ctl->GetPropAsBool(m_propName);};
        inline operator double() const      {return m_ctl->GetPropAsDouble(m_propName);};
        inline operator wxDateTime() const  {return m_ctl->GetPropAsDateTime(m_propName);};
        inline operator void *() const      {return m_ctl->GetPropAsPointer(m_propName);};
    };

    inline wxPropertySetter Prop(wxString name) {return wxPropertySetter(this, name);}

    VARIANT GetPropAsVariant(MEMBERID name);
    VARIANT GetPropAsVariant(const wxString& name);
    wxVariant GetPropAsWxVariant(const wxString& name);
    wxString GetPropAsString(const wxString& name);
    char GetPropAsChar(const wxString& name);
    long GetPropAsLong(const wxString& name);
    bool GetPropAsBool(const wxString& name);
    double GetPropAsDouble(const wxString& name);
    wxDateTime GetPropAsDateTime(const wxString& name);
    void *GetPropAsPointer(const wxString& name);

    // methods
    // VARIANTARG form is passed straight to Invoke, 
    // so args in *REVERSE* order
    VARIANT CallMethod(MEMBERID name, VARIANTARG args[], int argc);
    VARIANT CallMethod(wxString name, VARIANTARG args[] = NULL, int argc = -1);
    // args are in *NORMAL* order
    // args can be a single wxVariant or an array
    wxVariant CallMethod(wxString name, wxVariant args[], int nargs = -1);

        HRESULT ConnectAdvise(REFIID riid, IUnknown *eventSink);

        void OnSize(wxSizeEvent&);
    void OnPaint(wxPaintEvent& event);
    void OnMouse(wxMouseEvent& event);
        void OnSetFocus(wxFocusEvent&);
    void OnKillFocus(wxFocusEvent&);

        DECLARE_EVENT_TABLE();

protected:
    friend class FrameSite;
    friend class wxActiveXEvents;

        typedef map<MEMBERID, FuncX>    FuncXMap;
    typedef map<wxString, FuncX, NS_wxActiveX::less_wxStringI>  FuncXStringMap;
        typedef map<wxString, PropX, NS_wxActiveX::less_wxStringI> PropXMap;
        typedef wxAutoOleInterface<IConnectionPoint>    wxOleConnectionPoint;
        typedef pair<wxOleConnectionPoint, DWORD>               wxOleConnection;
        typedef vector<wxOleConnection>                                 wxOleConnectionArray;

        wxAutoOleInterface<IDispatch>                   m_Dispatch;
    wxAutoOleInterface<IOleClientSite>      m_clientSite;
    wxAutoOleInterface<IUnknown>            m_ActiveX;
        wxAutoOleInterface<IOleObject>                  m_oleObject;
        wxAutoOleInterface<IOleInPlaceObject>   m_oleInPlaceObject;
    wxAutoOleInterface<IOleInPlaceActiveObject>

                                            m_oleInPlaceActiveObject;
    wxAutoOleInterface<IOleDocumentView>        m_docView;
    wxAutoOleInterface<IViewObject>             m_viewObject;
        HWND m_oleObjectHWND;
    bool m_bAmbientUserMode;
    DWORD m_docAdviseCookie;
        wxOleConnectionArray                                    m_connections;

        void CreateActiveX(REFCLSID clsid);
    void CreateActiveX(LPOLESTR progId);
    HRESULT AmbientPropertyChanged(DISPID dispid);

        void GetTypeInfo();
        void GetTypeInfo(ITypeInfo *ti, bool defInterface, bool defEventSink);


    // events
    FuncXMap            m_events;

        // properties
        PropXMap                m_props;

    // Methods
    FuncXStringMap  m_methods;

    long MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
};

// events
class wxActiveXEvent : public wxCommandEvent
{
private:
    friend class wxActiveXEvents;

    wxVariant m_params;

public:

    virtual wxEvent *Clone() const { return new wxActiveXEvent(*this); }

    wxString EventName();
    int ParamCount() const;
    wxString ParamType(int idx);
    wxString ParamName(int idx);
    wxVariant& operator[] (int idx);
    wxVariant& operator[] (wxString name);
};

const wxEventType& RegisterActiveXEvent(const wxChar *eventName);
const wxEventType& RegisterActiveXEvent(DISPID event);

typedef void (wxEvtHandler::*wxActiveXEventFunction)(wxActiveXEvent&);

#define EVT_ACTIVEX(id, eventName, fn) DECLARE_EVENT_TABLE_ENTRY(RegisterActiveXEvent(wxT(eventName)), id, -1, (wxObjectEventFunction) (wxEventFunction) (wxActiveXEventFunction) & fn, (wxObject *) NULL ),
#define EVT_ACTIVEX_DISPID(id, eventDispId, fn) DECLARE_EVENT_TABLE_ENTRY(RegisterActiveXEvent(eventDispId), id, -1, (wxObjectEventFunction) (wxEventFunction) (wxActiveXEventFunction) & fn, (wxObject *) NULL ),

//util
bool wxDateTimeToVariant(wxDateTime dt, VARIANTARG& va);
bool VariantToWxDateTime(VARIANTARG va, wxDateTime& dt);
bool MSWVariantToVariant(VARIANTARG& va, wxVariant& vx);
bool VariantToMSWVariant(const wxVariant& vx, VARIANTARG& va);

#endif /* _IEHTMLWIN_H_ */

---