New wxActiveX and wxIEHtmlWin from Lindsay

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@16135 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

wxPython/contrib/iewin/.cvsignore

@@ -0,0 +1 @@
+orig

wxPython/contrib/iewin/IEHtmlWin.cpp

@@ -169,24 +169,25 @@ static const CLSID CLSID_MozillaBrowser =
     0x00, 0x00, 0x00, 0x00 } };
 
 
-//#define PROGID L"Shell.Explorer"
+//#define PROGID "Shell.Explorer"
 #define PROGID CLSID_WebBrowser
+//#define PROGID CLSID_MozillaBrowser
 //#define PROGID CLSID_HTMLDocument
-//#define PROGID L"MSCAL.Calendar"
+//#define PROGID "MSCAL.Calendar"
-//#define PROGID L"WordPad.Document.1"
+//#define PROGID "WordPad.Document.1"
-//#define PROGID L"SoftwareFX.ChartFX.20"
+//#define PROGID "SoftwareFX.ChartFX.20"
-
 
 wxIEHtmlWin::wxIEHtmlWin(wxWindow * parent, wxWindowID id,
         const wxPoint& pos,
         const wxSize& size,
         long style,
-              const wxString& name)
+        const wxString& name) : 
-	: wxActiveX(parent, PROGID, id, pos, size, style, name)
+    wxActiveX(parent, PROGID, id, pos, size, style, name)
 {
     SetupBrowser();
 }
 
+
 wxIEHtmlWin::~wxIEHtmlWin()
 {
 }
@@ -241,7 +242,7 @@ void wxIEHtmlWin::SetCharset(wxString charset)
 	{
 		wxAutoOleInterface<IHTMLDocument2> doc(IID_IHTMLDocument2, disp);
 		if (doc.Ok())
-            doc->put_charset((BSTR) (const wchar_t*)charset.wc_str(wxConvUTF8));
+			doc->put_charset((BSTR) wxConvUTF8.cMB2WC(charset).data());
 	};
 };
 
@@ -316,21 +317,21 @@ void wxIEHtmlWin::LoadUrl(const wxString& url)
 	headers.vt = VT_EMPTY;
 
 	HRESULT hret = 0;
-	hret = m_webBrowser->Navigate((BSTR) (const wchar_t*)url.wc_str(wxConvUTF8),
+	hret = m_webBrowser->Navigate((BSTR) wxConvUTF8.cMB2WC(url).data(), 
 		&navFlag, &targetFrame, &postData, &headers);	
 };
 
 
 bool  wxIEHtmlWin::LoadString(wxString html)
 {
-	string s = html.mb_str(wxConvUTF8);
+	string s = html.c_str();
 	istringstream *is = new istringstream(s);
 	return LoadStream(is);
 };
 
 bool  wxIEHtmlWin::LoadStream(istream *is)
 {
-	// wrap refernce around stream
+	// wrap reference around stream
     IStreamAdaptor *pstrm = new IStreamAdaptor(is);
 	pstrm->AddRef();
 
@@ -353,9 +354,11 @@ bool  wxIEHtmlWin::LoadStream(istream *is)
         HRESULT hr = pPersistStreamInit->InitNew();
         if (SUCCEEDED(hr))
             hr = pPersistStreamInit->Load(strm);
-    };
 
-    return true;
+		return SUCCEEDED(hr);
+    }
+	else
+	    return false;
 };
 
 bool wxIEHtmlWin::GoBack()
@@ -404,6 +407,7 @@ bool wxIEHtmlWin::Stop()
     return hret == S_OK;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 
 static wxAutoOleInterface<IHTMLSelectionObject> GetSelObject(IOleObject *oleObject)

wxPython/contrib/iewin/IEHtmlWin.h

@@ -19,10 +19,11 @@ public:
 		: wxNotifyEvent(commandType, id)
 	{}
 
-    wxString GetText() { return m_text1; }
+	wxString GetText1() { return m_text1; }
 	long GetLong1() { return m_long1; }
 	long GetLong2() { return m_long2; }
 
+
 	wxString	m_text1;
 	long		m_long1, m_long2;
 
@@ -30,6 +31,7 @@ public:
 
 private:
 	DECLARE_DYNAMIC_CLASS(wxMSHTMLEvent)
+
 };
 
 BEGIN_DECLARE_EVENT_TYPES()
@@ -51,14 +53,14 @@ typedef void (wxEvtHandler::*wxMSHTMLEventFunction)(wxMSHTMLEvent&);
 #define EVT_MSHTML_TITLECHANGE(id, fn) DECLARE_EVENT_TABLE_ENTRY(wxEVT_COMMAND_MSHTML_TITLECHANGE, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxMSHTMLEventFunction) & fn, NULL ),
 
 
-enum wxIEHtmlRefreshLevel {
+enum wxIEHtmlRefreshLevel 
+{
 	wxIEHTML_REFRESH_NORMAL = 0,
 	wxIEHTML_REFRESH_IFEXPIRED = 1,
 	wxIEHTML_REFRESH_CONTINUE = 2,
 	wxIEHTML_REFRESH_COMPLETELY = 3
 };
 
-
 class wxIEHtmlWin : public wxActiveX
 {
 public:

wxPython/contrib/iewin/iewin.cpp

@@ -150,8 +150,8 @@ static PyObject *_wrap_new_wxMSHTMLEvent(PyObject *self, PyObject *args, PyObjec
     return _resultobj;
 }
 
-#define wxMSHTMLEvent_GetText(_swigobj)  (_swigobj->GetText())
+#define wxMSHTMLEvent_GetText1(_swigobj)  (_swigobj->GetText1())
-static PyObject *_wrap_wxMSHTMLEvent_GetText(PyObject *self, PyObject *args, PyObject *kwargs) {
+static PyObject *_wrap_wxMSHTMLEvent_GetText1(PyObject *self, PyObject *args, PyObject *kwargs) {
     PyObject * _resultobj;
     wxString * _result;
     wxMSHTMLEvent * _arg0;
@@ -159,18 +159,18 @@ static PyObject *_wrap_wxMSHTMLEvent_GetText(PyObject *self, PyObject *args, PyO
     char *_kwnames[] = { "self", NULL };
 
     self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxMSHTMLEvent_GetText",_kwnames,&_argo0)) 
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxMSHTMLEvent_GetText1",_kwnames,&_argo0)) 
         return NULL;
     if (_argo0) {
         if (_argo0 == Py_None) { _arg0 = NULL; }
         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxMSHTMLEvent_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMSHTMLEvent_GetText. Expected _wxMSHTMLEvent_p.");
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMSHTMLEvent_GetText1. Expected _wxMSHTMLEvent_p.");
         return NULL;
         }
     }
 {
     PyThreadState* __tstate = wxPyBeginAllowThreads();
-    _result = new wxString (wxMSHTMLEvent_GetText(_arg0));
+    _result = new wxString (wxMSHTMLEvent_GetText1(_arg0));
 
     wxPyEndAllowThreads(__tstate);
     if (PyErr_Occurred()) return NULL;
@@ -776,7 +776,7 @@ static PyMethodDef iewincMethods[] = {
 	 { "new_wxIEHtmlWin", (PyCFunction) _wrap_new_wxIEHtmlWin, METH_VARARGS | METH_KEYWORDS },
 	 { "wxMSHTMLEvent_GetLong2", (PyCFunction) _wrap_wxMSHTMLEvent_GetLong2, METH_VARARGS | METH_KEYWORDS },
 	 { "wxMSHTMLEvent_GetLong1", (PyCFunction) _wrap_wxMSHTMLEvent_GetLong1, METH_VARARGS | METH_KEYWORDS },
-	 { "wxMSHTMLEvent_GetText", (PyCFunction) _wrap_wxMSHTMLEvent_GetText, METH_VARARGS | METH_KEYWORDS },
+	 { "wxMSHTMLEvent_GetText1", (PyCFunction) _wrap_wxMSHTMLEvent_GetText1, METH_VARARGS | METH_KEYWORDS },
 	 { "new_wxMSHTMLEvent", (PyCFunction) _wrap_new_wxMSHTMLEvent, METH_VARARGS | METH_KEYWORDS },
 	 { NULL, NULL }
 };

wxPython/contrib/iewin/iewin.i

@@ -44,7 +44,7 @@ class wxMSHTMLEvent : public wxNotifyEvent
 {
 public:
     wxMSHTMLEvent(wxEventType commandType = wxEVT_NULL, int id = 0);
-    wxString GetText();
+    wxString GetText1();
     long GetLong1();
     long GetLong2();
 };
@@ -103,6 +103,8 @@ public:
     bool LoadString(wxString html);
     /* bool LoadStream(istream *strm); */
 
+    %pragma(python) addtoclass = "Navigate = LoadUrl"
+
     void SetCharset(wxString charset);
     void SetEditMode(bool seton);
     bool GetEditMode();

wxPython/contrib/iewin/iewin.py

@@ -66,8 +66,8 @@ class wxMSHTMLEventPtr(wxNotifyEventPtr):
     def __init__(self,this):
         self.this = this
         self.thisown = 0
-    def GetText(self, *_args, **_kwargs):
+    def GetText1(self, *_args, **_kwargs):
-        val = apply(iewinc.wxMSHTMLEvent_GetText,(self,) + _args, _kwargs)
+        val = apply(iewinc.wxMSHTMLEvent_GetText1,(self,) + _args, _kwargs)
         return val
     def GetLong1(self, *_args, **_kwargs):
         val = apply(iewinc.wxMSHTMLEvent_GetLong1,(self,) + _args, _kwargs)
@@ -130,6 +130,7 @@ class wxIEHtmlWinPtr(wxWindowPtr):
         return val
     def __repr__(self):
         return "<C wxIEHtmlWin instance at %s>" % (self.this,)
+    Navigate = LoadUrl
 class wxIEHtmlWin(wxIEHtmlWinPtr):
     def __init__(self,*_args,**_kwargs):
         self.this = apply(iewinc.new_wxIEHtmlWin,_args,_kwargs)

wxPython/contrib/iewin/wxactivex.cpp

@@ -1,6 +1,6 @@
 #include "wxActiveX.h"
 #include <wx/strconv.h>
-#include <wx/msw/ole/uuid.h>
+#include <wx/event.h>
 #include <oleidl.h>
 #include <winerror.h>
 #include <idispids.h>
@@ -21,6 +21,7 @@ using namespace std;
     #endif
 #endif
 
+
 //////////////////////////////////////////////////////////////////////
 BEGIN_EVENT_TABLE(wxActiveX, wxWindow)
 	EVT_SIZE(OnSize)
@@ -190,7 +191,7 @@ wxActiveX::wxActiveX(wxWindow * parent, REFCLSID clsid, wxWindowID id,
         const wxSize& size,
         long style,
         const wxString& name) :
-	wxWindow(parent, id, pos, size, style, name)
+wxWindow(parent, id, pos, size, style, name)
 {
     m_bAmbientUserMode = true;
     m_docAdviseCookie = 0;
@@ -206,7 +207,7 @@ wxActiveX::wxActiveX(wxWindow * parent, wxString progId, wxWindowID id,
 {
     m_bAmbientUserMode = true;
     m_docAdviseCookie = 0;
-	CreateActiveX((LPOLESTR) (const wchar_t*)progId.wc_str(wxConvUTF8));
+    CreateActiveX((LPOLESTR) wxConvUTF8.cMB2WC(progId).data());
 }
 
 wxActiveX::~wxActiveX()
@@ -257,12 +258,13 @@ void wxActiveX::CreateActiveX(REFCLSID clsid)
     wxASSERT(adviseSink.Ok());
 
 
-
-
 	// // Create Object, get IUnknown interface
     m_ActiveX.CreateInstance(clsid, IID_IUnknown);
 	wxASSERT(m_ActiveX.Ok());
 
+	// Type Info
+	GetTypeInfo();
+
 	// Get IOleObject interface
 	hret = m_oleObject.QueryInterface(IID_IOleObject, m_ActiveX); 
 	wxASSERT(SUCCEEDED(hret));
@@ -318,12 +320,24 @@ void wxActiveX::CreateActiveX(REFCLSID clsid)
 
     if (! (dwMiscStatus & OLEMISC_INVISIBLEATRUNTIME))
     {
+		if (w > 0 && h > 0)
 			m_oleInPlaceObject->SetObjectRects(&posRect, &posRect);
 
 		hret = m_oleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL, m_clientSite, 0, (HWND)GetHWND(), &posRect);
         hret = m_oleObject->DoVerb(OLEIVERB_SHOW, 0, m_clientSite, 0, (HWND)GetHWND(), &posRect);
     };
 
+	if (! m_oleObjectHWND)
+	{
+		hret = m_oleInPlaceObject->GetWindow(&m_oleObjectHWND);
+		WXOLE_WARN(hret, "m_oleInPlaceObject->GetWindow(&m_oleObjectHWND)");
+	};
+
+	if (m_oleObjectHWND)
+	{
+		::SetActiveWindow(m_oleObjectHWND);
+		::ShowWindow(m_oleObjectHWND, SW_SHOW);
+	};
 }
 
 void wxActiveX::CreateActiveX(LPOLESTR progId)
@@ -335,6 +349,441 @@ void wxActiveX::CreateActiveX(LPOLESTR progId)
     CreateActiveX(clsid);
 };
 
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Case Insensitive Map of Event names to eventTypes
+// created dynamically at run time in:
+//      EVT_ACTIVEX(eventName, id, fn)
+// we map the pointer to them so that:
+//      const wxEventType& RegisterActiveXEvent(wxString eventName);
+// can return a const reference, which is neccessary for event tables
+// probably should use a wxWindows hash table here, but I'm lazy ...
+struct less_wxStringI
+{
+    bool operator()(const wxString& x, const wxString& y) const
+    {
+        return x.CmpNoCase(y) < 0;
+    };
+};
+
+typedef map<wxString, wxEventType *, less_wxStringI> ActiveXEventMap;
+static ActiveXEventMap sg_eventMap;
+
+// one off class for automatic freeing of activeX eventtypes
+class ActiveXEventMapFlusher
+{
+public:
+    ~ActiveXEventMapFlusher()
+    {
+        ActiveXEventMap::iterator it = sg_eventMap.end();
+        while (it != sg_eventMap.end())
+        {
+            delete it->second;
+            it++;
+        };
+    };
+};
+
+static ActiveXEventMapFlusher s_dummyActiveXEventMapFlusher;
+
+const wxEventType& RegisterActiveXEvent(wxString eventName)
+{
+    ActiveXEventMap::iterator it = sg_eventMap.find(eventName);
+    if (it == sg_eventMap.end())
+    {
+        wxEventType  *et = new wxEventType(wxNewEventType());
+        sg_eventMap[eventName] = et;
+
+        return *et;
+    };
+
+    return *(it->second);
+};
+
+//////////////////////////////////////////////////////
+bool MSWVariantToVariant(VARIANTARG& va, wxVariant& vx)
+{
+    switch(va.vt)
+    {
+	case VT_VARIANT | VT_BYREF:
+		return MSWVariantToVariant(*va.pvarVal, vx);
+
+    case VT_I2:
+    case VT_I4:
+        vx = (long) va.iVal;
+        return true;
+
+    case VT_I2 | VT_BYREF:
+    case VT_I4 | VT_BYREF:
+        vx = (long) *va.piVal;
+        return true;
+
+    case VT_BSTR:
+        vx = wxString(va.bstrVal);
+        return true;
+
+    case VT_BSTR | VT_BYREF:
+        vx = wxString(*va.pbstrVal);
+        return true;
+
+	case VT_BOOL:
+		vx = (va.boolVal != FALSE);
+		return true;
+
+	case VT_BOOL | VT_BYREF:
+		vx = (*va.pboolVal != FALSE);
+		return true;
+
+    default:
+        vx.MakeNull();
+        return false;
+    };
+};
+
+bool VariantToMSWVariant(wxVariant& vx, VARIANTARG& va)
+{
+    switch(va.vt)
+    {
+	case VT_VARIANT | VT_BYREF:
+		return VariantToMSWVariant(vx, va);
+
+    case VT_I2:
+    case VT_I4:
+        va.iVal = (long) vx;
+        return true;
+
+    case VT_I2 | VT_BYREF:
+    case VT_I4 | VT_BYREF:
+         *va.piVal = (long) vx;
+        return true;
+
+	case VT_BOOL:
+		va.boolVal = ((bool) vx) ? TRUE : FALSE;
+		return true;
+
+	case VT_BOOL | VT_BYREF:
+		*va.pboolVal = ((bool) vx) ? TRUE : FALSE;
+		return true;
+
+    default:
+        return false;
+    };
+};
+
+class wxActiveXEvents : public IDispatch
+{
+private:
+    DECLARE_OLE_UNKNOWN(wxActiveXEvents);
+
+
+    wxActiveX *m_activeX;
+
+public:
+    wxActiveXEvents(wxActiveX *ax) : m_activeX(ax) {}
+	~wxActiveXEvents() 
+    {
+    }
+
+	//IDispatch
+	STDMETHODIMP GetIDsOfNames(REFIID r, OLECHAR** o, unsigned int i, LCID l, DISPID* d)
+	{ 
+        return E_NOTIMPL;
+    };
+
+	STDMETHODIMP GetTypeInfo(unsigned int i, LCID l, ITypeInfo** t)
+	{ 
+        return E_NOTIMPL;
+    };
+
+	STDMETHODIMP GetTypeInfoCount(unsigned int* i)
+	{ 
+        return E_NOTIMPL;
+    };
+
+
+
+	STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
+						  WORD wFlags, DISPPARAMS * pDispParams,
+						  VARIANT * pVarResult, EXCEPINFO * pExcepInfo,
+						  unsigned int * puArgErr)
+	{ 
+	    if (wFlags & (DISPATCH_PROPERTYGET | DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF))
+            return E_NOTIMPL;
+
+        // map dispid to name
+        wxActiveX::MemberIdList::iterator mid = m_activeX->m_eventsIdx.find((MEMBERID) dispIdMember);
+        if (mid == m_activeX->m_eventsIdx.end())
+            return S_OK;
+
+        int idx = mid->second;
+
+        
+        wxActiveX::FuncX &func = m_activeX->m_events[idx];
+
+        ActiveXEventMap::iterator it = sg_eventMap.find(func.name);
+        if (it == sg_eventMap.end())
+            return S_OK;
+
+		wxActiveXEvent  event;
+    	event.SetId(m_activeX->GetId());
+	    event.SetEventType(*(it->second));
+        event.m_params.NullList();
+
+        // arguments
+        if (pDispParams)
+        {
+			// cdecl call
+            for (int i = pDispParams->cArgs - 1; i >= 0; i--)
+            {
+                VARIANTARG& va = pDispParams->rgvarg[i];
+				wxActiveX::ParamX &px = func.params[pDispParams->cArgs - i - 1];
+                wxVariant vx;
+
+                MSWVariantToVariant(va, vx);
+                vx.SetName(px.name);
+                event.m_params.Append(vx);
+            };
+        };
+
+		if (func.hasOut)
+		{
+    		m_activeX->GetParent()->ProcessEvent(event);
+            for (unsigned int i = 0; i < pDispParams->cArgs; i++)
+            {
+                VARIANTARG& va = pDispParams->rgvarg[i];
+				wxActiveX::ParamX &px = func.params[pDispParams->cArgs - i - 1];
+
+				if (px.IsOut())
+				{
+					wxVariant& vx = event.m_params[pDispParams->cArgs - i - 1];
+					
+					VariantToMSWVariant(vx, va);
+				};
+			};
+		}
+		else
+    		m_activeX->GetParent()->AddPendingEvent(event);
+
+    	return S_OK;
+    }
+};
+
+
+DEFINE_OLE_TABLE(wxActiveXEvents)
+	OLE_IINTERFACE(IUnknown)
+	OLE_INTERFACE(IID_IDispatch, IDispatch)
+END_OLE_TABLE;
+
+
+int wxActiveXEvent::ParamCount() const
+{
+    return m_params.GetCount();
+};
+
+static wxVariant nullVar;
+
+wxVariant wxActiveXEvent::operator[] (int idx) const
+{
+    return (wxVariant&) operator[] (idx);
+};
+
+wxVariant& wxActiveXEvent::operator[] (int idx)
+{
+    wxASSERT(idx >= 0 && idx < ParamCount());
+
+    return m_params[idx];
+};
+
+wxVariant wxActiveXEvent::operator[] (wxString name) const
+{
+    return (wxVariant&) operator[] (name);
+};
+
+wxVariant& wxActiveXEvent::operator[] (wxString name)
+{
+    for (int i = 0; i < m_params.GetCount(); i++)
+    {
+        if (name.CmpNoCase(m_params[i].GetName()) == 0)
+            return m_params[i];
+    };
+
+    wxString err = "wxActiveXEvent::operator[] invalid name <" + name + ">";
+    err += "\r\nValid Names = :\r\n";
+    for (i = 0; i < m_params.GetCount(); i++)
+    {
+        err += m_params[i].GetName();
+        err += "\r\n";
+    };
+
+    wxASSERT_MSG(false, err);
+
+    return nullVar;
+};
+
+void wxActiveX::GetTypeInfo()
+{
+	/*
+	We are currently only interested in the IDispatch interface 
+	to the control. For dual interfaces (TypeKind = TKIND_INTERFACE)
+	we should drill down through the inheritance 
+	(using TYPEATTR->cImplTypes) and GetRefTypeOfImplType(n)
+	and retrieve all the func names etc that way, then generate a C++ 
+	header	file for it.
+
+	But we don't do this and probably never will, so if we have a DUAL 
+	interface then we query for the IDispatch 
+	via GetRefTypeOfImplType(-1).
+	*/
+
+	HRESULT hret = 0;
+
+	// get type info via class info
+	wxAutoOleInterface<IProvideClassInfo> classInfo(IID_IProvideClassInfo, m_ActiveX);
+	if (! classInfo.Ok())
+		return;
+
+	// type info
+	wxAutoOleInterface<ITypeInfo> typeInfo;
+	hret = classInfo->GetClassInfo(typeInfo.GetRef());
+	if (! typeInfo.Ok())
+		return;
+
+	// TYPEATTR
+	TYPEATTR *ta = NULL;
+	hret = typeInfo->GetTypeAttr(&ta);
+	if (! ta)
+		return;
+
+    // this should be a TKIND_COCLASS
+    wxASSERT(ta->typekind == TKIND_COCLASS);
+
+    // iterate contained interfaces
+	for (int i = 0; i < ta->cImplTypes; i++)
+	{
+		HREFTYPE rt = 0;
+
+		// get dispatch type info handle
+		hret = typeInfo->GetRefTypeOfImplType(i, &rt);
+		if (! SUCCEEDED(hret))
+			continue;
+
+		// get dispatch type info interface
+		wxAutoOleInterface<ITypeInfo>  ti;
+		hret = typeInfo->GetRefTypeInfo(rt, ti.GetRef());
+		if (! ti.Ok())
+			continue;
+
+        // check if default event sink
+        bool defEventSink = false;
+        int impTypeFlags = 0;
+        typeInfo->GetImplTypeFlags(i, &impTypeFlags);
+
+        if (impTypeFlags & IMPLTYPEFLAG_FDEFAULT)
+        {
+            if (impTypeFlags & IMPLTYPEFLAG_FSOURCE)
+            {
+                WXOLE_TRACEOUT("Default Event Sink");
+                defEventSink = true;
+            }
+            else
+            {
+                WXOLE_TRACEOUT("Default Interface");
+            }
+        };
+
+
+		// process
+		GetTypeInfo(ti, defEventSink);
+	};
+
+
+    // free
+    typeInfo->ReleaseTypeAttr(ta);
+};
+
+void wxActiveX::GetTypeInfo(ITypeInfo *ti, bool defEventSink)
+{
+	ti->AddRef();
+	wxAutoOleInterface<ITypeInfo> typeInfo(ti);
+
+	// TYPEATTR
+	TYPEATTR *ta = NULL;
+	HRESULT hret = typeInfo->GetTypeAttr(&ta);
+	if (! ta)
+		return;
+
+	if (ta->typekind == TKIND_DISPATCH)
+	{
+        WXOLE_TRACEOUT("GUID = " << GetIIDName(ta->guid).c_str());
+
+        if (defEventSink)
+        {
+            wxActiveXEvents *disp = new wxActiveXEvents(this);
+            ConnectAdvise(ta->guid, disp);
+        };
+
+
+		// Get Function Names
+		for (int i = 0; i < ta->cFuncs; i++)
+		{
+			FUNCDESC FAR *fd = NULL;
+
+			hret = typeInfo->GetFuncDesc(i, &fd);
+			if (! fd)
+				continue;
+
+			BSTR anames[1] = {NULL};
+			unsigned int n = 0;
+
+			hret = typeInfo->GetNames(fd->memid, anames, 1, &n);
+
+			if (anames[0])
+			{
+				wxString name = anames[0];
+
+				WXOLE_TRACEOUT("Name " << i << " = " << name.c_str());
+				SysFreeString(anames[0]);
+
+                if (defEventSink)
+                {
+                    FuncX func;
+                    func.name = name;
+                    func.memid = fd->memid;
+					func.hasOut = false;
+
+                    // get Param Names
+                    unsigned int maxPNames = fd->cParams + 1;
+                    unsigned int nPNames = 0;
+                    BSTR *pnames = new BSTR[maxPNames];
+
+                    hret = typeInfo->GetNames(fd->memid, pnames, maxPNames, &nPNames);
+
+                    SysFreeString(pnames[0]);
+					// params
+					for (int p = 0; p < fd->cParams; p++)
+					{
+						ParamX param;
+						param.flags = fd->lprgelemdescParam[p].idldesc.wIDLFlags;
+						param.vt = fd->lprgelemdescParam[p].tdesc.vt;
+                        param.name = pnames[p + 1];
+                        SysFreeString(pnames[p + 1]);
+
+						func.hasOut |= param.IsOut();
+						func.params.push_back(param);
+					};
+                    delete [] pnames;
+
+                    m_events.push_back(func);
+                    m_eventsIdx[fd->memid] = m_events.size() - 1;
+                };
+			};
+
+			typeInfo->ReleaseFuncDesc(fd);
+		};
+	}
+
+	typeInfo->ReleaseTypeAttr(ta);
+};
+
 HRESULT wxActiveX::ConnectAdvise(REFIID riid, IUnknown *events)
 {
 	wxOleConnectionPoint	cp;
@@ -405,6 +854,9 @@ void wxActiveX::OnSize(wxSizeEvent& event)
 	posRect.right = w;
 	posRect.bottom = h;
 
+	if (w <= 0 && h <= 0)
+		return;
+
 	if (m_oleInPlaceObject) 
 		m_oleInPlaceObject->SetObjectRects(&posRect, &posRect);
 
@@ -828,6 +1280,8 @@ HRESULT FrameSite::GetContainer(LPOLECONTAINER * ppContainer)
 HRESULT FrameSite::ShowObject()
 {
 	WXOLE_TRACE("IOleClientSite::ShowObject");
+	if (m_window->m_oleObjectHWND)
+		::ShowWindow(m_window->m_oleObjectHWND, SW_SHOW);
 	return S_OK;
 }
 
@@ -1146,6 +1600,7 @@ wxString GetIIDName(REFIID riid)
 
   // construct the table containing all known interfaces
   #define ADD_KNOWN_IID(name) { &IID_I##name, _T(#name) }
+  #define ADD_KNOWN_GUID(name) { &name, _T(#name) }
 
   static const KNOWN_IID aKnownIids[] = 
   {
@@ -1227,10 +1682,18 @@ wxString GetIIDName(REFIID riid)
     ADD_KNOWN_IID(Unknown),
     ADD_KNOWN_IID(ViewObject),
     ADD_KNOWN_IID(ViewObject2),
+    ADD_KNOWN_GUID(IID_IDispatch),
+    ADD_KNOWN_GUID(IID_IWebBrowser),
+    ADD_KNOWN_GUID(IID_IWebBrowserApp),
+    ADD_KNOWN_GUID(IID_IWebBrowser2),
+    ADD_KNOWN_GUID(IID_IWebBrowser),
+    ADD_KNOWN_GUID(DIID_DWebBrowserEvents2),
+    ADD_KNOWN_GUID(DIID_DWebBrowserEvents),
   };
 
   // don't clobber preprocessor name space
   #undef ADD_KNOWN_IID
+  #undef ADD_KNOWN_GUID
 
   // try to find the interface in the table
   for ( size_t ui = 0; ui < WXSIZEOF(aKnownIids); ui++ ) 

wxPython/contrib/iewin/wxactivex.h

@@ -6,10 +6,13 @@
 
 #include <wx/setup.h>
 #include <wx/wx.h>
+#include <wx/variant.h>
 #include <oleidl.h>
+#include <exdisp.h>
 #include <docobj.h>
 #include <iostream>
 #include <vector>
+#include <map>
 using namespace std;
 
 //////////////////////////////////////////
@@ -268,12 +271,14 @@ public:
         const wxSize& size = wxDefaultSize,
         long style = 0,
         const wxString& name = wxPanelNameStr);
-
 	virtual ~wxActiveX();
 
 	void CreateActiveX(REFCLSID clsid);
     void CreateActiveX(LPOLESTR progId);
 
+	void GetTypeInfo();
+	void GetTypeInfo(ITypeInfo *ti, bool defEventSink);
+
 	HRESULT ConnectAdvise(REFIID riid, IUnknown *eventSink);
 
 	void OnSize(wxSizeEvent&);
@@ -284,6 +289,7 @@ public:
 
 protected:
     friend class FrameSite;
+    friend class wxActiveXEvents;
 
 	typedef wxAutoOleInterface<IConnectionPoint>	wxOleConnectionPoint;
 	typedef pair<wxOleConnectionPoint, DWORD>		wxOleConnection;
@@ -304,6 +310,66 @@ protected:
 
     HRESULT AmbientPropertyChanged(DISPID dispid);
 
+    // type stuff
+	class ParamX // refer to ELEMDESC, IDLDESC in MSDN
+	{
+	public:
+		USHORT	    flags;
+		VARTYPE	    vt;
+        wxString    name;
+
+		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 // refer to FUNCDESC in MSDN
+    {
+    public:
+        wxString    name;
+        MEMBERID    memid;
+		bool		hasOut;
+
+		ParamXArray	params;
+    };
+
+    typedef vector<FuncX> FuncXArray;
+    typedef map<MEMBERID, int>  MemberIdList;
+
+    // events
+    FuncXArray      m_events;
+    MemberIdList    m_eventsIdx;
 };
 
+// events
+class wxActiveXEvent : public wxNotifyEvent
+{
+private:
+    friend class wxActiveXEvents;
+
+    wxVariant m_params;
+
+public:
+
+    virtual wxEvent *Clone() const { return new wxActiveXEvent(*this); }
+
+    int ParamCount() const;
+    wxVariant  operator[] (int idx) const;
+    wxVariant& operator[] (int idx);
+    wxVariant  operator[] (wxString name) const;
+    wxVariant& operator[] (wxString name);
+};
+
+const wxEventType& RegisterActiveXEvent(wxString eventName);
+
+typedef void (wxEvtHandler::*wxActiveXEventFunction)(wxActiveXEvent&);
+
+#define EVT_ACTIVEX(id, eventName, fn) DECLARE_EVENT_TABLE_ENTRY(RegisterActiveXEvent(eventName), id, -1, (wxObjectEventFunction) (wxEventFunction) (wxActiveXEventFunction) & fn, (wxObject *) NULL ),
+
+//util
+bool MSWVariantToVariant(VARIANTARG& va, wxVariant& vx);
+bool VariantToMSWVariant(wxVariant& vx, VARIANTARG& va);
+
 #endif /* _IEHTMLWIN_H_ */