wxPython/contrib/activex/activex.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        activex.i
   3 // Purpose:     ActiveX controls (such as Internet Explorer) in a wxWindow
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     18-Mar-2004
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 2004 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13
  14 %module(package="wx") activex
  15
  16 %{
  17 #include "wx/wxPython/wxPython.h"
  18 #include "wx/wxPython/pyclasses.h"
  19 #include "wx/wxPython/pyistream.h"
  20
  21 #include "wxactivex.h"
  22 %}
  23
  24 //---------------------------------------------------------------------------
  25
  26 %import core.i
  27 %pythoncode { wx = _core }
  28 %pythoncode { __docfilter__ = wx.__DocFilter(globals()) }
  29
  30 MAKE_CONST_WXSTRING_NOSWIG(PanelNameStr);
  31
  32 %include _activex_rename.i
  33
  34
  35 //---------------------------------------------------------------------------
  36
  37 typedef unsigned short  USHORT;
  38 typedef long            DISPID;
  39 typedef long            MEMBERID;
  40 typedef unsigned short  VARTYPE;
  41
  42
  43 %{
  44 // Since SWIG doesn't support nested classes, we need to fool it a bit
  45 // and make them look like global classes.  These defines make the C++ code
  46 // know what we are doing.
  47 #define wxParamX        wxActiveX::ParamX
  48 #define wxFuncX         wxActiveX::FuncX
  49 #define wxPropX         wxActiveX::PropX
  50 #define wxParamXArray   wxActiveX::ParamXArray
  51 #define wxFuncXArray    wxActiveX::FuncXArray
  52 #define wxPropXArray    wxActiveX::PropXArray
  53 %}
  54
  55
  56 %{
  57 // Some conversion helpers
  58 static wxVariant _PyObj2Variant(PyObject* value);
  59 static bool  _PyObj2Variant(PyObject* value, wxVariant& wv);
  60 static PyObject* _Variant2PyObj(wxVariant& value, bool useNone=false);
  61 static wxString  _VARTYPEname(VARTYPE vt);
  62
  63 // Check if an exception has been raised  (blocking threads)
  64 inline bool wxPyErr_Occurred()
  65 {
  66     bool rval;
  67     wxPyBlock_t blocked = wxPyBeginBlockThreads();
  68     rval = PyErr_Occurred() != NULL;
  69     wxPyEndBlockThreads(blocked);
  70     return rval;
  71 }
  72
  73 %}
  74
  75 //---------------------------------------------------------------------------
  76 %newgroup
  77
  78 DocStr(CLSID,
  79 "This class wraps the Windows CLSID structure and is used to
  80 specify the class of the ActiveX object that is to be created.  A
  81 CLSID can be constructed from either a ProgID string, (such as
  82 'WordPad.Document.1') or a classID string, (such as
  83 '{CA8A9783-280D-11CF-A24D-444553540000}').", "");
  84
  85 class CLSID {
  86 public:
  87     %extend {
  88         CLSID(const wxString& id)
  89         {
  90             int result;
  91             CLSID* self = new CLSID;
  92             memset(self, 0, sizeof(CLSID));
  93
  94             if (id[0] == _T('{')) {
  95                 // Looks like a classID string
  96                 result =
  97                     CLSIDFromString(
  98                         (LPOLESTR)(const wchar_t *)id.wc_str(wxConvUTF8),
  99                         self);
 100             } else {
 101                 // Try a progID
 102                 result =
 103                     CLSIDFromProgID(
 104                         (LPOLESTR)(const wchar_t *)id.wc_str(wxConvUTF8),
 105                         self);
 106             }
 107             if (result != NOERROR) {
 108                 wxPyErr_SetString(PyExc_ValueError, "Not a recognized classID or progID");
 109                 delete self;
 110                 return NULL;
 111             }
 112             return self;
 113         }
 114
 115         ~CLSID() { delete self; }
 116
 117         wxString GetCLSIDString()
 118         {
 119             LPOLESTR s;
 120             wxString str;
 121             if (StringFromCLSID(*self, &s) == S_OK) {
 122                 str = s;
 123                 CoTaskMemFree(s);
 124             }
 125             else {
 126                 str = _T("Error!");  // TODO: raise exception?
 127             }
 128             return str;
 129         }
 130         wxString GetProgIDString()
 131         {
 132             LPOLESTR s;
 133             wxString str;
 134             if (ProgIDFromCLSID(*self, &s) == S_OK) {
 135                 str = s;
 136                 CoTaskMemFree(s);
 137             }
 138             else {
 139                 str = _T("Error!"); // TODO: raise exception?
 140             }
 141             return str;
 142         }
 143     }
 144     %pythoncode { def __str__(self):   return self.GetCLSIDString() }
 145 };
 146
 147
 148 //---------------------------------------------------------------------------
 149 %newgroup
 150
 151 %define MAKE_ARRAY_WRAPPER(basetype, arrayname)
 152 class arrayname
 153 {
 154 public:
 155     %extend {
 156         bool __nonzero__()          { return self->size() > 0; }
 157         int  __len__()              { return self->size(); }
 158
 159         const basetype& __getitem__(int idx) {
 160             if ( idx >= 0 && idx < self->size() )
 161                 return (*self)[idx];
 162             else {
 163                 static basetype BadVal;
 164                 wxPyErr_SetString(PyExc_IndexError, "Index out of range");
 165                 return BadVal;
 166             }
 167         }
 168         // TODO  __iter__??
 169     }
 170 };
 171 %enddef
 172
 173 //---------------------------------------------------------------------------
 174
 175 %immutable;
 176
 177 class wxParamX
 178 {
 179 public:
 180     USHORT      flags;
 181     bool        isPtr;
 182     bool        isSafeArray;
 183     bool        isOptional;
 184     VARTYPE     vt;
 185     wxString    name;
 186
 187     %feature("shadow") vt_type_get "vt_type = property(_activex.ParamX_vt_type_get)";
 188     %extend { wxString vt_type_get() { return _VARTYPEname(self->vt); } }
 189
 190     %feature("shadow") IsIn     "isIn = property(_activex.ParamX_IsIn)";
 191     %feature("shadow") IsOut    "isOut = property(_activex.ParamX_IsOut)";
 192     %feature("shadow") IsRetVal "isRetVal = property(_activex.ParamX_IsRetVal)";
 193     bool IsIn() const;
 194     bool IsOut() const;
 195     bool IsRetVal() const;
 196
 197 };
 198
 199
 200 class wxFuncX
 201 {
 202 public:
 203     wxString      name;
 204     MEMBERID      memid;
 205     bool          hasOut;
 206
 207     wxParamX      retType;
 208     wxParamXArray params;
 209 };
 210
 211
 212 class wxPropX
 213 {
 214 public:
 215     wxString    name;
 216     MEMBERID    memid;
 217     wxParamX    type;
 218     wxParamX    arg;
 219     bool        putByRef;
 220
 221     %feature("shadow") CanGet "canGet = property(_activex.PropX_CanGet)";
 222     %feature("shadow") CanSet "canSet = property(_activex.PropX_CanSet)";
 223     bool CanGet() const;
 224     bool CanSet() const;
 225 };
 226 %mutable;
 227
 228
 229 MAKE_ARRAY_WRAPPER(wxParamX, wxParamXArray);
 230 MAKE_ARRAY_WRAPPER(wxFuncX, wxFuncXArray);
 231 MAKE_ARRAY_WRAPPER(wxPropX, wxPropXArray);
 232
 233
 234 //---------------------------------------------------------------------------
 235 %newgroup
 236
 237 %{
 238 // C++ version of a Python-aware wxActiveX
 239 class wxActiveXWindow : public wxActiveX
 240 {
 241 private:
 242     CLSID       m_CLSID;
 243
 244     DECLARE_ABSTRACT_CLASS(wxActiveXWindow);
 245
 246 public:
 247     wxActiveXWindow( wxWindow* parent, const CLSID& clsId, wxWindowID id = -1,
 248                      const wxPoint& pos = wxDefaultPosition,
 249                      const wxSize& size = wxDefaultSize,
 250                      long style = 0,
 251                      const wxString& name = wxPyPanelNameStr)
 252         : wxActiveX(parent, clsId, id, pos, size, style, name)
 253     {
 254         m_CLSID = clsId;
 255     }
 256
 257     const CLSID& GetCLSID() const { return m_CLSID; }
 258
 259
 260     // Renamed versions of some base class methods that delegate
 261     // to the base where appropriate, and raise Python exceptions
 262     // when needed.
 263     int GetAXEventCount() const  { return wxActiveX::GetEventCount(); }
 264     int GetAXPropCount() const   { return wxActiveX::GetPropCount(); }
 265     int GetAXMethodCount() const { return wxActiveX::GetMethodCount(); }
 266
 267     const wxFuncX& GetAXEventDesc(int idx) const
 268     {
 269         static wxFuncX BadVal;
 270         if (idx < 0 || idx >= GetAXEventCount()) {
 271             wxPyErr_SetString(PyExc_IndexError, "Index out of range");
 272             return BadVal;
 273         }
 274         return m_events[idx];
 275     }
 276     const wxFuncX& GetAXMethodDesc(int idx) const
 277     {
 278         static wxFuncX BadVal;
 279         if (idx < 0 || idx >= GetAXMethodCount()) {
 280             wxPyErr_SetString(PyExc_IndexError, "Index out of range");
 281             return BadVal;
 282         }
 283         return m_methods[idx];
 284     }
 285     const wxPropX& GetAXPropDesc(int idx) const
 286     {
 287         static wxPropX BadVal;
 288         if (idx < 0 || idx >= GetAXPropCount()) {
 289             wxPyErr_SetString(PyExc_IndexError, "Index out of range");
 290             return BadVal;
 291         }
 292         return m_props[idx];
 293     }
 294
 295     const wxFuncX& GetAXMethodDesc(const wxString& name) const
 296     {
 297         NameMap::const_iterator it = m_methodNames.find(name);
 298         if (it == m_methodNames.end())     {
 299             wxString msg;
 300             msg << _T("method <") << name << _T("> not found");
 301             wxPyErr_SetString(PyExc_KeyError, msg.mb_str());
 302             static wxFuncX BadVal;
 303             return BadVal;
 304         };
 305         return GetAXMethodDesc(it->second);
 306     }
 307     const wxPropX& GetAXPropDesc(const wxString& name) const
 308     {
 309         NameMap::const_iterator it = m_propNames.find(name);
 310         if (it == m_propNames.end())     {
 311             wxString msg;
 312             msg << _T("property <") << name << _T("> not found");
 313             wxPyErr_SetString(PyExc_KeyError, msg.mb_str());
 314             static wxPropX BadVal;
 315             return BadVal;
 316         };
 317         return GetAXPropDesc(it->second);
 318     }
 319
 320     // Accessors for the internal vectors of events, methods and
 321     // proprties.  Can be used as sequence like objects from
 322     // Python.
 323     const wxFuncXArray& GetAXEvents()      { return m_events; }
 324     const wxFuncXArray& GetAXMethods()     { return m_methods; }
 325     const wxPropXArray& GetAXProperties()  { return m_props; }
 326
 327
 328     // Set a property from a Python object
 329     void SetAXProp(const wxString& name, PyObject* value)
 330     {
 331         const wxPropX& prop = GetAXPropDesc(name);
 332         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 333         if (! PyErr_Occurred() ) {
 334             if (! prop.CanSet()) {
 335                 wxString msg;
 336                 msg << _T("property <") << name << _T("> is readonly");
 337                 PyErr_SetString(PyExc_TypeError, msg.mb_str());
 338                 goto done;
 339             } else {
 340                 wxVariant wxV = _PyObj2Variant(value);
 341                 if (PyErr_Occurred())
 342                     goto done;
 343                 VARIANT v = {prop.arg.vt};
 344                 if (!VariantToMSWVariant(wxV, v) || PyErr_Occurred()) {
 345                     wxString msg;
 346                     msg << _T("Unable to convert value to expected type: (")
 347                         << _VARTYPEname(prop.arg.vt) << _T(") for property <")
 348                         << name << _T(">");
 349                     PyErr_SetString(PyExc_TypeError, msg.mb_str());
 350                     goto done;
 351                 }
 352                 PyThreadState* tstate = wxPyBeginAllowThreads();
 353                 SetProp(prop.memid, v);
 354                 VariantClear(&v);
 355                 wxPyEndAllowThreads(tstate);
 356             }
 357         }
 358     done:
 359         wxPyEndBlockThreads(blocked);
 360     }
 361
 362
 363     // Get a property and convert it to a Python object
 364     PyObject* GetAXProp(const wxString& name)
 365     {
 366         PyObject* rval = NULL;
 367         const wxPropX& prop = GetAXPropDesc(name);
 368         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 369         if (! PyErr_Occurred() ) {
 370             if (! prop.CanGet()) {
 371                 wxString msg;
 372                 msg << _T("property <") << name << _T("> is writeonly");
 373                 PyErr_SetString(PyExc_TypeError, msg.mb_str());
 374                 goto done;
 375             } else {
 376                 PyThreadState* tstate = wxPyBeginAllowThreads();
 377                 VARIANT v = GetPropAsVariant(prop.memid);
 378                 wxPyEndAllowThreads(tstate);
 379                 wxVariant wv;
 380                 if (!MSWVariantToVariant(v, wv) || PyErr_Occurred()) {
 381                     wxString msg;
 382                     msg << _T("Unable to convert value to expected type: (")
 383                         << _VARTYPEname(prop.arg.vt) << _T(") for property <")
 384                         << name << _T(">");
 385                     PyErr_SetString(PyExc_TypeError, msg.mb_str());
 386                     goto done;
 387                 }
 388                 rval = _Variant2PyObj(wv);
 389                 VariantClear(&v);
 390             }
 391         }
 392     done:
 393         wxPyEndBlockThreads(blocked);
 394         return rval;
 395     }
 396
 397
 398     // If both IsIn and isOut are false, assume it is actually an
 399     // input param
 400     bool paramIsIn(const wxParamX& p)
 401     {
 402         return p.IsIn() || (!p.IsIn() && !p.IsOut());
 403     }
 404
 405
 406     // Call a method of the ActiveX object
 407     PyObject* _CallAXMethod(const wxString& name, PyObject* args)
 408     {
 409         VARIANTARG *vargs = NULL;
 410         int nargs = 0;
 411         PyObject* rval = NULL;
 412         const wxFuncX& func = GetAXMethodDesc(name);
 413
 414         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 415         if (! PyErr_Occurred() ) {
 416             nargs = func.params.size();
 417             if (nargs > 0)
 418                 vargs = new VARIANTARG[nargs];
 419
 420             if (vargs) {
 421                 // init type of vargs, in reverse order
 422                 int i;
 423                 for (i = 0; i < nargs; i++)
 424                     vargs[nargs - i - 1].vt = func.params[i].vt;
 425
 426                 // Map the args coming from Python to the input parameters in vargs
 427                 int pi = 0;
 428                 i = 0;
 429                 while ( i<nargs && pi<PyTuple_Size(args) ) {
 430                     // Move to the next input param.
 431                     if (! paramIsIn(func.params[i])) {
 432                         i += 1;
 433                         continue;
 434                     }
 435                     // convert the python object
 436                     PyObject* obj = PyTuple_GetItem(args, pi);
 437                     if (obj == Py_None) // special-case None?
 438                         vargs[nargs - i - 1].vt = VT_EMPTY;
 439                     else {
 440                         wxVariant wxV = _PyObj2Variant(obj);
 441                         if (PyErr_Occurred())
 442                             goto done;
 443                         if (!VariantToMSWVariant(wxV, vargs[nargs - i - 1]) || PyErr_Occurred()) {
 444                             wxString msg;
 445                             msg << _T("Unable to convert value to expected type: (")
 446                                 << _VARTYPEname(vargs[nargs - i - 1].vt)
 447                                 << _T(") for parameter ") << i;
 448                             PyErr_SetString(PyExc_TypeError, msg.mb_str());
 449                             goto done;
 450                         }
 451                     }
 452                     i += 1;
 453                     pi += 1;
 454                 }
 455             }
 456
 457             // call the method
 458             PyThreadState* tstate = wxPyBeginAllowThreads();
 459             VARIANT rv = CallMethod(func.memid, vargs, nargs);
 460             wxPyEndAllowThreads(tstate);
 461
 462             // Convert the return value and any out-params, ignoring
 463             // conversion errors for now
 464             wxVariant wv;
 465             MSWVariantToVariant(rv, wv);
 466             rval = _Variant2PyObj(wv, true);
 467             VariantClear(&rv);
 468
 469             if (func.hasOut) {
 470                 // make a list and put the rval in it if it is not None
 471                 PyObject* lst = PyList_New(0);
 472                 if (rval != Py_None)
 473                     PyList_Append(lst, rval);
 474                 else
 475                     Py_DECREF(rval);
 476
 477                 // find the out params and convert them
 478                 for (int i = 0; i < nargs; i++) {
 479                     VARIANTARG& va = vargs[nargs - i - 1];
 480                     const wxParamX &px = func.params[i];
 481                     if (px.IsOut()) {
 482                         MSWVariantToVariant(va, wv);
 483                         PyObject* obj = _Variant2PyObj(wv, true);
 484                         PyList_Append(lst, obj);
 485                     }
 486                 }
 487                 rval = PyList_AsTuple(lst);
 488                 Py_DECREF(lst);
 489             }
 490             if (PyErr_Occurred())
 491                 PyErr_Clear();
 492         }
 493     done:
 494         wxPyEndBlockThreads(blocked);
 495         if (vargs) {
 496             for (int i = 0; i < nargs; i++)
 497                 VariantClear(&vargs[i]);
 498             delete [] vargs;
 499         }
 500         return rval;
 501     }
 502 };
 503
 504 IMPLEMENT_ABSTRACT_CLASS( wxActiveXWindow, wxWindow );
 505 %}
 506
 507
 508
 509 // Now tell SWIG about this new class that is implemented above.
 510
 511 DocStr(wxActiveXWindow,
 512 "ActiveXWindow derives from wxWindow and the constructor accepts a
 513 CLSID for the ActiveX Control that should be created.  The
 514 ActiveXWindow class simply adds methods that allow you to query
 515 some of the TypeInfo exposed by the ActiveX object, and also to
 516 get/set properties or call methods by name.  The Python
 517 implementation automatically handles converting parameters and
 518 return values to/from the types expected by the ActiveX code as
 519 specified by the TypeInfo.
 520 ", "");
 521
 522
 523 MustHaveApp(wxActiveXWindow);
 524
 525 class wxActiveXWindow : public wxWindow
 526 {
 527 public:
 528     %pythonAppend wxActiveXWindow      "self._setOORInfo(self)"
 529
 530     DocCtorStr(
 531         wxActiveXWindow( wxWindow* parent, const CLSID& clsId, wxWindowID id = -1,
 532                          const wxPoint& pos = wxDefaultPosition,
 533                          const wxSize& size = wxDefaultSize,
 534                          long style = 0,
 535                          const wxString& name = wxPyPanelNameStr),
 536         "Creates an ActiveX control from the clsID given and makes it act
 537 as much like a regular wx.Window as possible.", "");
 538
 539     DocDeclStr(
 540         const CLSID& , GetCLSID() const,
 541         "Return the CLSID used to construct this ActiveX window", "");
 542
 543
 544     DocDeclStr(
 545         int , GetAXEventCount() const,
 546         "Number of events defined for this control", "");
 547
 548     DocDeclStr(
 549         const wxFuncX& , GetAXEventDesc(int idx) const,
 550         "Returns event description by index", "");
 551
 552
 553     DocDeclStr(
 554         int , GetAXPropCount() const,
 555         "Number of properties defined for this control", "");
 556
 557     %nokwargs GetAXPropDesc;
 558     DocStr(GetPropDesc, "Returns property description by index or by name", "");
 559     const wxPropX& GetAXPropDesc(int idx) const;
 560     const wxPropX& GetAXPropDesc(const wxString& name) const;
 561
 562
 563
 564     DocDeclStr(
 565         int , GetAXMethodCount() const,
 566         "Number of methods defined for this control", "");
 567
 568     %nokwargs GetAXMethodDesc;
 569     DocStr(GetMethodDesc, "Returns method description by index or name", "");
 570     const wxFuncX& GetAXMethodDesc(int idx) const;
 571     const wxFuncX& GetAXMethodDesc(const wxString& name) const;
 572
 573
 574     DocDeclStr(
 575         const wxFuncXArray& , GetAXEvents(),
 576         "Returns a sequence of FuncX objects describing the events
 577 available for this ActiveX object.", "");
 578
 579     DocDeclStr(
 580         const wxFuncXArray& , GetAXMethods(),
 581         "Returns a sequence of FuncX objects describing the methods
 582 available for this ActiveX object.", "");
 583
 584     DocDeclStr(
 585         const wxPropXArray& , GetAXProperties(),
 586         "Returns a sequence of PropX objects describing the properties
 587 available for this ActiveX object.", "");
 588
 589
 590
 591     DocDeclStr(
 592         void , SetAXProp(const wxString& name, PyObject* value),
 593         "Set a property of the ActiveX object by name.", "");
 594
 595
 596     DocDeclStr(
 597         PyObject* , GetAXProp(const wxString& name),
 598         "Get the value of an ActiveX property by name.", "");
 599
 600
 601     %nokwargs _CallAXMethod;
 602     DocDeclStr(
 603         PyObject* , _CallAXMethod(const wxString& name, PyObject* args),
 604         "The implementation for CallMethod.  Calls an ActiveX method, by
 605 name passing the parameters given in args.", "");
 606     %pythoncode {
 607         def CallAXMethod(self, name, *args):
 608             """
 609             Front-end for _CallMethod.  Simply passes all positional args
 610             after the name as a single tuple to _CallMethod.
 611             """
 612             return self._CallAXMethod(name, args)
 613     }
 614 };
 615
 616 //---------------------------------------------------------------------------
 617 %newgroup
 618
 619 DocDeclStr(
 620     wxEventType , RegisterActiveXEvent(const wxString& eventName),
 621     "Creates a standard wx event ID for the given eventName.", "");
 622
 623
 624
 625 DocStr(wxActiveXEvent,
 626 "An instance of ActiveXEvent is sent to the handler for all bound
 627 ActiveX events.  Any event parameters from the ActiveX cntrol are
 628 turned into attributes of the Python proxy for this event object.
 629 Additionally, there is a property called eventName that will
 630 return (surprisingly <wink>) the name of the ActiveX event.", "");
 631
 632 class wxActiveXEvent : public wxCommandEvent
 633 {
 634 public:
 635     %feature("shadow") EventName "eventName = property(_activex.ActiveXEvent_EventName)";
 636     wxString EventName();
 637
 638     %extend {
 639
 640         // This is called by the EventThunker before calling the
 641         // handler. We'll convert and load the ActiveX event parameters into
 642         // attributes of the Python event object.
 643         void _preCallInit(PyObject* pyself) {
 644             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 645             PyObject* pList = PyList_New(0);
 646             PyObject_SetAttrString(pyself, "paramList", pList);
 647             Py_DECREF(pList);
 648             for (int i=0; i<self->ParamCount(); i+=1) {
 649                 PyObject* name = PyString_FromString((char*)(const char*)self->ParamName(i).mb_str());
 650                 PyObject* val = _Variant2PyObj((*self)[i], true);
 651                 PyObject_SetAttr(pyself, name, val);
 652                 PyList_Append(pList, name);
 653                 Py_DECREF(val);
 654                 Py_DECREF(name);
 655             }
 656             wxPyEndBlockThreads(blocked);
 657         }
 658
 659         // This one is called by the EventThunker after calling the
 660         // handler. It reloads any "out" parameters from the python attributes
 661         // back into the wxVariant they came from.
 662         void _postCallCleanup(PyObject* pyself) {
 663             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 664             for (int i=0; i<self->ParamCount(); i+=1) {
 665                 PyObject* val = PyObject_GetAttrString(
 666                     pyself, (char*)(const char*)self->ParamName(i).mb_str());
 667                 _PyObj2Variant(val, (*self)[i]);
 668                 Py_DECREF(val);
 669             }
 670             wxPyEndBlockThreads(blocked);
 671         }
 672
 673
 674     }
 675 };
 676
 677 //---------------------------------------------------------------------------
 678
 679 %{
 680
 681 // Caller should already have the GIL!
 682 wxVariant _PyObj2Variant(PyObject* value)
 683 {
 684     wxVariant rval;
 685
 686     if (value == Py_None)
 687         return rval;
 688
 689 #if PYTHON_API_VERSION >= 1012  // Python 2.3+
 690     else if (PyBool_Check(value))
 691         rval = (value == Py_True) ? true : false;
 692 #endif
 693
 694     else if (PyInt_Check(value))
 695         rval = PyInt_AS_LONG(value);
 696
 697     else if (PyFloat_Check(value))
 698         rval = PyFloat_AS_DOUBLE(value);
 699
 700     else if (PyString_Check(value) || PyUnicode_Check(value))
 701         rval = Py2wxString(value);
 702
 703     // TODO:    PyList of strings --> wxArrayString
 704     //          wxDateTime
 705     //          list of objects
 706     //          etc.
 707
 708     else {
 709         PyErr_SetString(PyExc_TypeError, "Unsupported object type in _PyObj2Variant");
 710         rval = (long)0;
 711     }
 712
 713     return rval;
 714 }
 715
 716 // This one uses the type of the variant to try and force the conversion
 717 bool  _PyObj2Variant(PyObject* value, wxVariant& wv)
 718 {
 719     wxString type = wv.GetType();
 720
 721     if ( type == _T("long") || type == _T("bool") || type == _T("char") )
 722         wv = PyInt_AsLong(value);
 723
 724     else if ( type == _T("string") )
 725         wv = Py2wxString(value);
 726
 727     else if ( type == _T("double") )
 728         wv  = PyFloat_AsDouble(value);
 729
 730     else {
 731         // it's some other type that we dont' handle yet.  Log it?
 732         return false;
 733     }
 734     return true;
 735 }
 736
 737 // Caller should already have the GIL!
 738 PyObject* _Variant2PyObj(wxVariant& value, bool useNone)
 739 {
 740     PyObject* rval = NULL;
 741
 742     if (value.IsNull()) {
 743         rval = Py_None;
 744         Py_INCREF(rval);
 745     }
 746
 747     // should "char" be treated as an int or as a string?
 748     else if (value.IsType(_T("char")) || value.IsType(_T("long")))
 749         rval = PyInt_FromLong(value);
 750
 751     else if (value.IsType(_T("double")))
 752         rval = PyFloat_FromDouble(value);
 753
 754     else if (value.IsType(_T("bool"))) {
 755         rval = (bool)value ? Py_True : Py_False;
 756         Py_INCREF(rval);
 757     }
 758
 759     else if (value.IsType(_T("string")))
 760         rval = wx2PyString(value);
 761
 762     else {
 763         if (useNone) {
 764             rval = Py_None;
 765             Py_INCREF(rval);
 766         }
 767         else {
 768             PyErr_SetString(PyExc_TypeError, "Unsupported object type in _Variant2PyObj");
 769         }
 770     }
 771     return rval;
 772 }
 773
 774
 775 wxString _VARTYPEname(VARTYPE vt)
 776 {
 777     if (vt & VT_BYREF)
 778         vt &= ~(VT_BYREF);
 779
 780     switch(vt) {
 781     case VT_VARIANT:
 782         return _T("VT_VARIANT");
 783
 784     // 1 byte chars
 785     case VT_I1:
 786     case VT_UI1:
 787     // 2 byte shorts
 788     case VT_I2:
 789     case VT_UI2:
 790     // 4 bytes longs
 791     case VT_I4:
 792     case VT_UI4:
 793     case VT_INT:
 794     case VT_UINT:
 795     case VT_ERROR:
 796         return _T("int");
 797
 798     // 4 byte floats
 799     case VT_R4:
 800     // 8 byte doubles
 801     case VT_R8:
 802     // decimals are converted from doubles too
 803     case VT_DECIMAL:
 804         return _T("double");
 805
 806     case VT_BOOL:
 807         return _T("bool");
 808
 809     case VT_DATE:
 810         return _T("wx.DateTime");
 811
 812     case VT_BSTR:
 813         return _T("string");
 814
 815     case VT_UNKNOWN:
 816         return _T("VT_UNKNOWN");
 817
 818     case VT_DISPATCH:
 819         return _T("VT_DISPATCH");
 820
 821     case VT_EMPTY:
 822         return _T("VT_EMPTY");
 823
 824     case VT_NULL:
 825         return _T("VT_NULL");
 826
 827     case VT_VOID:
 828         return _T("VT_VOID");
 829
 830     default:
 831         wxString msg;
 832         msg << _T("unsupported type ") << vt;
 833         return msg;
 834     }
 835 }
 836
 837 %}
 838
 839 //---------------------------------------------------------------------------
 840 //---------------------------------------------------------------------------
 841 %newgroup
 842
 843
 844 %{
 845 // A class derived from our wxActiveXWindow for the IE WebBrowser
 846 // control that will serve as a base class for a Python
 847 // implementation.  This is done so we can "eat our own dog food"
 848 // and use a class at least mostly generated by genaxmodule, but
 849 // also get some of the extra stuff like loading a document from
 850 // a string or a stream, getting text contents, etc. that
 851 // Lindsay's version gives us.
 852 //
 853
 854 #include <wx/mstream.h>
 855 #include <oleidl.h>
 856 #include <winerror.h>
 857 #include <exdispid.h>
 858 #include <exdisp.h>
 859 #include <olectl.h>
 860 #include <Mshtml.h>
 861 #include <sstream>
 862
 863 #include "IEHtmlStream.h"
 864
 865 class wxIEHtmlWindowBase : public wxActiveXWindow {
 866 private:
 867     wxAutoOleInterface<IWebBrowser2>  m_webBrowser;
 868
 869     DECLARE_ABSTRACT_CLASS(wxIEHtmlWindowBase);
 870
 871 public:
 872
 873     wxIEHtmlWindowBase ( wxWindow* parent, const CLSID& clsId, wxWindowID id = -1,
 874                          const wxPoint& pos = wxDefaultPosition,
 875                          const wxSize& size = wxDefaultSize,
 876                          long style = 0,
 877                          const wxString& name = wxPyPanelNameStr)
 878         : wxActiveXWindow(parent, clsId, id, pos, size, style, name)
 879     {
 880         HRESULT hret;
 881
 882         // Get IWebBrowser2 Interface
 883         hret = m_webBrowser.QueryInterface(IID_IWebBrowser2, m_ActiveX);
 884         wxASSERT(SUCCEEDED(hret));
 885
 886         // web browser setup
 887         m_webBrowser->put_MenuBar(VARIANT_FALSE);
 888         m_webBrowser->put_AddressBar(VARIANT_FALSE);
 889         m_webBrowser->put_StatusBar(VARIANT_FALSE);
 890         m_webBrowser->put_ToolBar(VARIANT_FALSE);
 891
 892         m_webBrowser->put_RegisterAsBrowser(VARIANT_TRUE);
 893         m_webBrowser->put_RegisterAsDropTarget(VARIANT_TRUE);
 894
 895         m_webBrowser->Navigate( L"about:blank", NULL, NULL, NULL, NULL );
 896     }
 897
 898
 899     void SetCharset(const wxString& charset)
 900     {
 901         HRESULT hret;
 902
 903         // HTML Document ?
 904         IDispatch *pDisp = NULL;
 905         hret = m_webBrowser->get_Document(&pDisp);
 906         wxAutoOleInterface<IDispatch> disp(pDisp);
 907
 908         if (disp.Ok())
 909         {
 910             wxAutoOleInterface<IHTMLDocument2> doc(IID_IHTMLDocument2, disp);
 911             if (doc.Ok())
 912                 doc->put_charset((BSTR) (const wchar_t *) charset.wc_str(wxConvUTF8));
 913             //doc->put_charset((BSTR) wxConvUTF8.cMB2WC(charset).data());
 914         }
 915     }
 916
 917
 918     bool LoadString(const wxString& html)
 919     {
 920         char *data = NULL;
 921         size_t len = html.length();
 922         len *= sizeof(wxChar);
 923         data = (char *) malloc(len);
 924         memcpy(data, html.c_str(), len);
 925         return LoadStream(new wxOwnedMemInputStream(data, len));
 926     }
 927
 928
 929     bool LoadStream(IStreamAdaptorBase *pstrm)
 930     {
 931         // need to prepend this as poxy MSHTML will not recognise a HTML comment
 932         // as starting a html document and treats it as plain text
 933         // Does nayone know how to force it to html mode ?
 934 #if wxUSE_UNICODE
 935         // TODO: What to do in this case???
 936 #else
 937         pstrm->prepend = _T("<html>");
 938 #endif
 939
 940         // strip leading whitespace as it can confuse MSHTML
 941         wxAutoOleInterface<IStream> strm(pstrm);
 942
 943         // Document Interface
 944         IDispatch *pDisp = NULL;
 945         HRESULT hret = m_webBrowser->get_Document(&pDisp);
 946         if (! pDisp)
 947             return false;
 948         wxAutoOleInterface<IDispatch> disp(pDisp);
 949
 950
 951         // get IPersistStreamInit
 952         wxAutoOleInterface<IPersistStreamInit>
 953             pPersistStreamInit(IID_IPersistStreamInit, disp);
 954
 955         if (pPersistStreamInit.Ok())
 956         {
 957             HRESULT hr = pPersistStreamInit->InitNew();
 958             if (SUCCEEDED(hr))
 959                 hr = pPersistStreamInit->Load(strm);
 960
 961             return SUCCEEDED(hr);
 962         }
 963         else
 964             return false;
 965     }
 966
 967     bool LoadStream(wxInputStream *is)
 968     {
 969         // wrap reference around stream
 970         IwxStreamAdaptor *pstrm = new IwxStreamAdaptor(is);
 971         pstrm->AddRef();
 972
 973         return LoadStream(pstrm);
 974     }
 975
 976
 977     wxString GetStringSelection(bool asHTML)
 978     {
 979         wxAutoOleInterface<IHTMLTxtRange> tr(wxieGetSelRange(m_oleObject));
 980         if (! tr)
 981             return wxEmptyString;
 982
 983         BSTR text = NULL;
 984         HRESULT hr = E_FAIL;
 985
 986         if (asHTML)
 987             hr = tr->get_htmlText(&text);
 988         else
 989             hr = tr->get_text(&text);
 990         if (hr != S_OK)
 991             return wxEmptyString;
 992
 993         wxString s = text;
 994         SysFreeString(text);
 995
 996         return s;
 997     };
 998
 999     wxString GetText(bool asHTML)
1000     {
1001         if (! m_webBrowser.Ok())
1002             return wxEmptyString;
1003
1004         // get document dispatch interface
1005         IDispatch *iDisp = NULL;
1006         HRESULT hr = m_webBrowser->get_Document(&iDisp);
1007         if (hr != S_OK)
1008             return wxEmptyString;
1009
1010         // Query for Document Interface
1011         wxAutoOleInterface<IHTMLDocument2> hd(IID_IHTMLDocument2, iDisp);
1012         iDisp->Release();
1013
1014         if (! hd.Ok())
1015             return wxEmptyString;
1016
1017         // get body element
1018         IHTMLElement *_body = NULL;
1019         hd->get_body(&_body);
1020         if (! _body)
1021             return wxEmptyString;
1022         wxAutoOleInterface<IHTMLElement> body(_body);
1023
1024         // get inner text
1025         BSTR text = NULL;
1026         hr = E_FAIL;
1027
1028         if (asHTML)
1029             hr = body->get_innerHTML(&text);
1030         else
1031             hr = body->get_innerText(&text);
1032         if (hr != S_OK)
1033             return wxEmptyString;
1034
1035         wxString s = text;
1036         SysFreeString(text);
1037
1038         return s;
1039     }
1040
1041
1042 //     void wxIEHtmlWin::SetEditMode(bool seton)
1043 //     {
1044 //         m_bAmbientUserMode = ! seton;
1045 //         AmbientPropertyChanged(DISPID_AMBIENT_USERMODE);
1046 //     };
1047
1048 //     bool wxIEHtmlWin::GetEditMode()
1049 //     {
1050 //         return ! m_bAmbientUserMode;
1051 //     };
1052 };
1053
1054 IMPLEMENT_ABSTRACT_CLASS( wxIEHtmlWindowBase, wxActiveXWindow );
1055
1056 %}
1057
1058
1059 // we'll document it in the derived Python class
1060 %feature("noautodoc") wxIEHtmlWindowBase;
1061 %feature("noautodoc") wxIEHtmlWindowBase::SetCharset;
1062 %feature("noautodoc") wxIEHtmlWindowBase::LoadString;
1063 %feature("noautodoc") wxIEHtmlWindowBase::LoadStream;
1064 %feature("noautodoc") wxIEHtmlWindowBase::GetStringSelection;
1065 %feature("noautodoc") wxIEHtmlWindowBase::GetText;
1066
1067
1068 MustHaveApp(wxIEHtmlWindowBase);
1069
1070 class wxIEHtmlWindowBase : public wxActiveXWindow {
1071 public:
1072     %pythonAppend wxIEHtmlWindowBase    "self._setOORInfo(self)"
1073
1074     wxIEHtmlWindowBase ( wxWindow* parent, const CLSID& clsId, wxWindowID id = -1,
1075                          const wxPoint& pos = wxDefaultPosition,
1076                          const wxSize& size = wxDefaultSize,
1077                          long style = 0,
1078                          const wxString& name = wxPyPanelNameStr);
1079
1080     void SetCharset(const wxString& charset);
1081     bool LoadString(const wxString& html);
1082     bool LoadStream(wxInputStream *is);
1083     wxString GetStringSelection(bool asHTML);
1084     wxString GetText(bool asHTML);
1085 };
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097 #if 0
1098 enum wxIEHtmlRefreshLevel
1099 {
1100     wxIEHTML_REFRESH_NORMAL = 0,
1101     wxIEHTML_REFRESH_IFEXPIRED = 1,
1102     wxIEHTML_REFRESH_CONTINUE = 2,
1103     wxIEHTML_REFRESH_COMPLETELY = 3
1104 };
1105
1106 DocStr(wxIEHtmlWin,
1107 "");
1108 class wxIEHtmlWin : public wxWindow
1109 {
1110 public:
1111     %pythonAppend wxIEHtmlWin      "self._setOORInfo(self)"
1112
1113     wxIEHtmlWin(wxWindow * parent, wxWindowID id = -1,
1114                 const wxPoint& pos = wxDefaultPosition,
1115                 const wxSize& size = wxDefaultSize,
1116                 long style = 0,
1117                 const wxString& name = wxPyPanelNameStr);
1118
1119     void LoadUrl(const wxString& url);
1120     bool LoadString(wxString html);
1121     bool LoadStream(wxInputStream *is);
1122
1123     %pythoncode { Navigate = LoadUrl }
1124
1125     void SetCharset(wxString charset);
1126     void SetEditMode(bool seton);
1127     bool GetEditMode();
1128     wxString GetStringSelection(bool asHTML = false);
1129     wxString GetText(bool asHTML = false);
1130
1131     bool GoBack();
1132     bool GoForward();
1133     bool GoHome();
1134     bool GoSearch();
1135     %name(RefreshPage)bool Refresh(wxIEHtmlRefreshLevel level);
1136     bool Stop();
1137 };
1138
1139
1140
1141 %pythoncode {
1142 wxEVT_COMMAND_MSHTML_BEFORENAVIGATE2  = RegisterActiveXEvent('BeforeNavigate2')
1143 wxEVT_COMMAND_MSHTML_NEWWINDOW2       = RegisterActiveXEvent('NewWindow2')
1144 wxEVT_COMMAND_MSHTML_DOCUMENTCOMPLETE = RegisterActiveXEvent('DocumentComplete')
1145 wxEVT_COMMAND_MSHTML_PROGRESSCHANGE   = RegisterActiveXEvent('ProgressChange')
1146 wxEVT_COMMAND_MSHTML_STATUSTEXTCHANGE = RegisterActiveXEvent('StatusTextChange')
1147 wxEVT_COMMAND_MSHTML_TITLECHANGE      = RegisterActiveXEvent('TitleChange')
1148
1149 EVT_MSHTML_BEFORENAVIGATE2      = wx.PyEventBinder(wxEVT_COMMAND_MSHTML_BEFORENAVIGATE2, 1)
1150 EVT_MSHTML_NEWWINDOW2           = wx.PyEventBinder(wxEVT_COMMAND_MSHTML_NEWWINDOW2, 1)
1151 EVT_MSHTML_DOCUMENTCOMPLETE     = wx.PyEventBinder(wxEVT_COMMAND_MSHTML_DOCUMENTCOMPLETE, 1)
1152 EVT_MSHTML_PROGRESSCHANGE       = wx.PyEventBinder(wxEVT_COMMAND_MSHTML_PROGRESSCHANGE, 1)
1153 EVT_MSHTML_STATUSTEXTCHANGE     = wx.PyEventBinder(wxEVT_COMMAND_MSHTML_STATUSTEXTCHANGE, 1)
1154 EVT_MSHTML_TITLECHANGE          = wx.PyEventBinder(wxEVT_COMMAND_MSHTML_TITLECHANGE, 1)
1155 }
1156
1157 #endif
1158
1159 //---------------------------------------------------------------------------
1160 // Include some extra Python code into the proxy module
1161
1162 %pythoncode "_activex_ex.py"
1163
1164 //---------------------------------------------------------------------------