]>
Commit | Line | Data |
---|---|---|
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 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__ } | |
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 | bool 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 | public: | |
244 | wxActiveXWindow( wxWindow* parent, const CLSID& clsId, wxWindowID id = -1, | |
245 | const wxPoint& pos = wxDefaultPosition, | |
246 | const wxSize& size = wxDefaultSize, | |
247 | long style = 0, | |
248 | const wxString& name = wxPyPanelNameStr) | |
249 | : wxActiveX(parent, clsId, id, pos, size, style, name) | |
250 | { | |
251 | m_CLSID = clsId; | |
252 | } | |
253 | ||
254 | const CLSID& GetCLSID() const { return m_CLSID; } | |
255 | ||
256 | ||
257 | // Renamed versions of some base class methods that delegate | |
258 | // to the base where appropriate, and raise Python exceptions | |
259 | // when needed. | |
260 | int GetAXEventCount() const { return wxActiveX::GetEventCount(); } | |
261 | int GetAXPropCount() const { return wxActiveX::GetPropCount(); } | |
262 | int GetAXMethodCount() const { return wxActiveX::GetMethodCount(); } | |
263 | ||
264 | const wxFuncX& GetAXEventDesc(int idx) const | |
265 | { | |
266 | static wxFuncX BadVal; | |
267 | if (idx < 0 || idx >= GetAXEventCount()) { | |
268 | wxPyErr_SetString(PyExc_IndexError, "Index out of range"); | |
269 | return BadVal; | |
270 | } | |
271 | return m_events[idx]; | |
272 | } | |
273 | const wxFuncX& GetAXMethodDesc(int idx) const | |
274 | { | |
275 | static wxFuncX BadVal; | |
276 | if (idx < 0 || idx >= GetAXMethodCount()) { | |
277 | wxPyErr_SetString(PyExc_IndexError, "Index out of range"); | |
278 | return BadVal; | |
279 | } | |
280 | return m_methods[idx]; | |
281 | } | |
282 | const wxPropX& GetAXPropDesc(int idx) const | |
283 | { | |
284 | static wxPropX BadVal; | |
285 | if (idx < 0 || idx >= GetAXPropCount()) { | |
286 | wxPyErr_SetString(PyExc_IndexError, "Index out of range"); | |
287 | return BadVal; | |
288 | } | |
289 | return m_props[idx]; | |
290 | } | |
291 | ||
292 | const wxFuncX& GetAXMethodDesc(const wxString& name) const | |
293 | { | |
294 | NameMap::const_iterator it = m_methodNames.find(name); | |
295 | if (it == m_methodNames.end()) { | |
296 | wxString msg; | |
297 | msg << _T("method <") << name << _T("> not found"); | |
298 | wxPyErr_SetString(PyExc_KeyError, msg.mb_str()); | |
299 | static wxFuncX BadVal; | |
300 | return BadVal; | |
301 | }; | |
302 | return GetAXMethodDesc(it->second); | |
303 | } | |
304 | const wxPropX& GetAXPropDesc(const wxString& name) const | |
305 | { | |
306 | NameMap::const_iterator it = m_propNames.find(name); | |
307 | if (it == m_propNames.end()) { | |
308 | wxString msg; | |
309 | msg << _T("property <") << name << _T("> not found"); | |
310 | wxPyErr_SetString(PyExc_KeyError, msg.mb_str()); | |
311 | static wxPropX BadVal; | |
312 | return BadVal; | |
313 | }; | |
314 | return GetAXPropDesc(it->second); | |
315 | } | |
316 | ||
317 | // Accessors for the internal vectors of events, methods and | |
318 | // proprties. Can be used as sequence like objects from | |
319 | // Python. | |
320 | const wxFuncXArray& GetAXEvents() { return m_events; } | |
321 | const wxFuncXArray& GetAXMethods() { return m_methods; } | |
322 | const wxPropXArray& GetAXProperties() { return m_props; } | |
323 | ||
324 | ||
325 | // Set a property from a Python object | |
326 | void SetAXProp(const wxString& name, PyObject* value) | |
327 | { | |
328 | const wxPropX& prop = GetAXPropDesc(name); | |
329 | bool blocked = wxPyBeginBlockThreads(); | |
330 | if (! PyErr_Occurred() ) { | |
331 | if (! prop.CanSet()) { | |
332 | wxString msg; | |
333 | msg << _T("property <") << name << _T("> is readonly"); | |
334 | PyErr_SetString(PyExc_TypeError, msg.mb_str()); | |
335 | goto done; | |
336 | } else { | |
337 | wxVariant wxV = _PyObj2Variant(value); | |
338 | if (PyErr_Occurred()) | |
339 | goto done; | |
340 | VARIANT v = {prop.arg.vt}; | |
341 | if (!VariantToMSWVariant(wxV, v) || PyErr_Occurred()) { | |
342 | wxString msg; | |
343 | msg << _T("Unable to convert value to expected type: (") | |
344 | << _VARTYPEname(prop.arg.vt) << _T(") for property <") | |
345 | << name << _T(">"); | |
346 | PyErr_SetString(PyExc_TypeError, msg.mb_str()); | |
347 | goto done; | |
348 | } | |
349 | PyThreadState* tstate = wxPyBeginAllowThreads(); | |
350 | SetProp(prop.memid, v); | |
351 | VariantClear(&v); | |
352 | wxPyEndAllowThreads(tstate); | |
353 | } | |
354 | } | |
355 | done: | |
356 | wxPyEndBlockThreads(blocked); | |
357 | } | |
358 | ||
359 | ||
360 | // Get a property and convert it to a Python object | |
361 | PyObject* GetAXProp(const wxString& name) | |
362 | { | |
363 | PyObject* rval = NULL; | |
364 | const wxPropX& prop = GetAXPropDesc(name); | |
365 | bool blocked = wxPyBeginBlockThreads(); | |
366 | if (! PyErr_Occurred() ) { | |
367 | if (! prop.CanGet()) { | |
368 | wxString msg; | |
369 | msg << _T("property <") << name << _T("> is writeonly"); | |
370 | PyErr_SetString(PyExc_TypeError, msg.mb_str()); | |
371 | goto done; | |
372 | } else { | |
373 | PyThreadState* tstate = wxPyBeginAllowThreads(); | |
374 | VARIANT v = GetPropAsVariant(prop.memid); | |
375 | wxPyEndAllowThreads(tstate); | |
376 | wxVariant wv; | |
377 | if (!MSWVariantToVariant(v, wv) || PyErr_Occurred()) { | |
378 | wxString msg; | |
379 | msg << _T("Unable to convert value to expected type: (") | |
380 | << _VARTYPEname(prop.arg.vt) << _T(") for property <") | |
381 | << name << _T(">"); | |
382 | PyErr_SetString(PyExc_TypeError, msg.mb_str()); | |
383 | goto done; | |
384 | } | |
385 | rval = _Variant2PyObj(wv); | |
386 | VariantClear(&v); | |
387 | } | |
388 | } | |
389 | done: | |
390 | wxPyEndBlockThreads(blocked); | |
391 | return rval; | |
392 | } | |
393 | ||
394 | ||
395 | // If both IsIn and isOut are false, assume it is actually an | |
396 | // input param | |
397 | bool paramIsIn(const wxParamX& p) | |
398 | { | |
399 | return p.IsIn() || (!p.IsIn() && !p.IsOut()); | |
400 | } | |
401 | ||
402 | ||
403 | // Call a method of the ActiveX object | |
404 | PyObject* _CallAXMethod(const wxString& name, PyObject* args) | |
405 | { | |
406 | VARIANTARG *vargs = NULL; | |
407 | int nargs = 0; | |
408 | PyObject* rval = NULL; | |
409 | const wxFuncX& func = GetAXMethodDesc(name); | |
410 | ||
411 | bool blocked = wxPyBeginBlockThreads(); | |
412 | if (! PyErr_Occurred() ) { | |
413 | nargs = func.params.size(); | |
414 | if (nargs > 0) | |
415 | vargs = new VARIANTARG[nargs]; | |
416 | ||
417 | if (vargs) { | |
418 | // init type of vargs, in reverse order | |
419 | int i; | |
420 | for (i = 0; i < nargs; i++) | |
421 | vargs[nargs - i - 1].vt = func.params[i].vt; | |
422 | ||
423 | // Map the args coming from Python to the input parameters in vargs | |
424 | int pi = 0; | |
425 | i = 0; | |
426 | while ( i<nargs && pi<PyTuple_Size(args) ) { | |
427 | // Move to the next input param. | |
428 | if (! paramIsIn(func.params[i])) { | |
429 | i += 1; | |
430 | continue; | |
431 | } | |
432 | // convert the python object | |
433 | PyObject* obj = PyTuple_GetItem(args, pi); | |
434 | if (obj == Py_None) // special-case None? | |
435 | vargs[nargs - i - 1].vt = VT_EMPTY; | |
436 | else { | |
437 | wxVariant wxV = _PyObj2Variant(obj); | |
438 | if (PyErr_Occurred()) | |
439 | goto done; | |
440 | if (!VariantToMSWVariant(wxV, vargs[nargs - i - 1]) || PyErr_Occurred()) { | |
441 | wxString msg; | |
442 | msg << _T("Unable to convert value to expected type: (") | |
443 | << _VARTYPEname(vargs[nargs - i - 1].vt) | |
444 | << _T(") for parameter ") << i; | |
445 | PyErr_SetString(PyExc_TypeError, msg.mb_str()); | |
446 | goto done; | |
447 | } | |
448 | } | |
449 | i += 1; | |
450 | pi += 1; | |
451 | } | |
452 | } | |
453 | ||
454 | // call the method | |
455 | PyThreadState* tstate = wxPyBeginAllowThreads(); | |
456 | VARIANT rv = CallMethod(func.memid, vargs, nargs); | |
457 | wxPyEndAllowThreads(tstate); | |
458 | ||
459 | // Convert the return value and any out-params, ignoring | |
460 | // conversion errors for now | |
461 | wxVariant wv; | |
462 | MSWVariantToVariant(rv, wv); | |
463 | rval = _Variant2PyObj(wv, True); | |
464 | VariantClear(&rv); | |
465 | ||
466 | if (func.hasOut) { | |
467 | // make a list and put the rval in it if it is not None | |
468 | PyObject* lst = PyList_New(0); | |
469 | if (rval != Py_None) | |
470 | PyList_Append(lst, rval); | |
471 | else | |
472 | Py_DECREF(rval); | |
473 | ||
474 | // find the out params and convert them | |
475 | for (int i = 0; i < nargs; i++) { | |
476 | VARIANTARG& va = vargs[nargs - i - 1]; | |
477 | const wxParamX &px = func.params[i]; | |
478 | if (px.IsOut()) { | |
479 | MSWVariantToVariant(va, wv); | |
480 | PyObject* obj = _Variant2PyObj(wv, True); | |
481 | PyList_Append(lst, obj); | |
482 | } | |
483 | } | |
484 | rval = PyList_AsTuple(lst); | |
485 | Py_DECREF(lst); | |
486 | } | |
487 | if (PyErr_Occurred()) | |
488 | PyErr_Clear(); | |
489 | } | |
490 | done: | |
491 | wxPyEndBlockThreads(blocked); | |
492 | if (vargs) { | |
493 | for (int i = 0; i < nargs; i++) | |
494 | VariantClear(&vargs[i]); | |
495 | delete [] vargs; | |
496 | } | |
497 | return rval; | |
498 | } | |
499 | }; | |
500 | %} | |
501 | ||
502 | ||
503 | ||
504 | // Now tell SWIG about this new class that is implemented above. | |
505 | ||
506 | DocStr(wxActiveXWindow, | |
507 | "ActiveXWindow derives from wxWindow and the constructor accepts a | |
508 | CLSID for the ActiveX Control that should be created. The | |
509 | ActiveXWindow class simply adds methods that allow you to query | |
510 | some of the TypeInfo exposed by the ActiveX object, and also to | |
511 | get/set properties or call methods by name. The Python | |
512 | implementation automatically handles converting parameters and | |
513 | return values to/from the types expected by the ActiveX code as | |
514 | specified by the TypeInfo. | |
515 | "); | |
516 | ||
517 | ||
518 | class wxActiveXWindow : public wxWindow | |
519 | { | |
520 | public: | |
521 | %pythonAppend wxActiveXWindow "self._setOORInfo(self)" | |
522 | ||
523 | DocCtorStr( | |
524 | wxActiveXWindow( wxWindow* parent, const CLSID& clsId, wxWindowID id = -1, | |
525 | const wxPoint& pos = wxDefaultPosition, | |
526 | const wxSize& size = wxDefaultSize, | |
527 | long style = 0, | |
528 | const wxString& name = wxPyPanelNameStr), | |
529 | "Creates an ActiveX control from the clsID given and makes it act | |
530 | as much like a regular wx.Window as possible."); | |
531 | ||
532 | DocDeclStr( | |
533 | const CLSID& , GetCLSID() const, | |
534 | "Return the CLSID used to construct this ActiveX window"); | |
535 | ||
536 | ||
537 | DocDeclStr( | |
538 | int , GetAXEventCount() const, | |
539 | "Number of events defined for this control"); | |
540 | ||
541 | DocDeclStr( | |
542 | const wxFuncX& , GetAXEventDesc(int idx) const, | |
543 | "Returns event description by index"); | |
544 | ||
545 | ||
546 | DocDeclStr( | |
547 | int , GetAXPropCount() const, | |
548 | "Number of properties defined for this control"); | |
549 | ||
550 | %nokwargs GetAXPropDesc; | |
551 | DocStr(GetPropDesc, "Returns property description by index or by name"); | |
552 | const wxPropX& GetAXPropDesc(int idx) const; | |
553 | const wxPropX& GetAXPropDesc(const wxString& name) const; | |
554 | ||
555 | ||
556 | ||
557 | DocDeclStr( | |
558 | int , GetAXMethodCount() const, | |
559 | "Number of methods defined for this control"); | |
560 | ||
561 | %nokwargs GetAXMethodDesc; | |
562 | DocStr(GetMethodDesc, "Returns method description by index or name"); | |
563 | const wxFuncX& GetAXMethodDesc(int idx) const; | |
564 | const wxFuncX& GetAXMethodDesc(const wxString& name) const; | |
565 | ||
566 | ||
567 | DocDeclStr( | |
568 | const wxFuncXArray& , GetAXEvents(), | |
569 | "Returns a sequence of FuncX objects describing the events | |
570 | available for this ActiveX object."); | |
571 | ||
572 | DocDeclStr( | |
573 | const wxFuncXArray& , GetAXMethods(), | |
574 | "Returns a sequence of FuncX objects describing the methods | |
575 | available for this ActiveX object."); | |
576 | ||
577 | DocDeclStr( | |
578 | const wxPropXArray& , GetAXProperties(), | |
579 | "Returns a sequence of PropX objects describing the properties | |
580 | available for this ActiveX object."); | |
581 | ||
582 | ||
583 | ||
584 | DocDeclStr( | |
585 | void , SetAXProp(const wxString& name, PyObject* value), | |
586 | "Set a property of the ActiveX object by name."); | |
587 | ||
588 | ||
589 | DocDeclStr( | |
590 | PyObject* , GetAXProp(const wxString& name), | |
591 | "Get the value of an ActiveX property by name."); | |
592 | ||
593 | ||
594 | %nokwargs _CallAXMethod; | |
595 | DocDeclStr( | |
596 | PyObject* , _CallAXMethod(const wxString& name, PyObject* args), | |
597 | "The implementation for CallMethod. Calls an ActiveX method, by | |
598 | name passing the parameters given in args."); | |
599 | %pythoncode { | |
600 | def CallAXMethod(self, name, *args): | |
601 | """ | |
602 | Front-end for _CallMethod. Simply passes all positional args | |
603 | after the name as a single tuple to _CallMethod. | |
604 | """ | |
605 | return self._CallAXMethod(name, args) | |
606 | } | |
607 | }; | |
608 | ||
609 | //--------------------------------------------------------------------------- | |
610 | %newgroup | |
611 | ||
612 | DocDeclStr( | |
613 | wxEventType , RegisterActiveXEvent(const wxString& eventName), | |
614 | "Creates a standard wx event ID for the given eventName."); | |
615 | ||
616 | ||
617 | ||
618 | DocStr(wxActiveXEvent, | |
619 | "An instance of ActiveXEvent is sent to the handler for all bound | |
620 | ActiveX events. Any event parameters from the ActiveX cntrol are | |
621 | turned into attributes of the Python proxy for this event object. | |
622 | Additionally, there is a property called eventName that will | |
623 | return (suprizingly <wink>) the name of the ActiveX event."); | |
624 | ||
625 | class wxActiveXEvent : public wxCommandEvent | |
626 | { | |
627 | public: | |
628 | %feature("shadow") EventName "eventName = property(_activex.ActiveXEvent_EventName)"; | |
629 | wxString EventName(); | |
630 | ||
631 | %extend { | |
632 | ||
633 | // This is called by the EventThunker before calling the | |
634 | // handler. We'll convert and load the ActiveX event parameters into | |
635 | // attributes of the Python event object. | |
636 | void _preCallInit(PyObject* pyself) { | |
637 | bool blocked = wxPyBeginBlockThreads(); | |
638 | PyObject* pList = PyList_New(0); | |
639 | PyObject_SetAttrString(pyself, "paramList", pList); | |
640 | Py_DECREF(pList); | |
641 | for (int i=0; i<self->ParamCount(); i+=1) { | |
642 | PyObject* name = PyString_FromString((char*)(const char*)self->ParamName(i).mb_str()); | |
643 | PyObject* val = _Variant2PyObj((*self)[i], True); | |
644 | PyObject_SetAttr(pyself, name, val); | |
645 | PyList_Append(pList, name); | |
646 | Py_DECREF(val); | |
647 | Py_DECREF(name); | |
648 | } | |
649 | wxPyEndBlockThreads(blocked); | |
650 | } | |
651 | ||
652 | // This one is called by the EventThunker after calling the | |
653 | // handler. It reloads any "out" parameters from the python attributes | |
654 | // back into the wxVariant they came from. | |
655 | void _postCallCleanup(PyObject* pyself) { | |
656 | bool blocked = wxPyBeginBlockThreads(); | |
657 | for (int i=0; i<self->ParamCount(); i+=1) { | |
658 | PyObject* val = PyObject_GetAttrString( | |
659 | pyself, (char*)(const char*)self->ParamName(i).mb_str()); | |
660 | _PyObj2Variant(val, (*self)[i]); | |
661 | Py_DECREF(val); | |
662 | } | |
663 | wxPyEndBlockThreads(blocked); | |
664 | } | |
665 | ||
666 | ||
667 | } | |
668 | }; | |
669 | ||
670 | //--------------------------------------------------------------------------- | |
671 | ||
672 | %{ | |
673 | ||
674 | // Caller should already have the GIL! | |
675 | wxVariant _PyObj2Variant(PyObject* value) | |
676 | { | |
677 | wxVariant rval; | |
678 | ||
679 | if (value == Py_None) | |
680 | return rval; | |
681 | ||
682 | #if PYTHON_API_VERSION >= 1012 // Python 2.3+ | |
683 | else if (PyBool_Check(value)) | |
684 | rval = (value == Py_True) ? true : false; | |
685 | #endif | |
686 | ||
687 | else if (PyInt_Check(value)) | |
688 | rval = PyInt_AS_LONG(value); | |
689 | ||
690 | else if (PyFloat_Check(value)) | |
691 | rval = PyFloat_AS_DOUBLE(value); | |
692 | ||
693 | else if (PyString_Check(value) || PyUnicode_Check(value)) | |
694 | rval = Py2wxString(value); | |
695 | ||
696 | // TODO: PyList of strings --> wxArrayString | |
697 | // wxDateTime | |
698 | // list of objects | |
699 | // etc. | |
700 | ||
701 | else { | |
702 | PyErr_SetString(PyExc_TypeError, "Unsupported object type in _PyObj2Variant"); | |
703 | rval = (long)0; | |
704 | } | |
705 | ||
706 | return rval; | |
707 | } | |
708 | ||
709 | // This one uses the type of the variant to try and force the conversion | |
710 | bool _PyObj2Variant(PyObject* value, wxVariant& wv) | |
711 | { | |
712 | wxString type = wv.GetType(); | |
713 | ||
714 | if ( type == _T("long") || type == _T("bool") || type == _T("char") ) | |
715 | wv = PyInt_AsLong(value); | |
716 | ||
717 | else if ( type == _T("string") ) | |
718 | wv = Py2wxString(value); | |
719 | ||
720 | else if ( type == _T("double") ) | |
721 | wv = PyFloat_AsDouble(value); | |
722 | ||
723 | else { | |
724 | // it's some other type that we dont' handle yet. Log it? | |
725 | return false; | |
726 | } | |
727 | return true; | |
728 | } | |
729 | ||
730 | // Caller should already have the GIL! | |
731 | PyObject* _Variant2PyObj(wxVariant& value, bool useNone) | |
732 | { | |
733 | PyObject* rval = NULL; | |
734 | ||
735 | if (value.IsNull()) { | |
736 | rval = Py_None; | |
737 | Py_INCREF(rval); | |
738 | } | |
739 | ||
740 | // should "char" be treated as an int or as a string? | |
741 | else if (value.IsType(_T("char")) || value.IsType(_T("long"))) | |
742 | rval = PyInt_FromLong(value); | |
743 | ||
744 | else if (value.IsType(_T("double"))) | |
745 | rval = PyFloat_FromDouble(value); | |
746 | ||
747 | else if (value.IsType(_T("bool"))) { | |
748 | rval = (bool)value ? Py_True : Py_False; | |
749 | Py_INCREF(rval); | |
750 | } | |
751 | ||
752 | else if (value.IsType(_T("string"))) | |
753 | rval = wx2PyString(value); | |
754 | ||
755 | else { | |
756 | if (useNone) { | |
757 | rval = Py_None; | |
758 | Py_INCREF(rval); | |
759 | } | |
760 | else { | |
761 | PyErr_SetString(PyExc_TypeError, "Unsupported object type in _Variant2PyObj"); | |
762 | } | |
763 | } | |
764 | return rval; | |
765 | } | |
766 | ||
767 | ||
768 | wxString _VARTYPEname(VARTYPE vt) | |
769 | { | |
770 | if (vt & VT_BYREF) | |
771 | vt &= ~(VT_BYREF); | |
772 | ||
773 | switch(vt) { | |
774 | case VT_VARIANT: | |
775 | return _T("VT_VARIANT"); | |
776 | ||
777 | // 1 byte chars | |
778 | case VT_I1: | |
779 | case VT_UI1: | |
780 | // 2 byte shorts | |
781 | case VT_I2: | |
782 | case VT_UI2: | |
783 | // 4 bytes longs | |
784 | case VT_I4: | |
785 | case VT_UI4: | |
786 | case VT_INT: | |
787 | case VT_UINT: | |
788 | case VT_ERROR: | |
789 | return _T("int"); | |
790 | ||
791 | // 4 byte floats | |
792 | case VT_R4: | |
793 | // 8 byte doubles | |
794 | case VT_R8: | |
795 | // decimals are converted from doubles too | |
796 | case VT_DECIMAL: | |
797 | return _T("double"); | |
798 | ||
799 | case VT_BOOL: | |
800 | return _T("bool"); | |
801 | ||
802 | case VT_DATE: | |
803 | return _T("wx.DateTime"); | |
804 | ||
805 | case VT_BSTR: | |
806 | return _T("string"); | |
807 | ||
808 | case VT_UNKNOWN: | |
809 | return _T("VT_UNKNOWN"); | |
810 | ||
811 | case VT_DISPATCH: | |
812 | return _T("VT_DISPATCH"); | |
813 | ||
814 | case VT_EMPTY: | |
815 | return _T("VT_EMPTY"); | |
816 | ||
817 | case VT_NULL: | |
818 | return _T("VT_NULL"); | |
819 | ||
820 | case VT_VOID: | |
821 | return _T("VT_VOID"); | |
822 | ||
823 | default: | |
824 | wxString msg; | |
825 | msg << _T("unsupported type ") << vt; | |
826 | return msg; | |
827 | } | |
828 | } | |
829 | ||
830 | %} | |
831 | ||
832 | //--------------------------------------------------------------------------- | |
833 | //--------------------------------------------------------------------------- | |
834 | %newgroup | |
835 | ||
836 | ||
837 | %{ | |
838 | // A class derived from out wxActiveXWindow for the IE WebBrowser | |
839 | // control that will serve as a base class for a Python | |
840 | // implementation. This is done so we can "eat our own dog food" | |
841 | // and use a class at least mostly generated by genaxmodule, but | |
842 | // also get some of the extra stuff like loading a document from | |
843 | // a string or a stream, getting text contents, etc. that | |
844 | // Lindsay's version gives us. | |
845 | // | |
846 | ||
847 | #include <wx/mstream.h> | |
848 | #include <oleidl.h> | |
849 | #include <winerror.h> | |
850 | #include <exdispid.h> | |
851 | #include <exdisp.h> | |
852 | #include <olectl.h> | |
853 | #include <Mshtml.h> | |
854 | #include <sstream> | |
855 | ||
856 | #include "IEHtmlStream.h" | |
857 | ||
858 | class wxIEHtmlWindowBase : public wxActiveXWindow { | |
859 | private: | |
860 | wxAutoOleInterface<IWebBrowser2> m_webBrowser; | |
861 | ||
862 | public: | |
863 | ||
864 | wxIEHtmlWindowBase ( wxWindow* parent, const CLSID& clsId, wxWindowID id = -1, | |
865 | const wxPoint& pos = wxDefaultPosition, | |
866 | const wxSize& size = wxDefaultSize, | |
867 | long style = 0, | |
868 | const wxString& name = wxPyPanelNameStr) | |
869 | : wxActiveXWindow(parent, clsId, id, pos, size, style, name) | |
870 | { | |
871 | HRESULT hret; | |
872 | ||
873 | // Get IWebBrowser2 Interface | |
874 | hret = m_webBrowser.QueryInterface(IID_IWebBrowser2, m_ActiveX); | |
875 | wxASSERT(SUCCEEDED(hret)); | |
876 | ||
877 | // web browser setup | |
878 | m_webBrowser->put_MenuBar(VARIANT_FALSE); | |
879 | m_webBrowser->put_AddressBar(VARIANT_FALSE); | |
880 | m_webBrowser->put_StatusBar(VARIANT_FALSE); | |
881 | m_webBrowser->put_ToolBar(VARIANT_FALSE); | |
882 | ||
883 | m_webBrowser->put_RegisterAsBrowser(VARIANT_TRUE); | |
884 | m_webBrowser->put_RegisterAsDropTarget(VARIANT_TRUE); | |
885 | ||
886 | m_webBrowser->Navigate( L"about:blank", NULL, NULL, NULL, NULL ); | |
887 | } | |
888 | ||
889 | ||
890 | void SetCharset(const wxString& charset) | |
891 | { | |
892 | HRESULT hret; | |
893 | ||
894 | // HTML Document ? | |
895 | IDispatch *pDisp = NULL; | |
896 | hret = m_webBrowser->get_Document(&pDisp); | |
897 | wxAutoOleInterface<IDispatch> disp(pDisp); | |
898 | ||
899 | if (disp.Ok()) | |
900 | { | |
901 | wxAutoOleInterface<IHTMLDocument2> doc(IID_IHTMLDocument2, disp); | |
902 | if (doc.Ok()) | |
903 | doc->put_charset((BSTR) (const wchar_t *) charset.wc_str(wxConvUTF8)); | |
904 | //doc->put_charset((BSTR) wxConvUTF8.cMB2WC(charset).data()); | |
905 | } | |
906 | } | |
907 | ||
908 | ||
909 | bool LoadString(const wxString& html) | |
910 | { | |
911 | char *data = NULL; | |
912 | size_t len = html.length(); | |
913 | len *= sizeof(wxChar); | |
914 | data = (char *) malloc(len); | |
915 | memcpy(data, html.c_str(), len); | |
916 | return LoadStream(new wxOwnedMemInputStream(data, len)); | |
917 | } | |
918 | ||
919 | ||
920 | bool LoadStream(IStreamAdaptorBase *pstrm) | |
921 | { | |
922 | // need to prepend this as poxy MSHTML will not recognise a HTML comment | |
923 | // as starting a html document and treats it as plain text | |
924 | // Does nayone know how to force it to html mode ? | |
925 | #if wxUSE_UNICODE | |
926 | // TODO: What to do in this case??? | |
927 | #else | |
928 | pstrm->prepend = _T("<html>"); | |
929 | #endif | |
930 | ||
931 | // strip leading whitespace as it can confuse MSHTML | |
932 | wxAutoOleInterface<IStream> strm(pstrm); | |
933 | ||
934 | // Document Interface | |
935 | IDispatch *pDisp = NULL; | |
936 | HRESULT hret = m_webBrowser->get_Document(&pDisp); | |
937 | if (! pDisp) | |
938 | return false; | |
939 | wxAutoOleInterface<IDispatch> disp(pDisp); | |
940 | ||
941 | ||
942 | // get IPersistStreamInit | |
943 | wxAutoOleInterface<IPersistStreamInit> | |
944 | pPersistStreamInit(IID_IPersistStreamInit, disp); | |
945 | ||
946 | if (pPersistStreamInit.Ok()) | |
947 | { | |
948 | HRESULT hr = pPersistStreamInit->InitNew(); | |
949 | if (SUCCEEDED(hr)) | |
950 | hr = pPersistStreamInit->Load(strm); | |
951 | ||
952 | return SUCCEEDED(hr); | |
953 | } | |
954 | else | |
955 | return false; | |
956 | } | |
957 | ||
958 | bool LoadStream(wxInputStream *is) | |
959 | { | |
960 | // wrap reference around stream | |
961 | IwxStreamAdaptor *pstrm = new IwxStreamAdaptor(is); | |
962 | pstrm->AddRef(); | |
963 | ||
964 | return LoadStream(pstrm); | |
965 | } | |
966 | ||
967 | ||
968 | wxString GetStringSelection(bool asHTML) | |
969 | { | |
970 | wxAutoOleInterface<IHTMLTxtRange> tr(wxieGetSelRange(m_oleObject)); | |
971 | if (! tr) | |
972 | return wxEmptyString; | |
973 | ||
974 | BSTR text = NULL; | |
975 | HRESULT hr = E_FAIL; | |
976 | ||
977 | if (asHTML) | |
978 | hr = tr->get_htmlText(&text); | |
979 | else | |
980 | hr = tr->get_text(&text); | |
981 | if (hr != S_OK) | |
982 | return wxEmptyString; | |
983 | ||
984 | wxString s = text; | |
985 | SysFreeString(text); | |
986 | ||
987 | return s; | |
988 | }; | |
989 | ||
990 | wxString GetText(bool asHTML) | |
991 | { | |
992 | if (! m_webBrowser.Ok()) | |
993 | return wxEmptyString; | |
994 | ||
995 | // get document dispatch interface | |
996 | IDispatch *iDisp = NULL; | |
997 | HRESULT hr = m_webBrowser->get_Document(&iDisp); | |
998 | if (hr != S_OK) | |
999 | return wxEmptyString; | |
1000 | ||
1001 | // Query for Document Interface | |
1002 | wxAutoOleInterface<IHTMLDocument2> hd(IID_IHTMLDocument2, iDisp); | |
1003 | iDisp->Release(); | |
1004 | ||
1005 | if (! hd.Ok()) | |
1006 | return wxEmptyString; | |
1007 | ||
1008 | // get body element | |
1009 | IHTMLElement *_body = NULL; | |
1010 | hd->get_body(&_body); | |
1011 | if (! _body) | |
1012 | return wxEmptyString; | |
1013 | wxAutoOleInterface<IHTMLElement> body(_body); | |
1014 | ||
1015 | // get inner text | |
1016 | BSTR text = NULL; | |
1017 | hr = E_FAIL; | |
1018 | ||
1019 | if (asHTML) | |
1020 | hr = body->get_innerHTML(&text); | |
1021 | else | |
1022 | hr = body->get_innerText(&text); | |
1023 | if (hr != S_OK) | |
1024 | return wxEmptyString; | |
1025 | ||
1026 | wxString s = text; | |
1027 | SysFreeString(text); | |
1028 | ||
1029 | return s; | |
1030 | } | |
1031 | ||
1032 | ||
1033 | // void wxIEHtmlWin::SetEditMode(bool seton) | |
1034 | // { | |
1035 | // m_bAmbientUserMode = ! seton; | |
1036 | // AmbientPropertyChanged(DISPID_AMBIENT_USERMODE); | |
1037 | // }; | |
1038 | ||
1039 | // bool wxIEHtmlWin::GetEditMode() | |
1040 | // { | |
1041 | // return ! m_bAmbientUserMode; | |
1042 | // }; | |
1043 | }; | |
1044 | %} | |
1045 | ||
1046 | ||
1047 | // we'll document it in the derived Python class | |
1048 | %feature("noautodoc") wxIEHtmlWindowBase; | |
1049 | %feature("noautodoc") wxIEHtmlWindowBase::SetCharset; | |
1050 | %feature("noautodoc") wxIEHtmlWindowBase::LoadString; | |
1051 | %feature("noautodoc") wxIEHtmlWindowBase::LoadStream; | |
1052 | %feature("noautodoc") wxIEHtmlWindowBase::GetStringSelection; | |
1053 | %feature("noautodoc") wxIEHtmlWindowBase::GetText; | |
1054 | ||
1055 | ||
1056 | class wxIEHtmlWindowBase : public wxActiveXWindow { | |
1057 | public: | |
1058 | ||
1059 | wxIEHtmlWindowBase ( wxWindow* parent, const CLSID& clsId, wxWindowID id = -1, | |
1060 | const wxPoint& pos = wxDefaultPosition, | |
1061 | const wxSize& size = wxDefaultSize, | |
1062 | long style = 0, | |
1063 | const wxString& name = wxPyPanelNameStr); | |
1064 | ||
1065 | void SetCharset(const wxString& charset); | |
1066 | bool LoadString(const wxString& html); | |
1067 | bool LoadStream(wxInputStream *is); | |
1068 | wxString GetStringSelection(bool asHTML); | |
1069 | wxString GetText(bool asHTML); | |
1070 | }; | |
1071 | ||
1072 | ||
1073 | ||
1074 | ||
1075 | ||
1076 | ||
1077 | ||
1078 | ||
1079 | ||
1080 | ||
1081 | ||
1082 | #if 0 | |
1083 | enum wxIEHtmlRefreshLevel | |
1084 | { | |
1085 | wxIEHTML_REFRESH_NORMAL = 0, | |
1086 | wxIEHTML_REFRESH_IFEXPIRED = 1, | |
1087 | wxIEHTML_REFRESH_CONTINUE = 2, | |
1088 | wxIEHTML_REFRESH_COMPLETELY = 3 | |
1089 | }; | |
1090 | ||
1091 | DocStr(wxIEHtmlWin, | |
1092 | ""); | |
1093 | class wxIEHtmlWin : public wxWindow | |
1094 | { | |
1095 | public: | |
1096 | %pythonAppend wxIEHtmlWin "self._setOORInfo(self)" | |
1097 | ||
1098 | wxIEHtmlWin(wxWindow * parent, wxWindowID id = -1, | |
1099 | const wxPoint& pos = wxDefaultPosition, | |
1100 | const wxSize& size = wxDefaultSize, | |
1101 | long style = 0, | |
1102 | const wxString& name = wxPyPanelNameStr); | |
1103 | ||
1104 | void LoadUrl(const wxString& url); | |
1105 | bool LoadString(wxString html); | |
1106 | bool LoadStream(wxInputStream *is); | |
1107 | ||
1108 | %pythoncode { Navigate = LoadUrl } | |
1109 | ||
1110 | void SetCharset(wxString charset); | |
1111 | void SetEditMode(bool seton); | |
1112 | bool GetEditMode(); | |
1113 | wxString GetStringSelection(bool asHTML = false); | |
1114 | wxString GetText(bool asHTML = false); | |
1115 | ||
1116 | bool GoBack(); | |
1117 | bool GoForward(); | |
1118 | bool GoHome(); | |
1119 | bool GoSearch(); | |
1120 | %name(RefreshPage)bool Refresh(wxIEHtmlRefreshLevel level); | |
1121 | bool Stop(); | |
1122 | }; | |
1123 | ||
1124 | ||
1125 | ||
1126 | %pythoncode { | |
1127 | wxEVT_COMMAND_MSHTML_BEFORENAVIGATE2 = RegisterActiveXEvent('BeforeNavigate2') | |
1128 | wxEVT_COMMAND_MSHTML_NEWWINDOW2 = RegisterActiveXEvent('NewWindow2') | |
1129 | wxEVT_COMMAND_MSHTML_DOCUMENTCOMPLETE = RegisterActiveXEvent('DocumentComplete') | |
1130 | wxEVT_COMMAND_MSHTML_PROGRESSCHANGE = RegisterActiveXEvent('ProgressChange') | |
1131 | wxEVT_COMMAND_MSHTML_STATUSTEXTCHANGE = RegisterActiveXEvent('StatusTextChange') | |
1132 | wxEVT_COMMAND_MSHTML_TITLECHANGE = RegisterActiveXEvent('TitleChange') | |
1133 | ||
1134 | EVT_MSHTML_BEFORENAVIGATE2 = wx.PyEventBinder(wxEVT_COMMAND_MSHTML_BEFORENAVIGATE2, 1) | |
1135 | EVT_MSHTML_NEWWINDOW2 = wx.PyEventBinder(wxEVT_COMMAND_MSHTML_NEWWINDOW2, 1) | |
1136 | EVT_MSHTML_DOCUMENTCOMPLETE = wx.PyEventBinder(wxEVT_COMMAND_MSHTML_DOCUMENTCOMPLETE, 1) | |
1137 | EVT_MSHTML_PROGRESSCHANGE = wx.PyEventBinder(wxEVT_COMMAND_MSHTML_PROGRESSCHANGE, 1) | |
1138 | EVT_MSHTML_STATUSTEXTCHANGE = wx.PyEventBinder(wxEVT_COMMAND_MSHTML_STATUSTEXTCHANGE, 1) | |
1139 | EVT_MSHTML_TITLECHANGE = wx.PyEventBinder(wxEVT_COMMAND_MSHTML_TITLECHANGE, 1) | |
1140 | } | |
1141 | ||
1142 | #endif | |
1143 | ||
1144 | //--------------------------------------------------------------------------- | |
1145 | // Include some extra Python code into the proxy module | |
1146 | ||
1147 | %pythoncode "_activex_ex.py" | |
1148 | ||
1149 | //--------------------------------------------------------------------------- |