Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

New wxActiveX and wxIEHtmlWin from Lindsay

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@16135 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robin Dunn
2002-07-11 17:43:34 +00:00
parent cb1871cabf
commit 83a732882a
8 changed files with 682 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
wxPython/contrib/iewin/.cvsignore Normal file
View File

@@ -0,0 +1 @@
orig

30
wxPython/contrib/iewin/IEHtmlWin.cpp
View File

@@ -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 L"WordPad.Document.1"
//#define PROGID L"SoftwareFX.ChartFX.20"
//#define PROGID "MSCAL.Calendar"
//#define PROGID "WordPad.Document.1"
//#define PROGID "SoftwareFX.ChartFX.20"
wxIEHtmlWin::wxIEHtmlWin(wxWindow * parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
: wxActiveX(parent, PROGID, id, pos, size, style, name)
const wxString& 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)

8
wxPython/contrib/iewin/IEHtmlWin.h
View File

@@ -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:

12
wxPython/contrib/iewin/iewin.cpp
View File

@@ -150,8 +150,8 @@ static PyObject *_wrap_new_wxMSHTMLEvent(PyObject *self, PyObject *args, PyObjec
return _resultobj;
}
#define wxMSHTMLEvent_GetText(_swigobj) (_swigobj->GetText())
static PyObject *_wrap_wxMSHTMLEvent_GetText(PyObject *self, PyObject *args, PyObject *kwargs) {
#define wxMSHTMLEvent_GetText1(_swigobj) (_swigobj->GetText1())
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 }
};

4
wxPython/contrib/iewin/iewin.i
View File

@@ -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();

5
wxPython/contrib/iewin/iewin.py
View File

@@ -66,8 +66,8 @@ class wxMSHTMLEventPtr(wxNotifyEventPtr):
def __init__(self,this):
self.this = this
self.thisown = 0
def GetText(self, *_args, **_kwargs):
val = apply(iewinc.wxMSHTMLEvent_GetText,(self,) + _args, _kwargs)
def GetText1(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)

471
wxPython/contrib/iewin/wxactivex.cpp
View File

@@ -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)
@@ -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++ )

68
wxPython/contrib/iewin/wxactivex.h
View File

@@ -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_ */