]> git.saurik.com Git - wxWidgets.git/blob - wxPython/contrib/activex/activex_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / contrib / activex / activex_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_CLSID swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_unsigned_short swig_types[8]
2475 #define SWIGTYPE_p_wxANIHandler swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxActiveXEvent swig_types[12]
2479 #define SWIGTYPE_p_wxActiveXWindow swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBoxSizer swig_types[15]
2482 #define SWIGTYPE_p_wxCURHandler swig_types[16]
2483 #define SWIGTYPE_p_wxChildFocusEvent swig_types[17]
2484 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[18]
2485 #define SWIGTYPE_p_wxCloseEvent swig_types[19]
2486 #define SWIGTYPE_p_wxCommandEvent swig_types[20]
2487 #define SWIGTYPE_p_wxContextMenuEvent swig_types[21]
2488 #define SWIGTYPE_p_wxControl swig_types[22]
2489 #define SWIGTYPE_p_wxControlWithItems swig_types[23]
2490 #define SWIGTYPE_p_wxDateEvent swig_types[24]
2491 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[25]
2492 #define SWIGTYPE_p_wxDropFilesEvent swig_types[26]
2493 #define SWIGTYPE_p_wxDuplexMode swig_types[27]
2494 #define SWIGTYPE_p_wxEraseEvent swig_types[28]
2495 #define SWIGTYPE_p_wxEvent swig_types[29]
2496 #define SWIGTYPE_p_wxEventBlocker swig_types[30]
2497 #define SWIGTYPE_p_wxEvtHandler swig_types[31]
2498 #define SWIGTYPE_p_wxFSFile swig_types[32]
2499 #define SWIGTYPE_p_wxFileSystem swig_types[33]
2500 #define SWIGTYPE_p_wxFlexGridSizer swig_types[34]
2501 #define SWIGTYPE_p_wxFocusEvent swig_types[35]
2502 #define SWIGTYPE_p_wxFuncX swig_types[36]
2503 #define SWIGTYPE_p_wxFuncXArray swig_types[37]
2504 #define SWIGTYPE_p_wxGBSizerItem swig_types[38]
2505 #define SWIGTYPE_p_wxGIFHandler swig_types[39]
2506 #define SWIGTYPE_p_wxGridBagSizer swig_types[40]
2507 #define SWIGTYPE_p_wxGridSizer swig_types[41]
2508 #define SWIGTYPE_p_wxICOHandler swig_types[42]
2509 #define SWIGTYPE_p_wxIEHtmlWindowBase swig_types[43]
2510 #define SWIGTYPE_p_wxIconizeEvent swig_types[44]
2511 #define SWIGTYPE_p_wxIdleEvent swig_types[45]
2512 #define SWIGTYPE_p_wxImage swig_types[46]
2513 #define SWIGTYPE_p_wxImageHandler swig_types[47]
2514 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[48]
2515 #define SWIGTYPE_p_wxInitDialogEvent swig_types[49]
2516 #define SWIGTYPE_p_wxInputStream swig_types[50]
2517 #define SWIGTYPE_p_wxJPEGHandler swig_types[51]
2518 #define SWIGTYPE_p_wxKeyEvent swig_types[52]
2519 #define SWIGTYPE_p_wxLayoutConstraints swig_types[53]
2520 #define SWIGTYPE_p_wxMaximizeEvent swig_types[54]
2521 #define SWIGTYPE_p_wxMenu swig_types[55]
2522 #define SWIGTYPE_p_wxMenuBar swig_types[56]
2523 #define SWIGTYPE_p_wxMenuEvent swig_types[57]
2524 #define SWIGTYPE_p_wxMenuItem swig_types[58]
2525 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[59]
2526 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[60]
2527 #define SWIGTYPE_p_wxMouseEvent swig_types[61]
2528 #define SWIGTYPE_p_wxMoveEvent swig_types[62]
2529 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[63]
2530 #define SWIGTYPE_p_wxNcPaintEvent swig_types[64]
2531 #define SWIGTYPE_p_wxNotifyEvent swig_types[65]
2532 #define SWIGTYPE_p_wxObject swig_types[66]
2533 #define SWIGTYPE_p_wxPCXHandler swig_types[67]
2534 #define SWIGTYPE_p_wxPNGHandler swig_types[68]
2535 #define SWIGTYPE_p_wxPNMHandler swig_types[69]
2536 #define SWIGTYPE_p_wxPaintEvent swig_types[70]
2537 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[71]
2538 #define SWIGTYPE_p_wxPaperSize swig_types[72]
2539 #define SWIGTYPE_p_wxParamX swig_types[73]
2540 #define SWIGTYPE_p_wxParamXArray swig_types[74]
2541 #define SWIGTYPE_p_wxPropX swig_types[75]
2542 #define SWIGTYPE_p_wxPropXArray swig_types[76]
2543 #define SWIGTYPE_p_wxPyApp swig_types[77]
2544 #define SWIGTYPE_p_wxPyCommandEvent swig_types[78]
2545 #define SWIGTYPE_p_wxPyEvent swig_types[79]
2546 #define SWIGTYPE_p_wxPyImageHandler swig_types[80]
2547 #define SWIGTYPE_p_wxPySizer swig_types[81]
2548 #define SWIGTYPE_p_wxPyValidator swig_types[82]
2549 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[83]
2550 #define SWIGTYPE_p_wxScrollEvent swig_types[84]
2551 #define SWIGTYPE_p_wxScrollWinEvent swig_types[85]
2552 #define SWIGTYPE_p_wxSetCursorEvent swig_types[86]
2553 #define SWIGTYPE_p_wxShowEvent swig_types[87]
2554 #define SWIGTYPE_p_wxSizeEvent swig_types[88]
2555 #define SWIGTYPE_p_wxSizer swig_types[89]
2556 #define SWIGTYPE_p_wxSizerItem swig_types[90]
2557 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[91]
2558 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[92]
2559 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[93]
2560 #define SWIGTYPE_p_wxTGAHandler swig_types[94]
2561 #define SWIGTYPE_p_wxTIFFHandler swig_types[95]
2562 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[96]
2563 #define SWIGTYPE_p_wxValidator swig_types[97]
2564 #define SWIGTYPE_p_wxWindow swig_types[98]
2565 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[99]
2566 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[100]
2567 #define SWIGTYPE_p_wxXPMHandler swig_types[101]
2568 static swig_type_info *swig_types[103];
2569 static swig_module_info swig_module = {swig_types, 102, 0, 0, 0, 0};
2570 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2571 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2572
2573 /* -------- TYPES TABLE (END) -------- */
2574
2575 #if (PY_VERSION_HEX <= 0x02000000)
2576 # if !defined(SWIG_PYTHON_CLASSIC)
2577 # error "This python version requires to use swig with the '-classic' option"
2578 # endif
2579 #endif
2580 #if (PY_VERSION_HEX <= 0x02020000)
2581 # error "This python version requires to use swig with the '-nomodern' option"
2582 #endif
2583 #if (PY_VERSION_HEX <= 0x02020000)
2584 # error "This python version requires to use swig with the '-nomodernargs' option"
2585 #endif
2586 #ifndef METH_O
2587 # error "This python version requires to use swig with the '-nofastunpack' option"
2588 #endif
2589
2590 /*-----------------------------------------------
2591 @(target):= _activex.so
2592 ------------------------------------------------*/
2593 #define SWIG_init init_activex
2594
2595 #define SWIG_name "_activex"
2596
2597 #define SWIGVERSION 0x010329
2598
2599
2600 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2601 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2602
2603
2604 #include <stdexcept>
2605
2606
2607 namespace swig {
2608 class PyObject_ptr {
2609 protected:
2610 PyObject *_obj;
2611
2612 public:
2613 PyObject_ptr() :_obj(0)
2614 {
2615 }
2616
2617 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2618 {
2619 Py_XINCREF(_obj);
2620 }
2621
2622 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2623 {
2624 if (initial_ref) Py_XINCREF(_obj);
2625 }
2626
2627 PyObject_ptr & operator=(const PyObject_ptr& item)
2628 {
2629 Py_XINCREF(item._obj);
2630 Py_XDECREF(_obj);
2631 _obj = item._obj;
2632 return *this;
2633 }
2634
2635 ~PyObject_ptr()
2636 {
2637 Py_XDECREF(_obj);
2638 }
2639
2640 operator PyObject *() const
2641 {
2642 return _obj;
2643 }
2644
2645 PyObject *operator->() const
2646 {
2647 return _obj;
2648 }
2649 };
2650 }
2651
2652
2653 namespace swig {
2654 struct PyObject_var : PyObject_ptr {
2655 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2656
2657 PyObject_var & operator = (PyObject* obj)
2658 {
2659 Py_XDECREF(_obj);
2660 _obj = obj;
2661 return *this;
2662 }
2663 };
2664 }
2665
2666
2667 #include "wx/wxPython/wxPython.h"
2668 #include "wx/wxPython/pyclasses.h"
2669 #include "wx/wxPython/pyistream.h"
2670
2671 #include "wxactivex.h"
2672
2673 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2674
2675 // Since SWIG doesn't support nested classes, we need to fool it a bit
2676 // and make them look like global classes. These defines make the C++ code
2677 // know what we are doing.
2678 #define wxParamX wxActiveX::ParamX
2679 #define wxFuncX wxActiveX::FuncX
2680 #define wxPropX wxActiveX::PropX
2681 #define wxParamXArray wxActiveX::ParamXArray
2682 #define wxFuncXArray wxActiveX::FuncXArray
2683 #define wxPropXArray wxActiveX::PropXArray
2684
2685
2686 // Some conversion helpers
2687 static wxVariant _PyObj2Variant(PyObject* value);
2688 static bool _PyObj2Variant(PyObject* value, wxVariant& wv);
2689 static PyObject* _Variant2PyObj(wxVariant& value, bool useNone=false);
2690 static wxString _VARTYPEname(VARTYPE vt);
2691
2692 // Check if an exception has been raised (blocking threads)
2693 inline bool wxPyErr_Occurred()
2694 {
2695 bool rval;
2696 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2697 rval = PyErr_Occurred() != NULL;
2698 wxPyEndBlockThreads(blocked);
2699 return rval;
2700 }
2701
2702
2703 SWIGINTERN CLSID *new_CLSID(wxString const &id){
2704 int result;
2705 CLSID* self = new CLSID;
2706 memset(self, 0, sizeof(CLSID));
2707
2708 if (id[0] == _T('{')) {
2709 // Looks like a classID string
2710 result =
2711 CLSIDFromString(
2712 (LPOLESTR)(const wchar_t *)id.wc_str(wxConvUTF8),
2713 self);
2714 } else {
2715 // Try a progID
2716 result =
2717 CLSIDFromProgID(
2718 (LPOLESTR)(const wchar_t *)id.wc_str(wxConvUTF8),
2719 self);
2720 }
2721 if (result != NOERROR) {
2722 wxPyErr_SetString(PyExc_ValueError, "Not a recognized classID or progID");
2723 delete self;
2724 return NULL;
2725 }
2726 return self;
2727 }
2728 SWIGINTERN void delete_CLSID(CLSID *self){ delete self; }
2729 SWIGINTERN wxString CLSID_GetCLSIDString(CLSID *self){
2730 LPOLESTR s;
2731 wxString str;
2732 if (StringFromCLSID(*self, &s) == S_OK) {
2733 str = s;
2734 CoTaskMemFree(s);
2735 }
2736 else {
2737 str = _T("Error!"); // TODO: raise exception?
2738 }
2739 return str;
2740 }
2741 SWIGINTERN wxString CLSID_GetProgIDString(CLSID *self){
2742 LPOLESTR s;
2743 wxString str;
2744 if (ProgIDFromCLSID(*self, &s) == S_OK) {
2745 str = s;
2746 CoTaskMemFree(s);
2747 }
2748 else {
2749 str = _T("Error!"); // TODO: raise exception?
2750 }
2751 return str;
2752 }
2753
2754 #define SWIG_From_long PyInt_FromLong
2755
2756
2757 SWIGINTERNINLINE PyObject*
2758 SWIG_From_unsigned_SS_long (unsigned long value)
2759 {
2760 return (value > LONG_MAX) ?
2761 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2762 }
2763
2764
2765 SWIGINTERNINLINE PyObject *
2766 SWIG_From_unsigned_SS_short (unsigned short value)
2767 {
2768 return SWIG_From_unsigned_SS_long (value);
2769 }
2770
2771 SWIGINTERN wxString wxParamX_vt_type_get(wxParamX *self){ return _VARTYPEname(self->vt); }
2772 SWIGINTERN bool wxParamXArray___nonzero__(wxParamXArray *self){ return self->size() > 0; }
2773 SWIGINTERN int wxParamXArray___len__(wxParamXArray *self){ return self->size(); }
2774
2775 SWIGINTERNINLINE PyObject *
2776 SWIG_From_int (int value)
2777 {
2778 return SWIG_From_long (value);
2779 }
2780
2781
2782 #include <limits.h>
2783 #ifndef LLONG_MIN
2784 # define LLONG_MIN LONG_LONG_MIN
2785 #endif
2786 #ifndef LLONG_MAX
2787 # define LLONG_MAX LONG_LONG_MAX
2788 #endif
2789 #ifndef ULLONG_MAX
2790 # define ULLONG_MAX ULONG_LONG_MAX
2791 #endif
2792
2793
2794 SWIGINTERN int
2795 SWIG_AsVal_long (PyObject* obj, long* val)
2796 {
2797 if (PyNumber_Check(obj)) {
2798 if (val) *val = PyInt_AsLong(obj);
2799 return SWIG_OK;
2800 }
2801 return SWIG_TypeError;
2802 }
2803
2804
2805 SWIGINTERN int
2806 SWIG_AsVal_int (PyObject * obj, int *val)
2807 {
2808 long v;
2809 int res = SWIG_AsVal_long (obj, &v);
2810 if (SWIG_IsOK(res)) {
2811 if ((v < INT_MIN || v > INT_MAX)) {
2812 return SWIG_OverflowError;
2813 } else {
2814 if (val) *val = static_cast< int >(v);
2815 }
2816 }
2817 return res;
2818 }
2819
2820 SWIGINTERN wxParamX const &wxParamXArray___getitem__(wxParamXArray *self,int idx){
2821 if ( idx >= 0 && idx < self->size() )
2822 return (*self)[idx];
2823 else {
2824 static wxParamX BadVal;
2825 wxPyErr_SetString(PyExc_IndexError, "Index out of range");
2826 return BadVal;
2827 }
2828 }
2829 SWIGINTERN bool wxFuncXArray___nonzero__(wxFuncXArray *self){ return self->size() > 0; }
2830 SWIGINTERN int wxFuncXArray___len__(wxFuncXArray *self){ return self->size(); }
2831 SWIGINTERN wxFuncX const &wxFuncXArray___getitem__(wxFuncXArray *self,int idx){
2832 if ( idx >= 0 && idx < self->size() )
2833 return (*self)[idx];
2834 else {
2835 static wxFuncX BadVal;
2836 wxPyErr_SetString(PyExc_IndexError, "Index out of range");
2837 return BadVal;
2838 }
2839 }
2840 SWIGINTERN bool wxPropXArray___nonzero__(wxPropXArray *self){ return self->size() > 0; }
2841 SWIGINTERN int wxPropXArray___len__(wxPropXArray *self){ return self->size(); }
2842 SWIGINTERN wxPropX const &wxPropXArray___getitem__(wxPropXArray *self,int idx){
2843 if ( idx >= 0 && idx < self->size() )
2844 return (*self)[idx];
2845 else {
2846 static wxPropX BadVal;
2847 wxPyErr_SetString(PyExc_IndexError, "Index out of range");
2848 return BadVal;
2849 }
2850 }
2851
2852 // C++ version of a Python-aware wxActiveX
2853 class wxActiveXWindow : public wxActiveX
2854 {
2855 private:
2856 CLSID m_CLSID;
2857
2858 DECLARE_ABSTRACT_CLASS(wxActiveXWindow);
2859
2860 public:
2861 wxActiveXWindow( wxWindow* parent, const CLSID& clsId, wxWindowID id = -1,
2862 const wxPoint& pos = wxDefaultPosition,
2863 const wxSize& size = wxDefaultSize,
2864 long style = 0,
2865 const wxString& name = wxPyPanelNameStr)
2866 : wxActiveX(parent, clsId, id, pos, size, style, name)
2867 {
2868 m_CLSID = clsId;
2869 }
2870
2871 const CLSID& GetCLSID() const { return m_CLSID; }
2872
2873
2874 // Renamed versions of some base class methods that delegate
2875 // to the base where appropriate, and raise Python exceptions
2876 // when needed.
2877 int GetAXEventCount() const { return wxActiveX::GetEventCount(); }
2878 int GetAXPropCount() const { return wxActiveX::GetPropCount(); }
2879 int GetAXMethodCount() const { return wxActiveX::GetMethodCount(); }
2880
2881 const wxFuncX& GetAXEventDesc(int idx) const
2882 {
2883 static wxFuncX BadVal;
2884 if (idx < 0 || idx >= GetAXEventCount()) {
2885 wxPyErr_SetString(PyExc_IndexError, "Index out of range");
2886 return BadVal;
2887 }
2888 return m_events[idx];
2889 }
2890 const wxFuncX& GetAXMethodDesc(int idx) const
2891 {
2892 static wxFuncX BadVal;
2893 if (idx < 0 || idx >= GetAXMethodCount()) {
2894 wxPyErr_SetString(PyExc_IndexError, "Index out of range");
2895 return BadVal;
2896 }
2897 return m_methods[idx];
2898 }
2899 const wxPropX& GetAXPropDesc(int idx) const
2900 {
2901 static wxPropX BadVal;
2902 if (idx < 0 || idx >= GetAXPropCount()) {
2903 wxPyErr_SetString(PyExc_IndexError, "Index out of range");
2904 return BadVal;
2905 }
2906 return m_props[idx];
2907 }
2908
2909 const wxFuncX& GetAXMethodDesc(const wxString& name) const
2910 {
2911 NameMap::const_iterator it = m_methodNames.find(name);
2912 if (it == m_methodNames.end()) {
2913 wxString msg;
2914 msg << _T("method <") << name << _T("> not found");
2915 wxPyErr_SetString(PyExc_KeyError, msg.mb_str());
2916 static wxFuncX BadVal;
2917 return BadVal;
2918 };
2919 return GetAXMethodDesc(it->second);
2920 }
2921 const wxPropX& GetAXPropDesc(const wxString& name) const
2922 {
2923 NameMap::const_iterator it = m_propNames.find(name);
2924 if (it == m_propNames.end()) {
2925 wxString msg;
2926 msg << _T("property <") << name << _T("> not found");
2927 wxPyErr_SetString(PyExc_KeyError, msg.mb_str());
2928 static wxPropX BadVal;
2929 return BadVal;
2930 };
2931 return GetAXPropDesc(it->second);
2932 }
2933
2934 // Accessors for the internal vectors of events, methods and
2935 // proprties. Can be used as sequence like objects from
2936 // Python.
2937 const wxFuncXArray& GetAXEvents() { return m_events; }
2938 const wxFuncXArray& GetAXMethods() { return m_methods; }
2939 const wxPropXArray& GetAXProperties() { return m_props; }
2940
2941
2942 // Set a property from a Python object
2943 void SetAXProp(const wxString& name, PyObject* value)
2944 {
2945 const wxPropX& prop = GetAXPropDesc(name);
2946 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2947 if (! PyErr_Occurred() ) {
2948 if (! prop.CanSet()) {
2949 wxString msg;
2950 msg << _T("property <") << name << _T("> is readonly");
2951 PyErr_SetString(PyExc_TypeError, msg.mb_str());
2952 goto done;
2953 } else {
2954 wxVariant wxV = _PyObj2Variant(value);
2955 if (PyErr_Occurred())
2956 goto done;
2957 VARIANT v = {prop.arg.vt};
2958 if (!VariantToMSWVariant(wxV, v) || PyErr_Occurred()) {
2959 wxString msg;
2960 msg << _T("Unable to convert value to expected type: (")
2961 << _VARTYPEname(prop.arg.vt) << _T(") for property <")
2962 << name << _T(">");
2963 PyErr_SetString(PyExc_TypeError, msg.mb_str());
2964 goto done;
2965 }
2966 PyThreadState* tstate = wxPyBeginAllowThreads();
2967 SetProp(prop.memid, v);
2968 VariantClear(&v);
2969 wxPyEndAllowThreads(tstate);
2970 }
2971 }
2972 done:
2973 wxPyEndBlockThreads(blocked);
2974 }
2975
2976
2977 // Get a property and convert it to a Python object
2978 PyObject* GetAXProp(const wxString& name)
2979 {
2980 PyObject* rval = NULL;
2981 const wxPropX& prop = GetAXPropDesc(name);
2982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2983 if (! PyErr_Occurred() ) {
2984 if (! prop.CanGet()) {
2985 wxString msg;
2986 msg << _T("property <") << name << _T("> is writeonly");
2987 PyErr_SetString(PyExc_TypeError, msg.mb_str());
2988 goto done;
2989 } else {
2990 PyThreadState* tstate = wxPyBeginAllowThreads();
2991 VARIANT v = GetPropAsVariant(prop.memid);
2992 wxPyEndAllowThreads(tstate);
2993 wxVariant wv;
2994 if (!MSWVariantToVariant(v, wv) || PyErr_Occurred()) {
2995 wxString msg;
2996 msg << _T("Unable to convert value to expected type: (")
2997 << _VARTYPEname(prop.arg.vt) << _T(") for property <")
2998 << name << _T(">");
2999 PyErr_SetString(PyExc_TypeError, msg.mb_str());
3000 goto done;
3001 }
3002 rval = _Variant2PyObj(wv);
3003 VariantClear(&v);
3004 }
3005 }
3006 done:
3007 wxPyEndBlockThreads(blocked);
3008 return rval;
3009 }
3010
3011
3012 // If both IsIn and isOut are false, assume it is actually an
3013 // input param
3014 bool paramIsIn(const wxParamX& p)
3015 {
3016 return p.IsIn() || (!p.IsIn() && !p.IsOut());
3017 }
3018
3019
3020 // Call a method of the ActiveX object
3021 PyObject* _CallAXMethod(const wxString& name, PyObject* args)
3022 {
3023 VARIANTARG *vargs = NULL;
3024 int nargs = 0;
3025 PyObject* rval = NULL;
3026 const wxFuncX& func = GetAXMethodDesc(name);
3027
3028 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3029 if (! PyErr_Occurred() ) {
3030 nargs = func.params.size();
3031 if (nargs > 0)
3032 vargs = new VARIANTARG[nargs];
3033
3034 if (vargs) {
3035 // init type of vargs, in reverse order
3036 int i;
3037 for (i = 0; i < nargs; i++)
3038 vargs[nargs - i - 1].vt = func.params[i].vt;
3039
3040 // Map the args coming from Python to the input parameters in vargs
3041 int pi = 0;
3042 i = 0;
3043 while ( i<nargs && pi<PyTuple_Size(args) ) {
3044 // Move to the next input param.
3045 if (! paramIsIn(func.params[i])) {
3046 i += 1;
3047 continue;
3048 }
3049 // convert the python object
3050 PyObject* obj = PyTuple_GetItem(args, pi);
3051 if (obj == Py_None) // special-case None?
3052 vargs[nargs - i - 1].vt = VT_EMPTY;
3053 else {
3054 wxVariant wxV = _PyObj2Variant(obj);
3055 if (PyErr_Occurred())
3056 goto done;
3057 if (!VariantToMSWVariant(wxV, vargs[nargs - i - 1]) || PyErr_Occurred()) {
3058 wxString msg;
3059 msg << _T("Unable to convert value to expected type: (")
3060 << _VARTYPEname(vargs[nargs - i - 1].vt)
3061 << _T(") for parameter ") << i;
3062 PyErr_SetString(PyExc_TypeError, msg.mb_str());
3063 goto done;
3064 }
3065 }
3066 i += 1;
3067 pi += 1;
3068 }
3069 }
3070
3071 // call the method
3072 PyThreadState* tstate = wxPyBeginAllowThreads();
3073 VARIANT rv = CallMethod(func.memid, vargs, nargs);
3074 wxPyEndAllowThreads(tstate);
3075
3076 // Convert the return value and any out-params, ignoring
3077 // conversion errors for now
3078 wxVariant wv;
3079 MSWVariantToVariant(rv, wv);
3080 rval = _Variant2PyObj(wv, true);
3081 VariantClear(&rv);
3082
3083 if (func.hasOut) {
3084 // make a list and put the rval in it if it is not None
3085 PyObject* lst = PyList_New(0);
3086 if (rval != Py_None)
3087 PyList_Append(lst, rval);
3088 else
3089 Py_DECREF(rval);
3090
3091 // find the out params and convert them
3092 for (int i = 0; i < nargs; i++) {
3093 VARIANTARG& va = vargs[nargs - i - 1];
3094 const wxParamX &px = func.params[i];
3095 if (px.IsOut()) {
3096 MSWVariantToVariant(va, wv);
3097 PyObject* obj = _Variant2PyObj(wv, true);
3098 PyList_Append(lst, obj);
3099 }
3100 }
3101 rval = PyList_AsTuple(lst);
3102 Py_DECREF(lst);
3103 }
3104 if (PyErr_Occurred())
3105 PyErr_Clear();
3106 }
3107 done:
3108 wxPyEndBlockThreads(blocked);
3109 if (vargs) {
3110 for (int i = 0; i < nargs; i++)
3111 VariantClear(&vargs[i]);
3112 delete [] vargs;
3113 }
3114 return rval;
3115 }
3116 };
3117
3118 IMPLEMENT_ABSTRACT_CLASS( wxActiveXWindow, wxWindow );
3119
3120 SWIGINTERN void wxActiveXEvent__preCallInit(wxActiveXEvent *self,PyObject *pyself){
3121 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3122 PyObject* pList = PyList_New(0);
3123 PyObject_SetAttrString(pyself, "paramList", pList);
3124 Py_DECREF(pList);
3125 for (int i=0; i<self->ParamCount(); i+=1) {
3126 PyObject* name = PyString_FromString((char*)(const char*)self->ParamName(i).mb_str());
3127 PyObject* val = _Variant2PyObj((*self)[i], true);
3128 PyObject_SetAttr(pyself, name, val);
3129 PyList_Append(pList, name);
3130 Py_DECREF(val);
3131 Py_DECREF(name);
3132 }
3133 wxPyEndBlockThreads(blocked);
3134 }
3135 SWIGINTERN void wxActiveXEvent__postCallCleanup(wxActiveXEvent *self,PyObject *pyself){
3136 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3137 for (int i=0; i<self->ParamCount(); i+=1) {
3138 PyObject* val = PyObject_GetAttrString(
3139 pyself, (char*)(const char*)self->ParamName(i).mb_str());
3140 _PyObj2Variant(val, (*self)[i]);
3141 Py_DECREF(val);
3142 }
3143 wxPyEndBlockThreads(blocked);
3144 }
3145
3146
3147 // Caller should already have the GIL!
3148 wxVariant _PyObj2Variant(PyObject* value)
3149 {
3150 wxVariant rval;
3151
3152 if (value == Py_None)
3153 return rval;
3154
3155 #if PYTHON_API_VERSION >= 1012 // Python 2.3+
3156 else if (PyBool_Check(value))
3157 rval = (value == Py_True) ? true : false;
3158 #endif
3159
3160 else if (PyInt_Check(value))
3161 rval = PyInt_AS_LONG(value);
3162
3163 else if (PyFloat_Check(value))
3164 rval = PyFloat_AS_DOUBLE(value);
3165
3166 else if (PyString_Check(value) || PyUnicode_Check(value))
3167 rval = Py2wxString(value);
3168
3169 // TODO: PyList of strings --> wxArrayString
3170 // wxDateTime
3171 // list of objects
3172 // etc.
3173
3174 else {
3175 PyErr_SetString(PyExc_TypeError, "Unsupported object type in _PyObj2Variant");
3176 rval = (long)0;
3177 }
3178
3179 return rval;
3180 }
3181
3182 // This one uses the type of the variant to try and force the conversion
3183 bool _PyObj2Variant(PyObject* value, wxVariant& wv)
3184 {
3185 wxString type = wv.GetType();
3186
3187 if ( type == _T("long") || type == _T("bool") || type == _T("char") )
3188 wv = PyInt_AsLong(value);
3189
3190 else if ( type == _T("string") )
3191 wv = Py2wxString(value);
3192
3193 else if ( type == _T("double") )
3194 wv = PyFloat_AsDouble(value);
3195
3196 else {
3197 // it's some other type that we dont' handle yet. Log it?
3198 return false;
3199 }
3200 return true;
3201 }
3202
3203 // Caller should already have the GIL!
3204 PyObject* _Variant2PyObj(wxVariant& value, bool useNone)
3205 {
3206 PyObject* rval = NULL;
3207
3208 if (value.IsNull()) {
3209 rval = Py_None;
3210 Py_INCREF(rval);
3211 }
3212
3213 // should "char" be treated as an int or as a string?
3214 else if (value.IsType(_T("char")) || value.IsType(_T("long")))
3215 rval = PyInt_FromLong(value);
3216
3217 else if (value.IsType(_T("double")))
3218 rval = PyFloat_FromDouble(value);
3219
3220 else if (value.IsType(_T("bool"))) {
3221 rval = (bool)value ? Py_True : Py_False;
3222 Py_INCREF(rval);
3223 }
3224
3225 else if (value.IsType(_T("string")))
3226 rval = wx2PyString(value);
3227
3228 else {
3229 if (useNone) {
3230 rval = Py_None;
3231 Py_INCREF(rval);
3232 }
3233 else {
3234 PyErr_SetString(PyExc_TypeError, "Unsupported object type in _Variant2PyObj");
3235 }
3236 }
3237 return rval;
3238 }
3239
3240
3241 wxString _VARTYPEname(VARTYPE vt)
3242 {
3243 if (vt & VT_BYREF)
3244 vt &= ~(VT_BYREF);
3245
3246 switch(vt) {
3247 case VT_VARIANT:
3248 return _T("VT_VARIANT");
3249
3250 // 1 byte chars
3251 case VT_I1:
3252 case VT_UI1:
3253 // 2 byte shorts
3254 case VT_I2:
3255 case VT_UI2:
3256 // 4 bytes longs
3257 case VT_I4:
3258 case VT_UI4:
3259 case VT_INT:
3260 case VT_UINT:
3261 case VT_ERROR:
3262 return _T("int");
3263
3264 // 4 byte floats
3265 case VT_R4:
3266 // 8 byte doubles
3267 case VT_R8:
3268 // decimals are converted from doubles too
3269 case VT_DECIMAL:
3270 return _T("double");
3271
3272 case VT_BOOL:
3273 return _T("bool");
3274
3275 case VT_DATE:
3276 return _T("wx.DateTime");
3277
3278 case VT_BSTR:
3279 return _T("string");
3280
3281 case VT_UNKNOWN:
3282 return _T("VT_UNKNOWN");
3283
3284 case VT_DISPATCH:
3285 return _T("VT_DISPATCH");
3286
3287 case VT_EMPTY:
3288 return _T("VT_EMPTY");
3289
3290 case VT_NULL:
3291 return _T("VT_NULL");
3292
3293 case VT_VOID:
3294 return _T("VT_VOID");
3295
3296 default:
3297 wxString msg;
3298 msg << _T("unsupported type ") << vt;
3299 return msg;
3300 }
3301 }
3302
3303
3304
3305 // A class derived from our wxActiveXWindow for the IE WebBrowser
3306 // control that will serve as a base class for a Python
3307 // implementation. This is done so we can "eat our own dog food"
3308 // and use a class at least mostly generated by genaxmodule, but
3309 // also get some of the extra stuff like loading a document from
3310 // a string or a stream, getting text contents, etc. that
3311 // Lindsay's version gives us.
3312 //
3313
3314 #include <wx/mstream.h>
3315 #include <oleidl.h>
3316 #include <winerror.h>
3317 #include <exdispid.h>
3318 #include <exdisp.h>
3319 #include <olectl.h>
3320 #include <Mshtml.h>
3321 #include <sstream>
3322
3323 #include "IEHtmlStream.h"
3324
3325 class wxIEHtmlWindowBase : public wxActiveXWindow {
3326 private:
3327 wxAutoOleInterface<IWebBrowser2> m_webBrowser;
3328
3329 DECLARE_ABSTRACT_CLASS(wxIEHtmlWindowBase);
3330
3331 public:
3332
3333 wxIEHtmlWindowBase ( wxWindow* parent, const CLSID& clsId, wxWindowID id = -1,
3334 const wxPoint& pos = wxDefaultPosition,
3335 const wxSize& size = wxDefaultSize,
3336 long style = 0,
3337 const wxString& name = wxPyPanelNameStr)
3338 : wxActiveXWindow(parent, clsId, id, pos, size, style, name)
3339 {
3340 HRESULT hret;
3341
3342 // Get IWebBrowser2 Interface
3343 hret = m_webBrowser.QueryInterface(IID_IWebBrowser2, m_ActiveX);
3344 wxASSERT(SUCCEEDED(hret));
3345
3346 // web browser setup
3347 m_webBrowser->put_MenuBar(VARIANT_FALSE);
3348 m_webBrowser->put_AddressBar(VARIANT_FALSE);
3349 m_webBrowser->put_StatusBar(VARIANT_FALSE);
3350 m_webBrowser->put_ToolBar(VARIANT_FALSE);
3351
3352 m_webBrowser->put_RegisterAsBrowser(VARIANT_TRUE);
3353 m_webBrowser->put_RegisterAsDropTarget(VARIANT_TRUE);
3354
3355 m_webBrowser->Navigate( L"about:blank", NULL, NULL, NULL, NULL );
3356 }
3357
3358
3359 void SetCharset(const wxString& charset)
3360 {
3361 HRESULT hret;
3362
3363 // HTML Document ?
3364 IDispatch *pDisp = NULL;
3365 hret = m_webBrowser->get_Document(&pDisp);
3366 wxAutoOleInterface<IDispatch> disp(pDisp);
3367
3368 if (disp.Ok())
3369 {
3370 wxAutoOleInterface<IHTMLDocument2> doc(IID_IHTMLDocument2, disp);
3371 if (doc.Ok())
3372 doc->put_charset((BSTR) (const wchar_t *) charset.wc_str(wxConvUTF8));
3373 //doc->put_charset((BSTR) wxConvUTF8.cMB2WC(charset).data());
3374 }
3375 }
3376
3377
3378 bool LoadString(const wxString& html)
3379 {
3380 char *data = NULL;
3381 size_t len = html.length();
3382 len *= sizeof(wxChar);
3383 data = (char *) malloc(len);
3384 memcpy(data, html.c_str(), len);
3385 return LoadStream(new wxOwnedMemInputStream(data, len));
3386 }
3387
3388
3389 bool LoadStream(IStreamAdaptorBase *pstrm)
3390 {
3391 // need to prepend this as poxy MSHTML will not recognise a HTML comment
3392 // as starting a html document and treats it as plain text
3393 // Does nayone know how to force it to html mode ?
3394 #if wxUSE_UNICODE
3395 // TODO: What to do in this case???
3396 #else
3397 pstrm->prepend = _T("<html>");
3398 #endif
3399
3400 // strip leading whitespace as it can confuse MSHTML
3401 wxAutoOleInterface<IStream> strm(pstrm);
3402
3403 // Document Interface
3404 IDispatch *pDisp = NULL;
3405 HRESULT hret = m_webBrowser->get_Document(&pDisp);
3406 if (! pDisp)
3407 return false;
3408 wxAutoOleInterface<IDispatch> disp(pDisp);
3409
3410
3411 // get IPersistStreamInit
3412 wxAutoOleInterface<IPersistStreamInit>
3413 pPersistStreamInit(IID_IPersistStreamInit, disp);
3414
3415 if (pPersistStreamInit.Ok())
3416 {
3417 HRESULT hr = pPersistStreamInit->InitNew();
3418 if (SUCCEEDED(hr))
3419 hr = pPersistStreamInit->Load(strm);
3420
3421 return SUCCEEDED(hr);
3422 }
3423 else
3424 return false;
3425 }
3426
3427 bool LoadStream(wxInputStream *is)
3428 {
3429 // wrap reference around stream
3430 IwxStreamAdaptor *pstrm = new IwxStreamAdaptor(is);
3431 pstrm->AddRef();
3432
3433 return LoadStream(pstrm);
3434 }
3435
3436
3437 wxString GetStringSelection(bool asHTML)
3438 {
3439 wxAutoOleInterface<IHTMLTxtRange> tr(wxieGetSelRange(m_oleObject));
3440 if (! tr)
3441 return wxEmptyString;
3442
3443 BSTR text = NULL;
3444 HRESULT hr = E_FAIL;
3445
3446 if (asHTML)
3447 hr = tr->get_htmlText(&text);
3448 else
3449 hr = tr->get_text(&text);
3450 if (hr != S_OK)
3451 return wxEmptyString;
3452
3453 wxString s = text;
3454 SysFreeString(text);
3455
3456 return s;
3457 };
3458
3459 wxString GetText(bool asHTML)
3460 {
3461 if (! m_webBrowser.Ok())
3462 return wxEmptyString;
3463
3464 // get document dispatch interface
3465 IDispatch *iDisp = NULL;
3466 HRESULT hr = m_webBrowser->get_Document(&iDisp);
3467 if (hr != S_OK)
3468 return wxEmptyString;
3469
3470 // Query for Document Interface
3471 wxAutoOleInterface<IHTMLDocument2> hd(IID_IHTMLDocument2, iDisp);
3472 iDisp->Release();
3473
3474 if (! hd.Ok())
3475 return wxEmptyString;
3476
3477 // get body element
3478 IHTMLElement *_body = NULL;
3479 hd->get_body(&_body);
3480 if (! _body)
3481 return wxEmptyString;
3482 wxAutoOleInterface<IHTMLElement> body(_body);
3483
3484 // get inner text
3485 BSTR text = NULL;
3486 hr = E_FAIL;
3487
3488 if (asHTML)
3489 hr = body->get_innerHTML(&text);
3490 else
3491 hr = body->get_innerText(&text);
3492 if (hr != S_OK)
3493 return wxEmptyString;
3494
3495 wxString s = text;
3496 SysFreeString(text);
3497
3498 return s;
3499 }
3500
3501
3502 // void wxIEHtmlWin::SetEditMode(bool seton)
3503 // {
3504 // m_bAmbientUserMode = ! seton;
3505 // AmbientPropertyChanged(DISPID_AMBIENT_USERMODE);
3506 // };
3507
3508 // bool wxIEHtmlWin::GetEditMode()
3509 // {
3510 // return ! m_bAmbientUserMode;
3511 // };
3512 };
3513
3514 IMPLEMENT_ABSTRACT_CLASS( wxIEHtmlWindowBase, wxActiveXWindow );
3515
3516
3517
3518 SWIGINTERN int
3519 SWIG_AsVal_bool (PyObject *obj, bool *val)
3520 {
3521 if (obj == Py_True) {
3522 if (val) *val = true;
3523 return SWIG_OK;
3524 } else if (obj == Py_False) {
3525 if (val) *val = false;
3526 return SWIG_OK;
3527 } else {
3528 long v = 0;
3529 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3530 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3531 return res;
3532 }
3533 }
3534
3535 #ifdef __cplusplus
3536 extern "C" {
3537 #endif
3538 SWIGINTERN PyObject *_wrap_new_CLSID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3539 PyObject *resultobj = 0;
3540 wxString *arg1 = 0 ;
3541 CLSID *result = 0 ;
3542 bool temp1 = false ;
3543 PyObject * obj0 = 0 ;
3544 char * kwnames[] = {
3545 (char *) "id", NULL
3546 };
3547
3548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CLSID",kwnames,&obj0)) SWIG_fail;
3549 {
3550 arg1 = wxString_in_helper(obj0);
3551 if (arg1 == NULL) SWIG_fail;
3552 temp1 = true;
3553 }
3554 {
3555 PyThreadState* __tstate = wxPyBeginAllowThreads();
3556 result = (CLSID *)new_CLSID((wxString const &)*arg1);
3557 wxPyEndAllowThreads(__tstate);
3558 if (PyErr_Occurred()) SWIG_fail;
3559 }
3560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CLSID, SWIG_POINTER_NEW | 0 );
3561 {
3562 if (temp1)
3563 delete arg1;
3564 }
3565 return resultobj;
3566 fail:
3567 {
3568 if (temp1)
3569 delete arg1;
3570 }
3571 return NULL;
3572 }
3573
3574
3575 SWIGINTERN PyObject *_wrap_delete_CLSID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3576 PyObject *resultobj = 0;
3577 CLSID *arg1 = (CLSID *) 0 ;
3578 void *argp1 = 0 ;
3579 int res1 = 0 ;
3580 PyObject *swig_obj[1] ;
3581
3582 if (!args) SWIG_fail;
3583 swig_obj[0] = args;
3584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CLSID, SWIG_POINTER_DISOWN | 0 );
3585 if (!SWIG_IsOK(res1)) {
3586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CLSID" "', expected argument " "1"" of type '" "CLSID *""'");
3587 }
3588 arg1 = reinterpret_cast< CLSID * >(argp1);
3589 {
3590 PyThreadState* __tstate = wxPyBeginAllowThreads();
3591 delete_CLSID(arg1);
3592
3593 wxPyEndAllowThreads(__tstate);
3594 if (PyErr_Occurred()) SWIG_fail;
3595 }
3596 resultobj = SWIG_Py_Void();
3597 return resultobj;
3598 fail:
3599 return NULL;
3600 }
3601
3602
3603 SWIGINTERN PyObject *_wrap_CLSID_GetCLSIDString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3604 PyObject *resultobj = 0;
3605 CLSID *arg1 = (CLSID *) 0 ;
3606 wxString result;
3607 void *argp1 = 0 ;
3608 int res1 = 0 ;
3609 PyObject *swig_obj[1] ;
3610
3611 if (!args) SWIG_fail;
3612 swig_obj[0] = args;
3613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CLSID, 0 | 0 );
3614 if (!SWIG_IsOK(res1)) {
3615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CLSID_GetCLSIDString" "', expected argument " "1"" of type '" "CLSID *""'");
3616 }
3617 arg1 = reinterpret_cast< CLSID * >(argp1);
3618 {
3619 PyThreadState* __tstate = wxPyBeginAllowThreads();
3620 result = CLSID_GetCLSIDString(arg1);
3621 wxPyEndAllowThreads(__tstate);
3622 if (PyErr_Occurred()) SWIG_fail;
3623 }
3624 {
3625 #if wxUSE_UNICODE
3626 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3627 #else
3628 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3629 #endif
3630 }
3631 return resultobj;
3632 fail:
3633 return NULL;
3634 }
3635
3636
3637 SWIGINTERN PyObject *_wrap_CLSID_GetProgIDString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3638 PyObject *resultobj = 0;
3639 CLSID *arg1 = (CLSID *) 0 ;
3640 wxString result;
3641 void *argp1 = 0 ;
3642 int res1 = 0 ;
3643 PyObject *swig_obj[1] ;
3644
3645 if (!args) SWIG_fail;
3646 swig_obj[0] = args;
3647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_CLSID, 0 | 0 );
3648 if (!SWIG_IsOK(res1)) {
3649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CLSID_GetProgIDString" "', expected argument " "1"" of type '" "CLSID *""'");
3650 }
3651 arg1 = reinterpret_cast< CLSID * >(argp1);
3652 {
3653 PyThreadState* __tstate = wxPyBeginAllowThreads();
3654 result = CLSID_GetProgIDString(arg1);
3655 wxPyEndAllowThreads(__tstate);
3656 if (PyErr_Occurred()) SWIG_fail;
3657 }
3658 {
3659 #if wxUSE_UNICODE
3660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3661 #else
3662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3663 #endif
3664 }
3665 return resultobj;
3666 fail:
3667 return NULL;
3668 }
3669
3670
3671 SWIGINTERN PyObject *CLSID_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3672 PyObject *obj;
3673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3674 SWIG_TypeNewClientData(SWIGTYPE_p_CLSID, SWIG_NewClientData(obj));
3675 return SWIG_Py_Void();
3676 }
3677
3678 SWIGINTERN PyObject *CLSID_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3679 return SWIG_Python_InitShadowInstance(args);
3680 }
3681
3682 SWIGINTERN PyObject *_wrap_ParamX_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3683 PyObject *resultobj = 0;
3684 wxParamX *arg1 = (wxParamX *) 0 ;
3685 USHORT result;
3686 void *argp1 = 0 ;
3687 int res1 = 0 ;
3688 PyObject *swig_obj[1] ;
3689
3690 if (!args) SWIG_fail;
3691 swig_obj[0] = args;
3692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxParamX, 0 | 0 );
3693 if (!SWIG_IsOK(res1)) {
3694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamX_flags_get" "', expected argument " "1"" of type '" "wxParamX *""'");
3695 }
3696 arg1 = reinterpret_cast< wxParamX * >(argp1);
3697 result = (USHORT) ((arg1)->flags);
3698 resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
3699 return resultobj;
3700 fail:
3701 return NULL;
3702 }
3703
3704
3705 SWIGINTERN PyObject *_wrap_ParamX_isPtr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3706 PyObject *resultobj = 0;
3707 wxParamX *arg1 = (wxParamX *) 0 ;
3708 bool result;
3709 void *argp1 = 0 ;
3710 int res1 = 0 ;
3711 PyObject *swig_obj[1] ;
3712
3713 if (!args) SWIG_fail;
3714 swig_obj[0] = args;
3715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxParamX, 0 | 0 );
3716 if (!SWIG_IsOK(res1)) {
3717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamX_isPtr_get" "', expected argument " "1"" of type '" "wxParamX *""'");
3718 }
3719 arg1 = reinterpret_cast< wxParamX * >(argp1);
3720 result = (bool) ((arg1)->isPtr);
3721 {
3722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3723 }
3724 return resultobj;
3725 fail:
3726 return NULL;
3727 }
3728
3729
3730 SWIGINTERN PyObject *_wrap_ParamX_isSafeArray_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3731 PyObject *resultobj = 0;
3732 wxParamX *arg1 = (wxParamX *) 0 ;
3733 bool result;
3734 void *argp1 = 0 ;
3735 int res1 = 0 ;
3736 PyObject *swig_obj[1] ;
3737
3738 if (!args) SWIG_fail;
3739 swig_obj[0] = args;
3740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxParamX, 0 | 0 );
3741 if (!SWIG_IsOK(res1)) {
3742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamX_isSafeArray_get" "', expected argument " "1"" of type '" "wxParamX *""'");
3743 }
3744 arg1 = reinterpret_cast< wxParamX * >(argp1);
3745 result = (bool) ((arg1)->isSafeArray);
3746 {
3747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3748 }
3749 return resultobj;
3750 fail:
3751 return NULL;
3752 }
3753
3754
3755 SWIGINTERN PyObject *_wrap_ParamX_isOptional_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3756 PyObject *resultobj = 0;
3757 wxParamX *arg1 = (wxParamX *) 0 ;
3758 bool result;
3759 void *argp1 = 0 ;
3760 int res1 = 0 ;
3761 PyObject *swig_obj[1] ;
3762
3763 if (!args) SWIG_fail;
3764 swig_obj[0] = args;
3765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxParamX, 0 | 0 );
3766 if (!SWIG_IsOK(res1)) {
3767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamX_isOptional_get" "', expected argument " "1"" of type '" "wxParamX *""'");
3768 }
3769 arg1 = reinterpret_cast< wxParamX * >(argp1);
3770 result = (bool) ((arg1)->isOptional);
3771 {
3772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3773 }
3774 return resultobj;
3775 fail:
3776 return NULL;
3777 }
3778
3779
3780 SWIGINTERN PyObject *_wrap_ParamX_vt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3781 PyObject *resultobj = 0;
3782 wxParamX *arg1 = (wxParamX *) 0 ;
3783 VARTYPE result;
3784 void *argp1 = 0 ;
3785 int res1 = 0 ;
3786 PyObject *swig_obj[1] ;
3787
3788 if (!args) SWIG_fail;
3789 swig_obj[0] = args;
3790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxParamX, 0 | 0 );
3791 if (!SWIG_IsOK(res1)) {
3792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamX_vt_get" "', expected argument " "1"" of type '" "wxParamX *""'");
3793 }
3794 arg1 = reinterpret_cast< wxParamX * >(argp1);
3795 result = (VARTYPE) ((arg1)->vt);
3796 resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
3797 return resultobj;
3798 fail:
3799 return NULL;
3800 }
3801
3802
3803 SWIGINTERN PyObject *_wrap_ParamX_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3804 PyObject *resultobj = 0;
3805 wxParamX *arg1 = (wxParamX *) 0 ;
3806 wxString *result = 0 ;
3807 void *argp1 = 0 ;
3808 int res1 = 0 ;
3809 PyObject *swig_obj[1] ;
3810
3811 if (!args) SWIG_fail;
3812 swig_obj[0] = args;
3813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxParamX, 0 | 0 );
3814 if (!SWIG_IsOK(res1)) {
3815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamX_name_get" "', expected argument " "1"" of type '" "wxParamX *""'");
3816 }
3817 arg1 = reinterpret_cast< wxParamX * >(argp1);
3818 result = (wxString *)& ((arg1)->name);
3819 {
3820 #if wxUSE_UNICODE
3821 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
3822 #else
3823 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
3824 #endif
3825 }
3826 return resultobj;
3827 fail:
3828 return NULL;
3829 }
3830
3831
3832 SWIGINTERN PyObject *_wrap_ParamX_vt_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3833 PyObject *resultobj = 0;
3834 wxParamX *arg1 = (wxParamX *) 0 ;
3835 wxString result;
3836 void *argp1 = 0 ;
3837 int res1 = 0 ;
3838 PyObject *swig_obj[1] ;
3839
3840 if (!args) SWIG_fail;
3841 swig_obj[0] = args;
3842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxParamX, 0 | 0 );
3843 if (!SWIG_IsOK(res1)) {
3844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamX_vt_type_get" "', expected argument " "1"" of type '" "wxParamX *""'");
3845 }
3846 arg1 = reinterpret_cast< wxParamX * >(argp1);
3847 {
3848 PyThreadState* __tstate = wxPyBeginAllowThreads();
3849 result = wxParamX_vt_type_get(arg1);
3850 wxPyEndAllowThreads(__tstate);
3851 if (PyErr_Occurred()) SWIG_fail;
3852 }
3853 {
3854 #if wxUSE_UNICODE
3855 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3856 #else
3857 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3858 #endif
3859 }
3860 return resultobj;
3861 fail:
3862 return NULL;
3863 }
3864
3865
3866 SWIGINTERN PyObject *_wrap_ParamX_IsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3867 PyObject *resultobj = 0;
3868 wxParamX *arg1 = (wxParamX *) 0 ;
3869 bool result;
3870 void *argp1 = 0 ;
3871 int res1 = 0 ;
3872 PyObject *swig_obj[1] ;
3873
3874 if (!args) SWIG_fail;
3875 swig_obj[0] = args;
3876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxParamX, 0 | 0 );
3877 if (!SWIG_IsOK(res1)) {
3878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamX_IsIn" "', expected argument " "1"" of type '" "wxParamX const *""'");
3879 }
3880 arg1 = reinterpret_cast< wxParamX * >(argp1);
3881 {
3882 PyThreadState* __tstate = wxPyBeginAllowThreads();
3883 result = (bool)((wxParamX const *)arg1)->IsIn();
3884 wxPyEndAllowThreads(__tstate);
3885 if (PyErr_Occurred()) SWIG_fail;
3886 }
3887 {
3888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3889 }
3890 return resultobj;
3891 fail:
3892 return NULL;
3893 }
3894
3895
3896 SWIGINTERN PyObject *_wrap_ParamX_IsOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3897 PyObject *resultobj = 0;
3898 wxParamX *arg1 = (wxParamX *) 0 ;
3899 bool result;
3900 void *argp1 = 0 ;
3901 int res1 = 0 ;
3902 PyObject *swig_obj[1] ;
3903
3904 if (!args) SWIG_fail;
3905 swig_obj[0] = args;
3906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxParamX, 0 | 0 );
3907 if (!SWIG_IsOK(res1)) {
3908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamX_IsOut" "', expected argument " "1"" of type '" "wxParamX const *""'");
3909 }
3910 arg1 = reinterpret_cast< wxParamX * >(argp1);
3911 {
3912 PyThreadState* __tstate = wxPyBeginAllowThreads();
3913 result = (bool)((wxParamX const *)arg1)->IsOut();
3914 wxPyEndAllowThreads(__tstate);
3915 if (PyErr_Occurred()) SWIG_fail;
3916 }
3917 {
3918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3919 }
3920 return resultobj;
3921 fail:
3922 return NULL;
3923 }
3924
3925
3926 SWIGINTERN PyObject *_wrap_ParamX_IsRetVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3927 PyObject *resultobj = 0;
3928 wxParamX *arg1 = (wxParamX *) 0 ;
3929 bool result;
3930 void *argp1 = 0 ;
3931 int res1 = 0 ;
3932 PyObject *swig_obj[1] ;
3933
3934 if (!args) SWIG_fail;
3935 swig_obj[0] = args;
3936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxParamX, 0 | 0 );
3937 if (!SWIG_IsOK(res1)) {
3938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamX_IsRetVal" "', expected argument " "1"" of type '" "wxParamX const *""'");
3939 }
3940 arg1 = reinterpret_cast< wxParamX * >(argp1);
3941 {
3942 PyThreadState* __tstate = wxPyBeginAllowThreads();
3943 result = (bool)((wxParamX const *)arg1)->IsRetVal();
3944 wxPyEndAllowThreads(__tstate);
3945 if (PyErr_Occurred()) SWIG_fail;
3946 }
3947 {
3948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3949 }
3950 return resultobj;
3951 fail:
3952 return NULL;
3953 }
3954
3955
3956 SWIGINTERN PyObject *ParamX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3957 PyObject *obj;
3958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3959 SWIG_TypeNewClientData(SWIGTYPE_p_wxParamX, SWIG_NewClientData(obj));
3960 return SWIG_Py_Void();
3961 }
3962
3963 SWIGINTERN PyObject *_wrap_FuncX_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3964 PyObject *resultobj = 0;
3965 wxFuncX *arg1 = (wxFuncX *) 0 ;
3966 wxString *result = 0 ;
3967 void *argp1 = 0 ;
3968 int res1 = 0 ;
3969 PyObject *swig_obj[1] ;
3970
3971 if (!args) SWIG_fail;
3972 swig_obj[0] = args;
3973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFuncX, 0 | 0 );
3974 if (!SWIG_IsOK(res1)) {
3975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FuncX_name_get" "', expected argument " "1"" of type '" "wxFuncX *""'");
3976 }
3977 arg1 = reinterpret_cast< wxFuncX * >(argp1);
3978 result = (wxString *)& ((arg1)->name);
3979 {
3980 #if wxUSE_UNICODE
3981 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
3982 #else
3983 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
3984 #endif
3985 }
3986 return resultobj;
3987 fail:
3988 return NULL;
3989 }
3990
3991
3992 SWIGINTERN PyObject *_wrap_FuncX_memid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3993 PyObject *resultobj = 0;
3994 wxFuncX *arg1 = (wxFuncX *) 0 ;
3995 MEMBERID result;
3996 void *argp1 = 0 ;
3997 int res1 = 0 ;
3998 PyObject *swig_obj[1] ;
3999
4000 if (!args) SWIG_fail;
4001 swig_obj[0] = args;
4002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFuncX, 0 | 0 );
4003 if (!SWIG_IsOK(res1)) {
4004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FuncX_memid_get" "', expected argument " "1"" of type '" "wxFuncX *""'");
4005 }
4006 arg1 = reinterpret_cast< wxFuncX * >(argp1);
4007 result = (MEMBERID) ((arg1)->memid);
4008 resultobj = SWIG_From_long(static_cast< long >(result));
4009 return resultobj;
4010 fail:
4011 return NULL;
4012 }
4013
4014
4015 SWIGINTERN PyObject *_wrap_FuncX_hasOut_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4016 PyObject *resultobj = 0;
4017 wxFuncX *arg1 = (wxFuncX *) 0 ;
4018 bool result;
4019 void *argp1 = 0 ;
4020 int res1 = 0 ;
4021 PyObject *swig_obj[1] ;
4022
4023 if (!args) SWIG_fail;
4024 swig_obj[0] = args;
4025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFuncX, 0 | 0 );
4026 if (!SWIG_IsOK(res1)) {
4027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FuncX_hasOut_get" "', expected argument " "1"" of type '" "wxFuncX *""'");
4028 }
4029 arg1 = reinterpret_cast< wxFuncX * >(argp1);
4030 result = (bool) ((arg1)->hasOut);
4031 {
4032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4033 }
4034 return resultobj;
4035 fail:
4036 return NULL;
4037 }
4038
4039
4040 SWIGINTERN PyObject *_wrap_FuncX_retType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4041 PyObject *resultobj = 0;
4042 wxFuncX *arg1 = (wxFuncX *) 0 ;
4043 wxParamX *result = 0 ;
4044 void *argp1 = 0 ;
4045 int res1 = 0 ;
4046 PyObject *swig_obj[1] ;
4047
4048 if (!args) SWIG_fail;
4049 swig_obj[0] = args;
4050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFuncX, 0 | 0 );
4051 if (!SWIG_IsOK(res1)) {
4052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FuncX_retType_get" "', expected argument " "1"" of type '" "wxFuncX *""'");
4053 }
4054 arg1 = reinterpret_cast< wxFuncX * >(argp1);
4055 result = (wxParamX *)& ((arg1)->retType);
4056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxParamX, 0 | 0 );
4057 return resultobj;
4058 fail:
4059 return NULL;
4060 }
4061
4062
4063 SWIGINTERN PyObject *_wrap_FuncX_params_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4064 PyObject *resultobj = 0;
4065 wxFuncX *arg1 = (wxFuncX *) 0 ;
4066 wxParamXArray *result = 0 ;
4067 void *argp1 = 0 ;
4068 int res1 = 0 ;
4069 PyObject *swig_obj[1] ;
4070
4071 if (!args) SWIG_fail;
4072 swig_obj[0] = args;
4073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFuncX, 0 | 0 );
4074 if (!SWIG_IsOK(res1)) {
4075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FuncX_params_get" "', expected argument " "1"" of type '" "wxFuncX *""'");
4076 }
4077 arg1 = reinterpret_cast< wxFuncX * >(argp1);
4078 result = (wxParamXArray *)& ((arg1)->params);
4079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxParamXArray, 0 | 0 );
4080 return resultobj;
4081 fail:
4082 return NULL;
4083 }
4084
4085
4086 SWIGINTERN PyObject *FuncX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4087 PyObject *obj;
4088 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4089 SWIG_TypeNewClientData(SWIGTYPE_p_wxFuncX, SWIG_NewClientData(obj));
4090 return SWIG_Py_Void();
4091 }
4092
4093 SWIGINTERN PyObject *_wrap_PropX_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4094 PyObject *resultobj = 0;
4095 wxPropX *arg1 = (wxPropX *) 0 ;
4096 wxString *result = 0 ;
4097 void *argp1 = 0 ;
4098 int res1 = 0 ;
4099 PyObject *swig_obj[1] ;
4100
4101 if (!args) SWIG_fail;
4102 swig_obj[0] = args;
4103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropX, 0 | 0 );
4104 if (!SWIG_IsOK(res1)) {
4105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropX_name_get" "', expected argument " "1"" of type '" "wxPropX *""'");
4106 }
4107 arg1 = reinterpret_cast< wxPropX * >(argp1);
4108 result = (wxString *)& ((arg1)->name);
4109 {
4110 #if wxUSE_UNICODE
4111 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
4112 #else
4113 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
4114 #endif
4115 }
4116 return resultobj;
4117 fail:
4118 return NULL;
4119 }
4120
4121
4122 SWIGINTERN PyObject *_wrap_PropX_memid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4123 PyObject *resultobj = 0;
4124 wxPropX *arg1 = (wxPropX *) 0 ;
4125 MEMBERID result;
4126 void *argp1 = 0 ;
4127 int res1 = 0 ;
4128 PyObject *swig_obj[1] ;
4129
4130 if (!args) SWIG_fail;
4131 swig_obj[0] = args;
4132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropX, 0 | 0 );
4133 if (!SWIG_IsOK(res1)) {
4134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropX_memid_get" "', expected argument " "1"" of type '" "wxPropX *""'");
4135 }
4136 arg1 = reinterpret_cast< wxPropX * >(argp1);
4137 result = (MEMBERID) ((arg1)->memid);
4138 resultobj = SWIG_From_long(static_cast< long >(result));
4139 return resultobj;
4140 fail:
4141 return NULL;
4142 }
4143
4144
4145 SWIGINTERN PyObject *_wrap_PropX_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4146 PyObject *resultobj = 0;
4147 wxPropX *arg1 = (wxPropX *) 0 ;
4148 wxParamX *result = 0 ;
4149 void *argp1 = 0 ;
4150 int res1 = 0 ;
4151 PyObject *swig_obj[1] ;
4152
4153 if (!args) SWIG_fail;
4154 swig_obj[0] = args;
4155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropX, 0 | 0 );
4156 if (!SWIG_IsOK(res1)) {
4157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropX_type_get" "', expected argument " "1"" of type '" "wxPropX *""'");
4158 }
4159 arg1 = reinterpret_cast< wxPropX * >(argp1);
4160 result = (wxParamX *)& ((arg1)->type);
4161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxParamX, 0 | 0 );
4162 return resultobj;
4163 fail:
4164 return NULL;
4165 }
4166
4167
4168 SWIGINTERN PyObject *_wrap_PropX_arg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4169 PyObject *resultobj = 0;
4170 wxPropX *arg1 = (wxPropX *) 0 ;
4171 wxParamX *result = 0 ;
4172 void *argp1 = 0 ;
4173 int res1 = 0 ;
4174 PyObject *swig_obj[1] ;
4175
4176 if (!args) SWIG_fail;
4177 swig_obj[0] = args;
4178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropX, 0 | 0 );
4179 if (!SWIG_IsOK(res1)) {
4180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropX_arg_get" "', expected argument " "1"" of type '" "wxPropX *""'");
4181 }
4182 arg1 = reinterpret_cast< wxPropX * >(argp1);
4183 result = (wxParamX *)& ((arg1)->arg);
4184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxParamX, 0 | 0 );
4185 return resultobj;
4186 fail:
4187 return NULL;
4188 }
4189
4190
4191 SWIGINTERN PyObject *_wrap_PropX_putByRef_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4192 PyObject *resultobj = 0;
4193 wxPropX *arg1 = (wxPropX *) 0 ;
4194 bool result;
4195 void *argp1 = 0 ;
4196 int res1 = 0 ;
4197 PyObject *swig_obj[1] ;
4198
4199 if (!args) SWIG_fail;
4200 swig_obj[0] = args;
4201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropX, 0 | 0 );
4202 if (!SWIG_IsOK(res1)) {
4203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropX_putByRef_get" "', expected argument " "1"" of type '" "wxPropX *""'");
4204 }
4205 arg1 = reinterpret_cast< wxPropX * >(argp1);
4206 result = (bool) ((arg1)->putByRef);
4207 {
4208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4209 }
4210 return resultobj;
4211 fail:
4212 return NULL;
4213 }
4214
4215
4216 SWIGINTERN PyObject *_wrap_PropX_CanGet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4217 PyObject *resultobj = 0;
4218 wxPropX *arg1 = (wxPropX *) 0 ;
4219 bool result;
4220 void *argp1 = 0 ;
4221 int res1 = 0 ;
4222 PyObject *swig_obj[1] ;
4223
4224 if (!args) SWIG_fail;
4225 swig_obj[0] = args;
4226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropX, 0 | 0 );
4227 if (!SWIG_IsOK(res1)) {
4228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropX_CanGet" "', expected argument " "1"" of type '" "wxPropX const *""'");
4229 }
4230 arg1 = reinterpret_cast< wxPropX * >(argp1);
4231 {
4232 PyThreadState* __tstate = wxPyBeginAllowThreads();
4233 result = (bool)((wxPropX const *)arg1)->CanGet();
4234 wxPyEndAllowThreads(__tstate);
4235 if (PyErr_Occurred()) SWIG_fail;
4236 }
4237 {
4238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4239 }
4240 return resultobj;
4241 fail:
4242 return NULL;
4243 }
4244
4245
4246 SWIGINTERN PyObject *_wrap_PropX_CanSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4247 PyObject *resultobj = 0;
4248 wxPropX *arg1 = (wxPropX *) 0 ;
4249 bool result;
4250 void *argp1 = 0 ;
4251 int res1 = 0 ;
4252 PyObject *swig_obj[1] ;
4253
4254 if (!args) SWIG_fail;
4255 swig_obj[0] = args;
4256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropX, 0 | 0 );
4257 if (!SWIG_IsOK(res1)) {
4258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropX_CanSet" "', expected argument " "1"" of type '" "wxPropX const *""'");
4259 }
4260 arg1 = reinterpret_cast< wxPropX * >(argp1);
4261 {
4262 PyThreadState* __tstate = wxPyBeginAllowThreads();
4263 result = (bool)((wxPropX const *)arg1)->CanSet();
4264 wxPyEndAllowThreads(__tstate);
4265 if (PyErr_Occurred()) SWIG_fail;
4266 }
4267 {
4268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4269 }
4270 return resultobj;
4271 fail:
4272 return NULL;
4273 }
4274
4275
4276 SWIGINTERN PyObject *PropX_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4277 PyObject *obj;
4278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4279 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropX, SWIG_NewClientData(obj));
4280 return SWIG_Py_Void();
4281 }
4282
4283 SWIGINTERN PyObject *_wrap_ParamXArray___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4284 PyObject *resultobj = 0;
4285 wxParamXArray *arg1 = (wxParamXArray *) 0 ;
4286 bool result;
4287 void *argp1 = 0 ;
4288 int res1 = 0 ;
4289 PyObject *swig_obj[1] ;
4290
4291 if (!args) SWIG_fail;
4292 swig_obj[0] = args;
4293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxParamXArray, 0 | 0 );
4294 if (!SWIG_IsOK(res1)) {
4295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamXArray___nonzero__" "', expected argument " "1"" of type '" "wxParamXArray *""'");
4296 }
4297 arg1 = reinterpret_cast< wxParamXArray * >(argp1);
4298 {
4299 PyThreadState* __tstate = wxPyBeginAllowThreads();
4300 result = (bool)wxParamXArray___nonzero__(arg1);
4301 wxPyEndAllowThreads(__tstate);
4302 if (PyErr_Occurred()) SWIG_fail;
4303 }
4304 {
4305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4306 }
4307 return resultobj;
4308 fail:
4309 return NULL;
4310 }
4311
4312
4313 SWIGINTERN PyObject *_wrap_ParamXArray___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4314 PyObject *resultobj = 0;
4315 wxParamXArray *arg1 = (wxParamXArray *) 0 ;
4316 int result;
4317 void *argp1 = 0 ;
4318 int res1 = 0 ;
4319 PyObject *swig_obj[1] ;
4320
4321 if (!args) SWIG_fail;
4322 swig_obj[0] = args;
4323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxParamXArray, 0 | 0 );
4324 if (!SWIG_IsOK(res1)) {
4325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamXArray___len__" "', expected argument " "1"" of type '" "wxParamXArray *""'");
4326 }
4327 arg1 = reinterpret_cast< wxParamXArray * >(argp1);
4328 {
4329 PyThreadState* __tstate = wxPyBeginAllowThreads();
4330 result = (int)wxParamXArray___len__(arg1);
4331 wxPyEndAllowThreads(__tstate);
4332 if (PyErr_Occurred()) SWIG_fail;
4333 }
4334 resultobj = SWIG_From_int(static_cast< int >(result));
4335 return resultobj;
4336 fail:
4337 return NULL;
4338 }
4339
4340
4341 SWIGINTERN PyObject *_wrap_ParamXArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4342 PyObject *resultobj = 0;
4343 wxParamXArray *arg1 = (wxParamXArray *) 0 ;
4344 int arg2 ;
4345 wxParamX *result = 0 ;
4346 void *argp1 = 0 ;
4347 int res1 = 0 ;
4348 int val2 ;
4349 int ecode2 = 0 ;
4350 PyObject * obj0 = 0 ;
4351 PyObject * obj1 = 0 ;
4352 char * kwnames[] = {
4353 (char *) "self",(char *) "idx", NULL
4354 };
4355
4356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ParamXArray___getitem__",kwnames,&obj0,&obj1)) SWIG_fail;
4357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxParamXArray, 0 | 0 );
4358 if (!SWIG_IsOK(res1)) {
4359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamXArray___getitem__" "', expected argument " "1"" of type '" "wxParamXArray *""'");
4360 }
4361 arg1 = reinterpret_cast< wxParamXArray * >(argp1);
4362 ecode2 = SWIG_AsVal_int(obj1, &val2);
4363 if (!SWIG_IsOK(ecode2)) {
4364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParamXArray___getitem__" "', expected argument " "2"" of type '" "int""'");
4365 }
4366 arg2 = static_cast< int >(val2);
4367 {
4368 PyThreadState* __tstate = wxPyBeginAllowThreads();
4369 {
4370 wxParamX const &_result_ref = wxParamXArray___getitem__(arg1,arg2);
4371 result = (wxParamX *) &_result_ref;
4372 }
4373 wxPyEndAllowThreads(__tstate);
4374 if (PyErr_Occurred()) SWIG_fail;
4375 }
4376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxParamX, 0 | 0 );
4377 return resultobj;
4378 fail:
4379 return NULL;
4380 }
4381
4382
4383 SWIGINTERN PyObject *ParamXArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4384 PyObject *obj;
4385 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4386 SWIG_TypeNewClientData(SWIGTYPE_p_wxParamXArray, SWIG_NewClientData(obj));
4387 return SWIG_Py_Void();
4388 }
4389
4390 SWIGINTERN PyObject *_wrap_FuncXArray___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4391 PyObject *resultobj = 0;
4392 wxFuncXArray *arg1 = (wxFuncXArray *) 0 ;
4393 bool result;
4394 void *argp1 = 0 ;
4395 int res1 = 0 ;
4396 PyObject *swig_obj[1] ;
4397
4398 if (!args) SWIG_fail;
4399 swig_obj[0] = args;
4400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFuncXArray, 0 | 0 );
4401 if (!SWIG_IsOK(res1)) {
4402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FuncXArray___nonzero__" "', expected argument " "1"" of type '" "wxFuncXArray *""'");
4403 }
4404 arg1 = reinterpret_cast< wxFuncXArray * >(argp1);
4405 {
4406 PyThreadState* __tstate = wxPyBeginAllowThreads();
4407 result = (bool)wxFuncXArray___nonzero__(arg1);
4408 wxPyEndAllowThreads(__tstate);
4409 if (PyErr_Occurred()) SWIG_fail;
4410 }
4411 {
4412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4413 }
4414 return resultobj;
4415 fail:
4416 return NULL;
4417 }
4418
4419
4420 SWIGINTERN PyObject *_wrap_FuncXArray___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4421 PyObject *resultobj = 0;
4422 wxFuncXArray *arg1 = (wxFuncXArray *) 0 ;
4423 int result;
4424 void *argp1 = 0 ;
4425 int res1 = 0 ;
4426 PyObject *swig_obj[1] ;
4427
4428 if (!args) SWIG_fail;
4429 swig_obj[0] = args;
4430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFuncXArray, 0 | 0 );
4431 if (!SWIG_IsOK(res1)) {
4432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FuncXArray___len__" "', expected argument " "1"" of type '" "wxFuncXArray *""'");
4433 }
4434 arg1 = reinterpret_cast< wxFuncXArray * >(argp1);
4435 {
4436 PyThreadState* __tstate = wxPyBeginAllowThreads();
4437 result = (int)wxFuncXArray___len__(arg1);
4438 wxPyEndAllowThreads(__tstate);
4439 if (PyErr_Occurred()) SWIG_fail;
4440 }
4441 resultobj = SWIG_From_int(static_cast< int >(result));
4442 return resultobj;
4443 fail:
4444 return NULL;
4445 }
4446
4447
4448 SWIGINTERN PyObject *_wrap_FuncXArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4449 PyObject *resultobj = 0;
4450 wxFuncXArray *arg1 = (wxFuncXArray *) 0 ;
4451 int arg2 ;
4452 wxFuncX *result = 0 ;
4453 void *argp1 = 0 ;
4454 int res1 = 0 ;
4455 int val2 ;
4456 int ecode2 = 0 ;
4457 PyObject * obj0 = 0 ;
4458 PyObject * obj1 = 0 ;
4459 char * kwnames[] = {
4460 (char *) "self",(char *) "idx", NULL
4461 };
4462
4463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FuncXArray___getitem__",kwnames,&obj0,&obj1)) SWIG_fail;
4464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFuncXArray, 0 | 0 );
4465 if (!SWIG_IsOK(res1)) {
4466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FuncXArray___getitem__" "', expected argument " "1"" of type '" "wxFuncXArray *""'");
4467 }
4468 arg1 = reinterpret_cast< wxFuncXArray * >(argp1);
4469 ecode2 = SWIG_AsVal_int(obj1, &val2);
4470 if (!SWIG_IsOK(ecode2)) {
4471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FuncXArray___getitem__" "', expected argument " "2"" of type '" "int""'");
4472 }
4473 arg2 = static_cast< int >(val2);
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 {
4477 wxFuncX const &_result_ref = wxFuncXArray___getitem__(arg1,arg2);
4478 result = (wxFuncX *) &_result_ref;
4479 }
4480 wxPyEndAllowThreads(__tstate);
4481 if (PyErr_Occurred()) SWIG_fail;
4482 }
4483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFuncX, 0 | 0 );
4484 return resultobj;
4485 fail:
4486 return NULL;
4487 }
4488
4489
4490 SWIGINTERN PyObject *FuncXArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4491 PyObject *obj;
4492 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4493 SWIG_TypeNewClientData(SWIGTYPE_p_wxFuncXArray, SWIG_NewClientData(obj));
4494 return SWIG_Py_Void();
4495 }
4496
4497 SWIGINTERN PyObject *_wrap_PropXArray___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4498 PyObject *resultobj = 0;
4499 wxPropXArray *arg1 = (wxPropXArray *) 0 ;
4500 bool result;
4501 void *argp1 = 0 ;
4502 int res1 = 0 ;
4503 PyObject *swig_obj[1] ;
4504
4505 if (!args) SWIG_fail;
4506 swig_obj[0] = args;
4507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropXArray, 0 | 0 );
4508 if (!SWIG_IsOK(res1)) {
4509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropXArray___nonzero__" "', expected argument " "1"" of type '" "wxPropXArray *""'");
4510 }
4511 arg1 = reinterpret_cast< wxPropXArray * >(argp1);
4512 {
4513 PyThreadState* __tstate = wxPyBeginAllowThreads();
4514 result = (bool)wxPropXArray___nonzero__(arg1);
4515 wxPyEndAllowThreads(__tstate);
4516 if (PyErr_Occurred()) SWIG_fail;
4517 }
4518 {
4519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4520 }
4521 return resultobj;
4522 fail:
4523 return NULL;
4524 }
4525
4526
4527 SWIGINTERN PyObject *_wrap_PropXArray___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4528 PyObject *resultobj = 0;
4529 wxPropXArray *arg1 = (wxPropXArray *) 0 ;
4530 int result;
4531 void *argp1 = 0 ;
4532 int res1 = 0 ;
4533 PyObject *swig_obj[1] ;
4534
4535 if (!args) SWIG_fail;
4536 swig_obj[0] = args;
4537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropXArray, 0 | 0 );
4538 if (!SWIG_IsOK(res1)) {
4539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropXArray___len__" "', expected argument " "1"" of type '" "wxPropXArray *""'");
4540 }
4541 arg1 = reinterpret_cast< wxPropXArray * >(argp1);
4542 {
4543 PyThreadState* __tstate = wxPyBeginAllowThreads();
4544 result = (int)wxPropXArray___len__(arg1);
4545 wxPyEndAllowThreads(__tstate);
4546 if (PyErr_Occurred()) SWIG_fail;
4547 }
4548 resultobj = SWIG_From_int(static_cast< int >(result));
4549 return resultobj;
4550 fail:
4551 return NULL;
4552 }
4553
4554
4555 SWIGINTERN PyObject *_wrap_PropXArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4556 PyObject *resultobj = 0;
4557 wxPropXArray *arg1 = (wxPropXArray *) 0 ;
4558 int arg2 ;
4559 wxPropX *result = 0 ;
4560 void *argp1 = 0 ;
4561 int res1 = 0 ;
4562 int val2 ;
4563 int ecode2 = 0 ;
4564 PyObject * obj0 = 0 ;
4565 PyObject * obj1 = 0 ;
4566 char * kwnames[] = {
4567 (char *) "self",(char *) "idx", NULL
4568 };
4569
4570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PropXArray___getitem__",kwnames,&obj0,&obj1)) SWIG_fail;
4571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPropXArray, 0 | 0 );
4572 if (!SWIG_IsOK(res1)) {
4573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropXArray___getitem__" "', expected argument " "1"" of type '" "wxPropXArray *""'");
4574 }
4575 arg1 = reinterpret_cast< wxPropXArray * >(argp1);
4576 ecode2 = SWIG_AsVal_int(obj1, &val2);
4577 if (!SWIG_IsOK(ecode2)) {
4578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PropXArray___getitem__" "', expected argument " "2"" of type '" "int""'");
4579 }
4580 arg2 = static_cast< int >(val2);
4581 {
4582 PyThreadState* __tstate = wxPyBeginAllowThreads();
4583 {
4584 wxPropX const &_result_ref = wxPropXArray___getitem__(arg1,arg2);
4585 result = (wxPropX *) &_result_ref;
4586 }
4587 wxPyEndAllowThreads(__tstate);
4588 if (PyErr_Occurred()) SWIG_fail;
4589 }
4590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropX, 0 | 0 );
4591 return resultobj;
4592 fail:
4593 return NULL;
4594 }
4595
4596
4597 SWIGINTERN PyObject *PropXArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4598 PyObject *obj;
4599 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4600 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropXArray, SWIG_NewClientData(obj));
4601 return SWIG_Py_Void();
4602 }
4603
4604 SWIGINTERN PyObject *_wrap_new_ActiveXWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4605 PyObject *resultobj = 0;
4606 wxWindow *arg1 = (wxWindow *) 0 ;
4607 CLSID *arg2 = 0 ;
4608 int arg3 = (int) -1 ;
4609 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4610 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4611 wxSize const &arg5_defvalue = wxDefaultSize ;
4612 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
4613 long arg6 = (long) 0 ;
4614 wxString const &arg7_defvalue = wxPyPanelNameStr ;
4615 wxString *arg7 = (wxString *) &arg7_defvalue ;
4616 wxActiveXWindow *result = 0 ;
4617 void *argp1 = 0 ;
4618 int res1 = 0 ;
4619 void *argp2 = 0 ;
4620 int res2 = 0 ;
4621 int val3 ;
4622 int ecode3 = 0 ;
4623 wxPoint temp4 ;
4624 wxSize temp5 ;
4625 long val6 ;
4626 int ecode6 = 0 ;
4627 bool temp7 = false ;
4628 PyObject * obj0 = 0 ;
4629 PyObject * obj1 = 0 ;
4630 PyObject * obj2 = 0 ;
4631 PyObject * obj3 = 0 ;
4632 PyObject * obj4 = 0 ;
4633 PyObject * obj5 = 0 ;
4634 PyObject * obj6 = 0 ;
4635 char * kwnames[] = {
4636 (char *) "parent",(char *) "clsId",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
4637 };
4638
4639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:new_ActiveXWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
4640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
4641 if (!SWIG_IsOK(res1)) {
4642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ActiveXWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
4643 }
4644 arg1 = reinterpret_cast< wxWindow * >(argp1);
4645 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CLSID, 0 | 0);
4646 if (!SWIG_IsOK(res2)) {
4647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ActiveXWindow" "', expected argument " "2"" of type '" "CLSID const &""'");
4648 }
4649 if (!argp2) {
4650 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ActiveXWindow" "', expected argument " "2"" of type '" "CLSID const &""'");
4651 }
4652 arg2 = reinterpret_cast< CLSID * >(argp2);
4653 if (obj2) {
4654 ecode3 = SWIG_AsVal_int(obj2, &val3);
4655 if (!SWIG_IsOK(ecode3)) {
4656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActiveXWindow" "', expected argument " "3"" of type '" "int""'");
4657 }
4658 arg3 = static_cast< int >(val3);
4659 }
4660 if (obj3) {
4661 {
4662 arg4 = &temp4;
4663 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4664 }
4665 }
4666 if (obj4) {
4667 {
4668 arg5 = &temp5;
4669 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
4670 }
4671 }
4672 if (obj5) {
4673 ecode6 = SWIG_AsVal_long(obj5, &val6);
4674 if (!SWIG_IsOK(ecode6)) {
4675 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ActiveXWindow" "', expected argument " "6"" of type '" "long""'");
4676 }
4677 arg6 = static_cast< long >(val6);
4678 }
4679 if (obj6) {
4680 {
4681 arg7 = wxString_in_helper(obj6);
4682 if (arg7 == NULL) SWIG_fail;
4683 temp7 = true;
4684 }
4685 }
4686 {
4687 if (!wxPyCheckForApp()) SWIG_fail;
4688 PyThreadState* __tstate = wxPyBeginAllowThreads();
4689 result = (wxActiveXWindow *)new wxActiveXWindow(arg1,(CLSID const &)*arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
4690 wxPyEndAllowThreads(__tstate);
4691 if (PyErr_Occurred()) SWIG_fail;
4692 }
4693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActiveXWindow, SWIG_POINTER_NEW | 0 );
4694 {
4695 if (temp7)
4696 delete arg7;
4697 }
4698 return resultobj;
4699 fail:
4700 {
4701 if (temp7)
4702 delete arg7;
4703 }
4704 return NULL;
4705 }
4706
4707
4708 SWIGINTERN PyObject *_wrap_ActiveXWindow_GetCLSID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4709 PyObject *resultobj = 0;
4710 wxActiveXWindow *arg1 = (wxActiveXWindow *) 0 ;
4711 CLSID *result = 0 ;
4712 void *argp1 = 0 ;
4713 int res1 = 0 ;
4714 PyObject *swig_obj[1] ;
4715
4716 if (!args) SWIG_fail;
4717 swig_obj[0] = args;
4718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActiveXWindow, 0 | 0 );
4719 if (!SWIG_IsOK(res1)) {
4720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXWindow_GetCLSID" "', expected argument " "1"" of type '" "wxActiveXWindow const *""'");
4721 }
4722 arg1 = reinterpret_cast< wxActiveXWindow * >(argp1);
4723 {
4724 PyThreadState* __tstate = wxPyBeginAllowThreads();
4725 {
4726 CLSID const &_result_ref = ((wxActiveXWindow const *)arg1)->GetCLSID();
4727 result = (CLSID *) &_result_ref;
4728 }
4729 wxPyEndAllowThreads(__tstate);
4730 if (PyErr_Occurred()) SWIG_fail;
4731 }
4732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CLSID, 0 | 0 );
4733 return resultobj;
4734 fail:
4735 return NULL;
4736 }
4737
4738
4739 SWIGINTERN PyObject *_wrap_ActiveXWindow_GetAXEventCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4740 PyObject *resultobj = 0;
4741 wxActiveXWindow *arg1 = (wxActiveXWindow *) 0 ;
4742 int result;
4743 void *argp1 = 0 ;
4744 int res1 = 0 ;
4745 PyObject *swig_obj[1] ;
4746
4747 if (!args) SWIG_fail;
4748 swig_obj[0] = args;
4749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActiveXWindow, 0 | 0 );
4750 if (!SWIG_IsOK(res1)) {
4751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXWindow_GetAXEventCount" "', expected argument " "1"" of type '" "wxActiveXWindow const *""'");
4752 }
4753 arg1 = reinterpret_cast< wxActiveXWindow * >(argp1);
4754 {
4755 PyThreadState* __tstate = wxPyBeginAllowThreads();
4756 result = (int)((wxActiveXWindow const *)arg1)->GetAXEventCount();
4757 wxPyEndAllowThreads(__tstate);
4758 if (PyErr_Occurred()) SWIG_fail;
4759 }
4760 resultobj = SWIG_From_int(static_cast< int >(result));
4761 return resultobj;
4762 fail:
4763 return NULL;
4764 }
4765
4766
4767 SWIGINTERN PyObject *_wrap_ActiveXWindow_GetAXEventDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4768 PyObject *resultobj = 0;
4769 wxActiveXWindow *arg1 = (wxActiveXWindow *) 0 ;
4770 int arg2 ;
4771 wxFuncX *result = 0 ;
4772 void *argp1 = 0 ;
4773 int res1 = 0 ;
4774 int val2 ;
4775 int ecode2 = 0 ;
4776 PyObject * obj0 = 0 ;
4777 PyObject * obj1 = 0 ;
4778 char * kwnames[] = {
4779 (char *) "self",(char *) "idx", NULL
4780 };
4781
4782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ActiveXWindow_GetAXEventDesc",kwnames,&obj0,&obj1)) SWIG_fail;
4783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxActiveXWindow, 0 | 0 );
4784 if (!SWIG_IsOK(res1)) {
4785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXWindow_GetAXEventDesc" "', expected argument " "1"" of type '" "wxActiveXWindow const *""'");
4786 }
4787 arg1 = reinterpret_cast< wxActiveXWindow * >(argp1);
4788 ecode2 = SWIG_AsVal_int(obj1, &val2);
4789 if (!SWIG_IsOK(ecode2)) {
4790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActiveXWindow_GetAXEventDesc" "', expected argument " "2"" of type '" "int""'");
4791 }
4792 arg2 = static_cast< int >(val2);
4793 {
4794 PyThreadState* __tstate = wxPyBeginAllowThreads();
4795 {
4796 wxFuncX const &_result_ref = ((wxActiveXWindow const *)arg1)->GetAXEventDesc(arg2);
4797 result = (wxFuncX *) &_result_ref;
4798 }
4799 wxPyEndAllowThreads(__tstate);
4800 if (PyErr_Occurred()) SWIG_fail;
4801 }
4802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFuncX, 0 | 0 );
4803 return resultobj;
4804 fail:
4805 return NULL;
4806 }
4807
4808
4809 SWIGINTERN PyObject *_wrap_ActiveXWindow_GetAXPropCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4810 PyObject *resultobj = 0;
4811 wxActiveXWindow *arg1 = (wxActiveXWindow *) 0 ;
4812 int result;
4813 void *argp1 = 0 ;
4814 int res1 = 0 ;
4815 PyObject *swig_obj[1] ;
4816
4817 if (!args) SWIG_fail;
4818 swig_obj[0] = args;
4819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActiveXWindow, 0 | 0 );
4820 if (!SWIG_IsOK(res1)) {
4821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXWindow_GetAXPropCount" "', expected argument " "1"" of type '" "wxActiveXWindow const *""'");
4822 }
4823 arg1 = reinterpret_cast< wxActiveXWindow * >(argp1);
4824 {
4825 PyThreadState* __tstate = wxPyBeginAllowThreads();
4826 result = (int)((wxActiveXWindow const *)arg1)->GetAXPropCount();
4827 wxPyEndAllowThreads(__tstate);
4828 if (PyErr_Occurred()) SWIG_fail;
4829 }
4830 resultobj = SWIG_From_int(static_cast< int >(result));
4831 return resultobj;
4832 fail:
4833 return NULL;
4834 }
4835
4836
4837 SWIGINTERN PyObject *_wrap_ActiveXWindow_GetAXPropDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4838 PyObject *resultobj = 0;
4839 wxActiveXWindow *arg1 = (wxActiveXWindow *) 0 ;
4840 int arg2 ;
4841 wxPropX *result = 0 ;
4842 void *argp1 = 0 ;
4843 int res1 = 0 ;
4844 int val2 ;
4845 int ecode2 = 0 ;
4846
4847 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
4848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActiveXWindow, 0 | 0 );
4849 if (!SWIG_IsOK(res1)) {
4850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXWindow_GetAXPropDesc" "', expected argument " "1"" of type '" "wxActiveXWindow const *""'");
4851 }
4852 arg1 = reinterpret_cast< wxActiveXWindow * >(argp1);
4853 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4854 if (!SWIG_IsOK(ecode2)) {
4855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActiveXWindow_GetAXPropDesc" "', expected argument " "2"" of type '" "int""'");
4856 }
4857 arg2 = static_cast< int >(val2);
4858 {
4859 PyThreadState* __tstate = wxPyBeginAllowThreads();
4860 {
4861 wxPropX const &_result_ref = ((wxActiveXWindow const *)arg1)->GetAXPropDesc(arg2);
4862 result = (wxPropX *) &_result_ref;
4863 }
4864 wxPyEndAllowThreads(__tstate);
4865 if (PyErr_Occurred()) SWIG_fail;
4866 }
4867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropX, 0 | 0 );
4868 return resultobj;
4869 fail:
4870 return NULL;
4871 }
4872
4873
4874 SWIGINTERN PyObject *_wrap_ActiveXWindow_GetAXPropDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4875 PyObject *resultobj = 0;
4876 wxActiveXWindow *arg1 = (wxActiveXWindow *) 0 ;
4877 wxString *arg2 = 0 ;
4878 wxPropX *result = 0 ;
4879 void *argp1 = 0 ;
4880 int res1 = 0 ;
4881 bool temp2 = false ;
4882
4883 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
4884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActiveXWindow, 0 | 0 );
4885 if (!SWIG_IsOK(res1)) {
4886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXWindow_GetAXPropDesc" "', expected argument " "1"" of type '" "wxActiveXWindow const *""'");
4887 }
4888 arg1 = reinterpret_cast< wxActiveXWindow * >(argp1);
4889 {
4890 arg2 = wxString_in_helper(swig_obj[1]);
4891 if (arg2 == NULL) SWIG_fail;
4892 temp2 = true;
4893 }
4894 {
4895 PyThreadState* __tstate = wxPyBeginAllowThreads();
4896 {
4897 wxPropX const &_result_ref = ((wxActiveXWindow const *)arg1)->GetAXPropDesc((wxString const &)*arg2);
4898 result = (wxPropX *) &_result_ref;
4899 }
4900 wxPyEndAllowThreads(__tstate);
4901 if (PyErr_Occurred()) SWIG_fail;
4902 }
4903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropX, 0 | 0 );
4904 {
4905 if (temp2)
4906 delete arg2;
4907 }
4908 return resultobj;
4909 fail:
4910 {
4911 if (temp2)
4912 delete arg2;
4913 }
4914 return NULL;
4915 }
4916
4917
4918 SWIGINTERN PyObject *_wrap_ActiveXWindow_GetAXPropDesc(PyObject *self, PyObject *args) {
4919 int argc;
4920 PyObject *argv[3];
4921
4922 if (!(argc = SWIG_Python_UnpackTuple(args,"ActiveXWindow_GetAXPropDesc",0,2,argv))) SWIG_fail;
4923 --argc;
4924 if (argc == 2) {
4925 int _v = 0;
4926 {
4927 {
4928 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
4929 }
4930 }
4931 if (!_v) goto check_1;
4932 return _wrap_ActiveXWindow_GetAXPropDesc__SWIG_1(self, argc, argv);
4933 }
4934 check_1:
4935
4936 if (argc == 2) {
4937 return _wrap_ActiveXWindow_GetAXPropDesc__SWIG_0(self, argc, argv);
4938 }
4939
4940 fail:
4941 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'ActiveXWindow_GetAXPropDesc'");
4942 return NULL;
4943 }
4944
4945
4946 SWIGINTERN PyObject *_wrap_ActiveXWindow_GetAXMethodCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4947 PyObject *resultobj = 0;
4948 wxActiveXWindow *arg1 = (wxActiveXWindow *) 0 ;
4949 int result;
4950 void *argp1 = 0 ;
4951 int res1 = 0 ;
4952 PyObject *swig_obj[1] ;
4953
4954 if (!args) SWIG_fail;
4955 swig_obj[0] = args;
4956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActiveXWindow, 0 | 0 );
4957 if (!SWIG_IsOK(res1)) {
4958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXWindow_GetAXMethodCount" "', expected argument " "1"" of type '" "wxActiveXWindow const *""'");
4959 }
4960 arg1 = reinterpret_cast< wxActiveXWindow * >(argp1);
4961 {
4962 PyThreadState* __tstate = wxPyBeginAllowThreads();
4963 result = (int)((wxActiveXWindow const *)arg1)->GetAXMethodCount();
4964 wxPyEndAllowThreads(__tstate);
4965 if (PyErr_Occurred()) SWIG_fail;
4966 }
4967 resultobj = SWIG_From_int(static_cast< int >(result));
4968 return resultobj;
4969 fail:
4970 return NULL;
4971 }
4972
4973
4974 SWIGINTERN PyObject *_wrap_ActiveXWindow_GetAXMethodDesc__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4975 PyObject *resultobj = 0;
4976 wxActiveXWindow *arg1 = (wxActiveXWindow *) 0 ;
4977 int arg2 ;
4978 wxFuncX *result = 0 ;
4979 void *argp1 = 0 ;
4980 int res1 = 0 ;
4981 int val2 ;
4982 int ecode2 = 0 ;
4983
4984 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
4985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActiveXWindow, 0 | 0 );
4986 if (!SWIG_IsOK(res1)) {
4987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXWindow_GetAXMethodDesc" "', expected argument " "1"" of type '" "wxActiveXWindow const *""'");
4988 }
4989 arg1 = reinterpret_cast< wxActiveXWindow * >(argp1);
4990 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4991 if (!SWIG_IsOK(ecode2)) {
4992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActiveXWindow_GetAXMethodDesc" "', expected argument " "2"" of type '" "int""'");
4993 }
4994 arg2 = static_cast< int >(val2);
4995 {
4996 PyThreadState* __tstate = wxPyBeginAllowThreads();
4997 {
4998 wxFuncX const &_result_ref = ((wxActiveXWindow const *)arg1)->GetAXMethodDesc(arg2);
4999 result = (wxFuncX *) &_result_ref;
5000 }
5001 wxPyEndAllowThreads(__tstate);
5002 if (PyErr_Occurred()) SWIG_fail;
5003 }
5004 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFuncX, 0 | 0 );
5005 return resultobj;
5006 fail:
5007 return NULL;
5008 }
5009
5010
5011 SWIGINTERN PyObject *_wrap_ActiveXWindow_GetAXMethodDesc__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
5012 PyObject *resultobj = 0;
5013 wxActiveXWindow *arg1 = (wxActiveXWindow *) 0 ;
5014 wxString *arg2 = 0 ;
5015 wxFuncX *result = 0 ;
5016 void *argp1 = 0 ;
5017 int res1 = 0 ;
5018 bool temp2 = false ;
5019
5020 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
5021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActiveXWindow, 0 | 0 );
5022 if (!SWIG_IsOK(res1)) {
5023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXWindow_GetAXMethodDesc" "', expected argument " "1"" of type '" "wxActiveXWindow const *""'");
5024 }
5025 arg1 = reinterpret_cast< wxActiveXWindow * >(argp1);
5026 {
5027 arg2 = wxString_in_helper(swig_obj[1]);
5028 if (arg2 == NULL) SWIG_fail;
5029 temp2 = true;
5030 }
5031 {
5032 PyThreadState* __tstate = wxPyBeginAllowThreads();
5033 {
5034 wxFuncX const &_result_ref = ((wxActiveXWindow const *)arg1)->GetAXMethodDesc((wxString const &)*arg2);
5035 result = (wxFuncX *) &_result_ref;
5036 }
5037 wxPyEndAllowThreads(__tstate);
5038 if (PyErr_Occurred()) SWIG_fail;
5039 }
5040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFuncX, 0 | 0 );
5041 {
5042 if (temp2)
5043 delete arg2;
5044 }
5045 return resultobj;
5046 fail:
5047 {
5048 if (temp2)
5049 delete arg2;
5050 }
5051 return NULL;
5052 }
5053
5054
5055 SWIGINTERN PyObject *_wrap_ActiveXWindow_GetAXMethodDesc(PyObject *self, PyObject *args) {
5056 int argc;
5057 PyObject *argv[3];
5058
5059 if (!(argc = SWIG_Python_UnpackTuple(args,"ActiveXWindow_GetAXMethodDesc",0,2,argv))) SWIG_fail;
5060 --argc;
5061 if (argc == 2) {
5062 int _v = 0;
5063 {
5064 {
5065 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
5066 }
5067 }
5068 if (!_v) goto check_1;
5069 return _wrap_ActiveXWindow_GetAXMethodDesc__SWIG_1(self, argc, argv);
5070 }
5071 check_1:
5072
5073 if (argc == 2) {
5074 return _wrap_ActiveXWindow_GetAXMethodDesc__SWIG_0(self, argc, argv);
5075 }
5076
5077 fail:
5078 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'ActiveXWindow_GetAXMethodDesc'");
5079 return NULL;
5080 }
5081
5082
5083 SWIGINTERN PyObject *_wrap_ActiveXWindow_GetAXEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5084 PyObject *resultobj = 0;
5085 wxActiveXWindow *arg1 = (wxActiveXWindow *) 0 ;
5086 wxFuncXArray *result = 0 ;
5087 void *argp1 = 0 ;
5088 int res1 = 0 ;
5089 PyObject *swig_obj[1] ;
5090
5091 if (!args) SWIG_fail;
5092 swig_obj[0] = args;
5093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActiveXWindow, 0 | 0 );
5094 if (!SWIG_IsOK(res1)) {
5095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXWindow_GetAXEvents" "', expected argument " "1"" of type '" "wxActiveXWindow *""'");
5096 }
5097 arg1 = reinterpret_cast< wxActiveXWindow * >(argp1);
5098 {
5099 PyThreadState* __tstate = wxPyBeginAllowThreads();
5100 {
5101 wxFuncXArray const &_result_ref = (arg1)->GetAXEvents();
5102 result = (wxFuncXArray *) &_result_ref;
5103 }
5104 wxPyEndAllowThreads(__tstate);
5105 if (PyErr_Occurred()) SWIG_fail;
5106 }
5107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFuncXArray, 0 | 0 );
5108 return resultobj;
5109 fail:
5110 return NULL;
5111 }
5112
5113
5114 SWIGINTERN PyObject *_wrap_ActiveXWindow_GetAXMethods(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5115 PyObject *resultobj = 0;
5116 wxActiveXWindow *arg1 = (wxActiveXWindow *) 0 ;
5117 wxFuncXArray *result = 0 ;
5118 void *argp1 = 0 ;
5119 int res1 = 0 ;
5120 PyObject *swig_obj[1] ;
5121
5122 if (!args) SWIG_fail;
5123 swig_obj[0] = args;
5124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActiveXWindow, 0 | 0 );
5125 if (!SWIG_IsOK(res1)) {
5126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXWindow_GetAXMethods" "', expected argument " "1"" of type '" "wxActiveXWindow *""'");
5127 }
5128 arg1 = reinterpret_cast< wxActiveXWindow * >(argp1);
5129 {
5130 PyThreadState* __tstate = wxPyBeginAllowThreads();
5131 {
5132 wxFuncXArray const &_result_ref = (arg1)->GetAXMethods();
5133 result = (wxFuncXArray *) &_result_ref;
5134 }
5135 wxPyEndAllowThreads(__tstate);
5136 if (PyErr_Occurred()) SWIG_fail;
5137 }
5138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFuncXArray, 0 | 0 );
5139 return resultobj;
5140 fail:
5141 return NULL;
5142 }
5143
5144
5145 SWIGINTERN PyObject *_wrap_ActiveXWindow_GetAXProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5146 PyObject *resultobj = 0;
5147 wxActiveXWindow *arg1 = (wxActiveXWindow *) 0 ;
5148 wxPropXArray *result = 0 ;
5149 void *argp1 = 0 ;
5150 int res1 = 0 ;
5151 PyObject *swig_obj[1] ;
5152
5153 if (!args) SWIG_fail;
5154 swig_obj[0] = args;
5155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActiveXWindow, 0 | 0 );
5156 if (!SWIG_IsOK(res1)) {
5157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXWindow_GetAXProperties" "', expected argument " "1"" of type '" "wxActiveXWindow *""'");
5158 }
5159 arg1 = reinterpret_cast< wxActiveXWindow * >(argp1);
5160 {
5161 PyThreadState* __tstate = wxPyBeginAllowThreads();
5162 {
5163 wxPropXArray const &_result_ref = (arg1)->GetAXProperties();
5164 result = (wxPropXArray *) &_result_ref;
5165 }
5166 wxPyEndAllowThreads(__tstate);
5167 if (PyErr_Occurred()) SWIG_fail;
5168 }
5169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropXArray, 0 | 0 );
5170 return resultobj;
5171 fail:
5172 return NULL;
5173 }
5174
5175
5176 SWIGINTERN PyObject *_wrap_ActiveXWindow_SetAXProp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5177 PyObject *resultobj = 0;
5178 wxActiveXWindow *arg1 = (wxActiveXWindow *) 0 ;
5179 wxString *arg2 = 0 ;
5180 PyObject *arg3 = (PyObject *) 0 ;
5181 void *argp1 = 0 ;
5182 int res1 = 0 ;
5183 bool temp2 = false ;
5184 PyObject * obj0 = 0 ;
5185 PyObject * obj1 = 0 ;
5186 PyObject * obj2 = 0 ;
5187 char * kwnames[] = {
5188 (char *) "self",(char *) "name",(char *) "value", NULL
5189 };
5190
5191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ActiveXWindow_SetAXProp",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxActiveXWindow, 0 | 0 );
5193 if (!SWIG_IsOK(res1)) {
5194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXWindow_SetAXProp" "', expected argument " "1"" of type '" "wxActiveXWindow *""'");
5195 }
5196 arg1 = reinterpret_cast< wxActiveXWindow * >(argp1);
5197 {
5198 arg2 = wxString_in_helper(obj1);
5199 if (arg2 == NULL) SWIG_fail;
5200 temp2 = true;
5201 }
5202 arg3 = obj2;
5203 {
5204 PyThreadState* __tstate = wxPyBeginAllowThreads();
5205 (arg1)->SetAXProp((wxString const &)*arg2,arg3);
5206 wxPyEndAllowThreads(__tstate);
5207 if (PyErr_Occurred()) SWIG_fail;
5208 }
5209 resultobj = SWIG_Py_Void();
5210 {
5211 if (temp2)
5212 delete arg2;
5213 }
5214 return resultobj;
5215 fail:
5216 {
5217 if (temp2)
5218 delete arg2;
5219 }
5220 return NULL;
5221 }
5222
5223
5224 SWIGINTERN PyObject *_wrap_ActiveXWindow_GetAXProp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5225 PyObject *resultobj = 0;
5226 wxActiveXWindow *arg1 = (wxActiveXWindow *) 0 ;
5227 wxString *arg2 = 0 ;
5228 PyObject *result = 0 ;
5229 void *argp1 = 0 ;
5230 int res1 = 0 ;
5231 bool temp2 = false ;
5232 PyObject * obj0 = 0 ;
5233 PyObject * obj1 = 0 ;
5234 char * kwnames[] = {
5235 (char *) "self",(char *) "name", NULL
5236 };
5237
5238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ActiveXWindow_GetAXProp",kwnames,&obj0,&obj1)) SWIG_fail;
5239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxActiveXWindow, 0 | 0 );
5240 if (!SWIG_IsOK(res1)) {
5241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXWindow_GetAXProp" "', expected argument " "1"" of type '" "wxActiveXWindow *""'");
5242 }
5243 arg1 = reinterpret_cast< wxActiveXWindow * >(argp1);
5244 {
5245 arg2 = wxString_in_helper(obj1);
5246 if (arg2 == NULL) SWIG_fail;
5247 temp2 = true;
5248 }
5249 {
5250 PyThreadState* __tstate = wxPyBeginAllowThreads();
5251 result = (PyObject *)(arg1)->GetAXProp((wxString const &)*arg2);
5252 wxPyEndAllowThreads(__tstate);
5253 if (PyErr_Occurred()) SWIG_fail;
5254 }
5255 resultobj = result;
5256 {
5257 if (temp2)
5258 delete arg2;
5259 }
5260 return resultobj;
5261 fail:
5262 {
5263 if (temp2)
5264 delete arg2;
5265 }
5266 return NULL;
5267 }
5268
5269
5270 SWIGINTERN PyObject *_wrap_ActiveXWindow__CallAXMethod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5271 PyObject *resultobj = 0;
5272 wxActiveXWindow *arg1 = (wxActiveXWindow *) 0 ;
5273 wxString *arg2 = 0 ;
5274 PyObject *arg3 = (PyObject *) 0 ;
5275 PyObject *result = 0 ;
5276 void *argp1 = 0 ;
5277 int res1 = 0 ;
5278 bool temp2 = false ;
5279 PyObject *swig_obj[3] ;
5280
5281 if (!SWIG_Python_UnpackTuple(args,"ActiveXWindow__CallAXMethod",3,3,swig_obj)) SWIG_fail;
5282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActiveXWindow, 0 | 0 );
5283 if (!SWIG_IsOK(res1)) {
5284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXWindow__CallAXMethod" "', expected argument " "1"" of type '" "wxActiveXWindow *""'");
5285 }
5286 arg1 = reinterpret_cast< wxActiveXWindow * >(argp1);
5287 {
5288 arg2 = wxString_in_helper(swig_obj[1]);
5289 if (arg2 == NULL) SWIG_fail;
5290 temp2 = true;
5291 }
5292 arg3 = swig_obj[2];
5293 {
5294 PyThreadState* __tstate = wxPyBeginAllowThreads();
5295 result = (PyObject *)(arg1)->_CallAXMethod((wxString const &)*arg2,arg3);
5296 wxPyEndAllowThreads(__tstate);
5297 if (PyErr_Occurred()) SWIG_fail;
5298 }
5299 resultobj = result;
5300 {
5301 if (temp2)
5302 delete arg2;
5303 }
5304 return resultobj;
5305 fail:
5306 {
5307 if (temp2)
5308 delete arg2;
5309 }
5310 return NULL;
5311 }
5312
5313
5314 SWIGINTERN PyObject *ActiveXWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5315 PyObject *obj;
5316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5317 SWIG_TypeNewClientData(SWIGTYPE_p_wxActiveXWindow, SWIG_NewClientData(obj));
5318 return SWIG_Py_Void();
5319 }
5320
5321 SWIGINTERN PyObject *ActiveXWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5322 return SWIG_Python_InitShadowInstance(args);
5323 }
5324
5325 SWIGINTERN PyObject *_wrap_RegisterActiveXEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5326 PyObject *resultobj = 0;
5327 wxString *arg1 = 0 ;
5328 wxEventType result;
5329 bool temp1 = false ;
5330 PyObject * obj0 = 0 ;
5331 char * kwnames[] = {
5332 (char *) "eventName", NULL
5333 };
5334
5335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterActiveXEvent",kwnames,&obj0)) SWIG_fail;
5336 {
5337 arg1 = wxString_in_helper(obj0);
5338 if (arg1 == NULL) SWIG_fail;
5339 temp1 = true;
5340 }
5341 {
5342 PyThreadState* __tstate = wxPyBeginAllowThreads();
5343 result = (wxEventType)RegisterActiveXEvent((wxString const &)*arg1);
5344 wxPyEndAllowThreads(__tstate);
5345 if (PyErr_Occurred()) SWIG_fail;
5346 }
5347 resultobj = SWIG_From_int(static_cast< int >(result));
5348 {
5349 if (temp1)
5350 delete arg1;
5351 }
5352 return resultobj;
5353 fail:
5354 {
5355 if (temp1)
5356 delete arg1;
5357 }
5358 return NULL;
5359 }
5360
5361
5362 SWIGINTERN PyObject *_wrap_ActiveXEvent_EventName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5363 PyObject *resultobj = 0;
5364 wxActiveXEvent *arg1 = (wxActiveXEvent *) 0 ;
5365 wxString result;
5366 void *argp1 = 0 ;
5367 int res1 = 0 ;
5368 PyObject *swig_obj[1] ;
5369
5370 if (!args) SWIG_fail;
5371 swig_obj[0] = args;
5372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActiveXEvent, 0 | 0 );
5373 if (!SWIG_IsOK(res1)) {
5374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXEvent_EventName" "', expected argument " "1"" of type '" "wxActiveXEvent *""'");
5375 }
5376 arg1 = reinterpret_cast< wxActiveXEvent * >(argp1);
5377 {
5378 PyThreadState* __tstate = wxPyBeginAllowThreads();
5379 result = (arg1)->EventName();
5380 wxPyEndAllowThreads(__tstate);
5381 if (PyErr_Occurred()) SWIG_fail;
5382 }
5383 {
5384 #if wxUSE_UNICODE
5385 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5386 #else
5387 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5388 #endif
5389 }
5390 return resultobj;
5391 fail:
5392 return NULL;
5393 }
5394
5395
5396 SWIGINTERN PyObject *_wrap_ActiveXEvent__preCallInit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5397 PyObject *resultobj = 0;
5398 wxActiveXEvent *arg1 = (wxActiveXEvent *) 0 ;
5399 PyObject *arg2 = (PyObject *) 0 ;
5400 void *argp1 = 0 ;
5401 int res1 = 0 ;
5402 PyObject * obj0 = 0 ;
5403 PyObject * obj1 = 0 ;
5404 char * kwnames[] = {
5405 (char *) "self",(char *) "pyself", NULL
5406 };
5407
5408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ActiveXEvent__preCallInit",kwnames,&obj0,&obj1)) SWIG_fail;
5409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxActiveXEvent, 0 | 0 );
5410 if (!SWIG_IsOK(res1)) {
5411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXEvent__preCallInit" "', expected argument " "1"" of type '" "wxActiveXEvent *""'");
5412 }
5413 arg1 = reinterpret_cast< wxActiveXEvent * >(argp1);
5414 arg2 = obj1;
5415 {
5416 PyThreadState* __tstate = wxPyBeginAllowThreads();
5417 wxActiveXEvent__preCallInit(arg1,arg2);
5418 wxPyEndAllowThreads(__tstate);
5419 if (PyErr_Occurred()) SWIG_fail;
5420 }
5421 resultobj = SWIG_Py_Void();
5422 return resultobj;
5423 fail:
5424 return NULL;
5425 }
5426
5427
5428 SWIGINTERN PyObject *_wrap_ActiveXEvent__postCallCleanup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5429 PyObject *resultobj = 0;
5430 wxActiveXEvent *arg1 = (wxActiveXEvent *) 0 ;
5431 PyObject *arg2 = (PyObject *) 0 ;
5432 void *argp1 = 0 ;
5433 int res1 = 0 ;
5434 PyObject * obj0 = 0 ;
5435 PyObject * obj1 = 0 ;
5436 char * kwnames[] = {
5437 (char *) "self",(char *) "pyself", NULL
5438 };
5439
5440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ActiveXEvent__postCallCleanup",kwnames,&obj0,&obj1)) SWIG_fail;
5441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxActiveXEvent, 0 | 0 );
5442 if (!SWIG_IsOK(res1)) {
5443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveXEvent__postCallCleanup" "', expected argument " "1"" of type '" "wxActiveXEvent *""'");
5444 }
5445 arg1 = reinterpret_cast< wxActiveXEvent * >(argp1);
5446 arg2 = obj1;
5447 {
5448 PyThreadState* __tstate = wxPyBeginAllowThreads();
5449 wxActiveXEvent__postCallCleanup(arg1,arg2);
5450 wxPyEndAllowThreads(__tstate);
5451 if (PyErr_Occurred()) SWIG_fail;
5452 }
5453 resultobj = SWIG_Py_Void();
5454 return resultobj;
5455 fail:
5456 return NULL;
5457 }
5458
5459
5460 SWIGINTERN PyObject *ActiveXEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5461 PyObject *obj;
5462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5463 SWIG_TypeNewClientData(SWIGTYPE_p_wxActiveXEvent, SWIG_NewClientData(obj));
5464 return SWIG_Py_Void();
5465 }
5466
5467 SWIGINTERN PyObject *_wrap_new_IEHtmlWindowBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5468 PyObject *resultobj = 0;
5469 wxWindow *arg1 = (wxWindow *) 0 ;
5470 CLSID *arg2 = 0 ;
5471 int arg3 = (int) -1 ;
5472 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5473 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5474 wxSize const &arg5_defvalue = wxDefaultSize ;
5475 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
5476 long arg6 = (long) 0 ;
5477 wxString const &arg7_defvalue = wxPyPanelNameStr ;
5478 wxString *arg7 = (wxString *) &arg7_defvalue ;
5479 wxIEHtmlWindowBase *result = 0 ;
5480 void *argp1 = 0 ;
5481 int res1 = 0 ;
5482 void *argp2 = 0 ;
5483 int res2 = 0 ;
5484 int val3 ;
5485 int ecode3 = 0 ;
5486 wxPoint temp4 ;
5487 wxSize temp5 ;
5488 long val6 ;
5489 int ecode6 = 0 ;
5490 bool temp7 = false ;
5491 PyObject * obj0 = 0 ;
5492 PyObject * obj1 = 0 ;
5493 PyObject * obj2 = 0 ;
5494 PyObject * obj3 = 0 ;
5495 PyObject * obj4 = 0 ;
5496 PyObject * obj5 = 0 ;
5497 PyObject * obj6 = 0 ;
5498 char * kwnames[] = {
5499 (char *) "parent",(char *) "clsId",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
5500 };
5501
5502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:new_IEHtmlWindowBase",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
5504 if (!SWIG_IsOK(res1)) {
5505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IEHtmlWindowBase" "', expected argument " "1"" of type '" "wxWindow *""'");
5506 }
5507 arg1 = reinterpret_cast< wxWindow * >(argp1);
5508 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_CLSID, 0 | 0);
5509 if (!SWIG_IsOK(res2)) {
5510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_IEHtmlWindowBase" "', expected argument " "2"" of type '" "CLSID const &""'");
5511 }
5512 if (!argp2) {
5513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IEHtmlWindowBase" "', expected argument " "2"" of type '" "CLSID const &""'");
5514 }
5515 arg2 = reinterpret_cast< CLSID * >(argp2);
5516 if (obj2) {
5517 ecode3 = SWIG_AsVal_int(obj2, &val3);
5518 if (!SWIG_IsOK(ecode3)) {
5519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_IEHtmlWindowBase" "', expected argument " "3"" of type '" "int""'");
5520 }
5521 arg3 = static_cast< int >(val3);
5522 }
5523 if (obj3) {
5524 {
5525 arg4 = &temp4;
5526 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5527 }
5528 }
5529 if (obj4) {
5530 {
5531 arg5 = &temp5;
5532 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
5533 }
5534 }
5535 if (obj5) {
5536 ecode6 = SWIG_AsVal_long(obj5, &val6);
5537 if (!SWIG_IsOK(ecode6)) {
5538 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_IEHtmlWindowBase" "', expected argument " "6"" of type '" "long""'");
5539 }
5540 arg6 = static_cast< long >(val6);
5541 }
5542 if (obj6) {
5543 {
5544 arg7 = wxString_in_helper(obj6);
5545 if (arg7 == NULL) SWIG_fail;
5546 temp7 = true;
5547 }
5548 }
5549 {
5550 if (!wxPyCheckForApp()) SWIG_fail;
5551 PyThreadState* __tstate = wxPyBeginAllowThreads();
5552 result = (wxIEHtmlWindowBase *)new wxIEHtmlWindowBase(arg1,(CLSID const &)*arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
5553 wxPyEndAllowThreads(__tstate);
5554 if (PyErr_Occurred()) SWIG_fail;
5555 }
5556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIEHtmlWindowBase, SWIG_POINTER_NEW | 0 );
5557 {
5558 if (temp7)
5559 delete arg7;
5560 }
5561 return resultobj;
5562 fail:
5563 {
5564 if (temp7)
5565 delete arg7;
5566 }
5567 return NULL;
5568 }
5569
5570
5571 SWIGINTERN PyObject *_wrap_IEHtmlWindowBase_SetCharset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5572 PyObject *resultobj = 0;
5573 wxIEHtmlWindowBase *arg1 = (wxIEHtmlWindowBase *) 0 ;
5574 wxString *arg2 = 0 ;
5575 void *argp1 = 0 ;
5576 int res1 = 0 ;
5577 bool temp2 = false ;
5578 PyObject * obj0 = 0 ;
5579 PyObject * obj1 = 0 ;
5580 char * kwnames[] = {
5581 (char *) "self",(char *) "charset", NULL
5582 };
5583
5584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IEHtmlWindowBase_SetCharset",kwnames,&obj0,&obj1)) SWIG_fail;
5585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIEHtmlWindowBase, 0 | 0 );
5586 if (!SWIG_IsOK(res1)) {
5587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IEHtmlWindowBase_SetCharset" "', expected argument " "1"" of type '" "wxIEHtmlWindowBase *""'");
5588 }
5589 arg1 = reinterpret_cast< wxIEHtmlWindowBase * >(argp1);
5590 {
5591 arg2 = wxString_in_helper(obj1);
5592 if (arg2 == NULL) SWIG_fail;
5593 temp2 = true;
5594 }
5595 {
5596 PyThreadState* __tstate = wxPyBeginAllowThreads();
5597 (arg1)->SetCharset((wxString const &)*arg2);
5598 wxPyEndAllowThreads(__tstate);
5599 if (PyErr_Occurred()) SWIG_fail;
5600 }
5601 resultobj = SWIG_Py_Void();
5602 {
5603 if (temp2)
5604 delete arg2;
5605 }
5606 return resultobj;
5607 fail:
5608 {
5609 if (temp2)
5610 delete arg2;
5611 }
5612 return NULL;
5613 }
5614
5615
5616 SWIGINTERN PyObject *_wrap_IEHtmlWindowBase_LoadString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5617 PyObject *resultobj = 0;
5618 wxIEHtmlWindowBase *arg1 = (wxIEHtmlWindowBase *) 0 ;
5619 wxString *arg2 = 0 ;
5620 bool result;
5621 void *argp1 = 0 ;
5622 int res1 = 0 ;
5623 bool temp2 = false ;
5624 PyObject * obj0 = 0 ;
5625 PyObject * obj1 = 0 ;
5626 char * kwnames[] = {
5627 (char *) "self",(char *) "html", NULL
5628 };
5629
5630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IEHtmlWindowBase_LoadString",kwnames,&obj0,&obj1)) SWIG_fail;
5631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIEHtmlWindowBase, 0 | 0 );
5632 if (!SWIG_IsOK(res1)) {
5633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IEHtmlWindowBase_LoadString" "', expected argument " "1"" of type '" "wxIEHtmlWindowBase *""'");
5634 }
5635 arg1 = reinterpret_cast< wxIEHtmlWindowBase * >(argp1);
5636 {
5637 arg2 = wxString_in_helper(obj1);
5638 if (arg2 == NULL) SWIG_fail;
5639 temp2 = true;
5640 }
5641 {
5642 PyThreadState* __tstate = wxPyBeginAllowThreads();
5643 result = (bool)(arg1)->LoadString((wxString const &)*arg2);
5644 wxPyEndAllowThreads(__tstate);
5645 if (PyErr_Occurred()) SWIG_fail;
5646 }
5647 {
5648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5649 }
5650 {
5651 if (temp2)
5652 delete arg2;
5653 }
5654 return resultobj;
5655 fail:
5656 {
5657 if (temp2)
5658 delete arg2;
5659 }
5660 return NULL;
5661 }
5662
5663
5664 SWIGINTERN PyObject *_wrap_IEHtmlWindowBase_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5665 PyObject *resultobj = 0;
5666 wxIEHtmlWindowBase *arg1 = (wxIEHtmlWindowBase *) 0 ;
5667 wxInputStream *arg2 = (wxInputStream *) 0 ;
5668 bool result;
5669 void *argp1 = 0 ;
5670 int res1 = 0 ;
5671 wxPyInputStream *temp2 ;
5672 PyObject * obj0 = 0 ;
5673 PyObject * obj1 = 0 ;
5674 char * kwnames[] = {
5675 (char *) "self",(char *) "is", NULL
5676 };
5677
5678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IEHtmlWindowBase_LoadStream",kwnames,&obj0,&obj1)) SWIG_fail;
5679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIEHtmlWindowBase, 0 | 0 );
5680 if (!SWIG_IsOK(res1)) {
5681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IEHtmlWindowBase_LoadStream" "', expected argument " "1"" of type '" "wxIEHtmlWindowBase *""'");
5682 }
5683 arg1 = reinterpret_cast< wxIEHtmlWindowBase * >(argp1);
5684 {
5685 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
5686 arg2 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp2->m_wxis);
5687 } else {
5688 PyErr_Clear(); // clear the failure of the wxPyConvert above
5689 arg2 = wxPyCBInputStream_create(obj1, true);
5690 if (arg2 == NULL) {
5691 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
5692 SWIG_fail;
5693 }
5694 }
5695 }
5696 {
5697 PyThreadState* __tstate = wxPyBeginAllowThreads();
5698 result = (bool)(arg1)->LoadStream(arg2);
5699 wxPyEndAllowThreads(__tstate);
5700 if (PyErr_Occurred()) SWIG_fail;
5701 }
5702 {
5703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5704 }
5705 return resultobj;
5706 fail:
5707 return NULL;
5708 }
5709
5710
5711 SWIGINTERN PyObject *_wrap_IEHtmlWindowBase_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5712 PyObject *resultobj = 0;
5713 wxIEHtmlWindowBase *arg1 = (wxIEHtmlWindowBase *) 0 ;
5714 bool arg2 ;
5715 wxString result;
5716 void *argp1 = 0 ;
5717 int res1 = 0 ;
5718 bool val2 ;
5719 int ecode2 = 0 ;
5720 PyObject * obj0 = 0 ;
5721 PyObject * obj1 = 0 ;
5722 char * kwnames[] = {
5723 (char *) "self",(char *) "asHTML", NULL
5724 };
5725
5726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IEHtmlWindowBase_GetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
5727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIEHtmlWindowBase, 0 | 0 );
5728 if (!SWIG_IsOK(res1)) {
5729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IEHtmlWindowBase_GetStringSelection" "', expected argument " "1"" of type '" "wxIEHtmlWindowBase *""'");
5730 }
5731 arg1 = reinterpret_cast< wxIEHtmlWindowBase * >(argp1);
5732 ecode2 = SWIG_AsVal_bool(obj1, &val2);
5733 if (!SWIG_IsOK(ecode2)) {
5734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IEHtmlWindowBase_GetStringSelection" "', expected argument " "2"" of type '" "bool""'");
5735 }
5736 arg2 = static_cast< bool >(val2);
5737 {
5738 PyThreadState* __tstate = wxPyBeginAllowThreads();
5739 result = (arg1)->GetStringSelection(arg2);
5740 wxPyEndAllowThreads(__tstate);
5741 if (PyErr_Occurred()) SWIG_fail;
5742 }
5743 {
5744 #if wxUSE_UNICODE
5745 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5746 #else
5747 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5748 #endif
5749 }
5750 return resultobj;
5751 fail:
5752 return NULL;
5753 }
5754
5755
5756 SWIGINTERN PyObject *_wrap_IEHtmlWindowBase_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5757 PyObject *resultobj = 0;
5758 wxIEHtmlWindowBase *arg1 = (wxIEHtmlWindowBase *) 0 ;
5759 bool arg2 ;
5760 wxString result;
5761 void *argp1 = 0 ;
5762 int res1 = 0 ;
5763 bool val2 ;
5764 int ecode2 = 0 ;
5765 PyObject * obj0 = 0 ;
5766 PyObject * obj1 = 0 ;
5767 char * kwnames[] = {
5768 (char *) "self",(char *) "asHTML", NULL
5769 };
5770
5771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IEHtmlWindowBase_GetText",kwnames,&obj0,&obj1)) SWIG_fail;
5772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIEHtmlWindowBase, 0 | 0 );
5773 if (!SWIG_IsOK(res1)) {
5774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IEHtmlWindowBase_GetText" "', expected argument " "1"" of type '" "wxIEHtmlWindowBase *""'");
5775 }
5776 arg1 = reinterpret_cast< wxIEHtmlWindowBase * >(argp1);
5777 ecode2 = SWIG_AsVal_bool(obj1, &val2);
5778 if (!SWIG_IsOK(ecode2)) {
5779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IEHtmlWindowBase_GetText" "', expected argument " "2"" of type '" "bool""'");
5780 }
5781 arg2 = static_cast< bool >(val2);
5782 {
5783 PyThreadState* __tstate = wxPyBeginAllowThreads();
5784 result = (arg1)->GetText(arg2);
5785 wxPyEndAllowThreads(__tstate);
5786 if (PyErr_Occurred()) SWIG_fail;
5787 }
5788 {
5789 #if wxUSE_UNICODE
5790 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5791 #else
5792 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5793 #endif
5794 }
5795 return resultobj;
5796 fail:
5797 return NULL;
5798 }
5799
5800
5801 SWIGINTERN PyObject *IEHtmlWindowBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5802 PyObject *obj;
5803 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5804 SWIG_TypeNewClientData(SWIGTYPE_p_wxIEHtmlWindowBase, SWIG_NewClientData(obj));
5805 return SWIG_Py_Void();
5806 }
5807
5808 SWIGINTERN PyObject *IEHtmlWindowBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5809 return SWIG_Python_InitShadowInstance(args);
5810 }
5811
5812 static PyMethodDef SwigMethods[] = {
5813 { (char *)"new_CLSID", (PyCFunction) _wrap_new_CLSID, METH_VARARGS | METH_KEYWORDS, NULL},
5814 { (char *)"delete_CLSID", (PyCFunction)_wrap_delete_CLSID, METH_O, NULL},
5815 { (char *)"CLSID_GetCLSIDString", (PyCFunction)_wrap_CLSID_GetCLSIDString, METH_O, NULL},
5816 { (char *)"CLSID_GetProgIDString", (PyCFunction)_wrap_CLSID_GetProgIDString, METH_O, NULL},
5817 { (char *)"CLSID_swigregister", CLSID_swigregister, METH_VARARGS, NULL},
5818 { (char *)"CLSID_swiginit", CLSID_swiginit, METH_VARARGS, NULL},
5819 { (char *)"ParamX_flags_get", (PyCFunction)_wrap_ParamX_flags_get, METH_O, NULL},
5820 { (char *)"ParamX_isPtr_get", (PyCFunction)_wrap_ParamX_isPtr_get, METH_O, NULL},
5821 { (char *)"ParamX_isSafeArray_get", (PyCFunction)_wrap_ParamX_isSafeArray_get, METH_O, NULL},
5822 { (char *)"ParamX_isOptional_get", (PyCFunction)_wrap_ParamX_isOptional_get, METH_O, NULL},
5823 { (char *)"ParamX_vt_get", (PyCFunction)_wrap_ParamX_vt_get, METH_O, NULL},
5824 { (char *)"ParamX_name_get", (PyCFunction)_wrap_ParamX_name_get, METH_O, NULL},
5825 { (char *)"ParamX_vt_type_get", (PyCFunction)_wrap_ParamX_vt_type_get, METH_O, NULL},
5826 { (char *)"ParamX_IsIn", (PyCFunction)_wrap_ParamX_IsIn, METH_O, NULL},
5827 { (char *)"ParamX_IsOut", (PyCFunction)_wrap_ParamX_IsOut, METH_O, NULL},
5828 { (char *)"ParamX_IsRetVal", (PyCFunction)_wrap_ParamX_IsRetVal, METH_O, NULL},
5829 { (char *)"ParamX_swigregister", ParamX_swigregister, METH_VARARGS, NULL},
5830 { (char *)"FuncX_name_get", (PyCFunction)_wrap_FuncX_name_get, METH_O, NULL},
5831 { (char *)"FuncX_memid_get", (PyCFunction)_wrap_FuncX_memid_get, METH_O, NULL},
5832 { (char *)"FuncX_hasOut_get", (PyCFunction)_wrap_FuncX_hasOut_get, METH_O, NULL},
5833 { (char *)"FuncX_retType_get", (PyCFunction)_wrap_FuncX_retType_get, METH_O, NULL},
5834 { (char *)"FuncX_params_get", (PyCFunction)_wrap_FuncX_params_get, METH_O, NULL},
5835 { (char *)"FuncX_swigregister", FuncX_swigregister, METH_VARARGS, NULL},
5836 { (char *)"PropX_name_get", (PyCFunction)_wrap_PropX_name_get, METH_O, NULL},
5837 { (char *)"PropX_memid_get", (PyCFunction)_wrap_PropX_memid_get, METH_O, NULL},
5838 { (char *)"PropX_type_get", (PyCFunction)_wrap_PropX_type_get, METH_O, NULL},
5839 { (char *)"PropX_arg_get", (PyCFunction)_wrap_PropX_arg_get, METH_O, NULL},
5840 { (char *)"PropX_putByRef_get", (PyCFunction)_wrap_PropX_putByRef_get, METH_O, NULL},
5841 { (char *)"PropX_CanGet", (PyCFunction)_wrap_PropX_CanGet, METH_O, NULL},
5842 { (char *)"PropX_CanSet", (PyCFunction)_wrap_PropX_CanSet, METH_O, NULL},
5843 { (char *)"PropX_swigregister", PropX_swigregister, METH_VARARGS, NULL},
5844 { (char *)"ParamXArray___nonzero__", (PyCFunction)_wrap_ParamXArray___nonzero__, METH_O, NULL},
5845 { (char *)"ParamXArray___len__", (PyCFunction)_wrap_ParamXArray___len__, METH_O, NULL},
5846 { (char *)"ParamXArray___getitem__", (PyCFunction) _wrap_ParamXArray___getitem__, METH_VARARGS | METH_KEYWORDS, NULL},
5847 { (char *)"ParamXArray_swigregister", ParamXArray_swigregister, METH_VARARGS, NULL},
5848 { (char *)"FuncXArray___nonzero__", (PyCFunction)_wrap_FuncXArray___nonzero__, METH_O, NULL},
5849 { (char *)"FuncXArray___len__", (PyCFunction)_wrap_FuncXArray___len__, METH_O, NULL},
5850 { (char *)"FuncXArray___getitem__", (PyCFunction) _wrap_FuncXArray___getitem__, METH_VARARGS | METH_KEYWORDS, NULL},
5851 { (char *)"FuncXArray_swigregister", FuncXArray_swigregister, METH_VARARGS, NULL},
5852 { (char *)"PropXArray___nonzero__", (PyCFunction)_wrap_PropXArray___nonzero__, METH_O, NULL},
5853 { (char *)"PropXArray___len__", (PyCFunction)_wrap_PropXArray___len__, METH_O, NULL},
5854 { (char *)"PropXArray___getitem__", (PyCFunction) _wrap_PropXArray___getitem__, METH_VARARGS | METH_KEYWORDS, NULL},
5855 { (char *)"PropXArray_swigregister", PropXArray_swigregister, METH_VARARGS, NULL},
5856 { (char *)"new_ActiveXWindow", (PyCFunction) _wrap_new_ActiveXWindow, METH_VARARGS | METH_KEYWORDS, NULL},
5857 { (char *)"ActiveXWindow_GetCLSID", (PyCFunction)_wrap_ActiveXWindow_GetCLSID, METH_O, NULL},
5858 { (char *)"ActiveXWindow_GetAXEventCount", (PyCFunction)_wrap_ActiveXWindow_GetAXEventCount, METH_O, NULL},
5859 { (char *)"ActiveXWindow_GetAXEventDesc", (PyCFunction) _wrap_ActiveXWindow_GetAXEventDesc, METH_VARARGS | METH_KEYWORDS, NULL},
5860 { (char *)"ActiveXWindow_GetAXPropCount", (PyCFunction)_wrap_ActiveXWindow_GetAXPropCount, METH_O, NULL},
5861 { (char *)"ActiveXWindow_GetAXPropDesc", _wrap_ActiveXWindow_GetAXPropDesc, METH_VARARGS, NULL},
5862 { (char *)"ActiveXWindow_GetAXMethodCount", (PyCFunction)_wrap_ActiveXWindow_GetAXMethodCount, METH_O, NULL},
5863 { (char *)"ActiveXWindow_GetAXMethodDesc", _wrap_ActiveXWindow_GetAXMethodDesc, METH_VARARGS, NULL},
5864 { (char *)"ActiveXWindow_GetAXEvents", (PyCFunction)_wrap_ActiveXWindow_GetAXEvents, METH_O, NULL},
5865 { (char *)"ActiveXWindow_GetAXMethods", (PyCFunction)_wrap_ActiveXWindow_GetAXMethods, METH_O, NULL},
5866 { (char *)"ActiveXWindow_GetAXProperties", (PyCFunction)_wrap_ActiveXWindow_GetAXProperties, METH_O, NULL},
5867 { (char *)"ActiveXWindow_SetAXProp", (PyCFunction) _wrap_ActiveXWindow_SetAXProp, METH_VARARGS | METH_KEYWORDS, NULL},
5868 { (char *)"ActiveXWindow_GetAXProp", (PyCFunction) _wrap_ActiveXWindow_GetAXProp, METH_VARARGS | METH_KEYWORDS, NULL},
5869 { (char *)"ActiveXWindow__CallAXMethod", _wrap_ActiveXWindow__CallAXMethod, METH_VARARGS, NULL},
5870 { (char *)"ActiveXWindow_swigregister", ActiveXWindow_swigregister, METH_VARARGS, NULL},
5871 { (char *)"ActiveXWindow_swiginit", ActiveXWindow_swiginit, METH_VARARGS, NULL},
5872 { (char *)"RegisterActiveXEvent", (PyCFunction) _wrap_RegisterActiveXEvent, METH_VARARGS | METH_KEYWORDS, NULL},
5873 { (char *)"ActiveXEvent_EventName", (PyCFunction)_wrap_ActiveXEvent_EventName, METH_O, NULL},
5874 { (char *)"ActiveXEvent__preCallInit", (PyCFunction) _wrap_ActiveXEvent__preCallInit, METH_VARARGS | METH_KEYWORDS, NULL},
5875 { (char *)"ActiveXEvent__postCallCleanup", (PyCFunction) _wrap_ActiveXEvent__postCallCleanup, METH_VARARGS | METH_KEYWORDS, NULL},
5876 { (char *)"ActiveXEvent_swigregister", ActiveXEvent_swigregister, METH_VARARGS, NULL},
5877 { (char *)"new_IEHtmlWindowBase", (PyCFunction) _wrap_new_IEHtmlWindowBase, METH_VARARGS | METH_KEYWORDS, NULL},
5878 { (char *)"IEHtmlWindowBase_SetCharset", (PyCFunction) _wrap_IEHtmlWindowBase_SetCharset, METH_VARARGS | METH_KEYWORDS, NULL},
5879 { (char *)"IEHtmlWindowBase_LoadString", (PyCFunction) _wrap_IEHtmlWindowBase_LoadString, METH_VARARGS | METH_KEYWORDS, NULL},
5880 { (char *)"IEHtmlWindowBase_LoadStream", (PyCFunction) _wrap_IEHtmlWindowBase_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
5881 { (char *)"IEHtmlWindowBase_GetStringSelection", (PyCFunction) _wrap_IEHtmlWindowBase_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
5882 { (char *)"IEHtmlWindowBase_GetText", (PyCFunction) _wrap_IEHtmlWindowBase_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
5883 { (char *)"IEHtmlWindowBase_swigregister", IEHtmlWindowBase_swigregister, METH_VARARGS, NULL},
5884 { (char *)"IEHtmlWindowBase_swiginit", IEHtmlWindowBase_swiginit, METH_VARARGS, NULL},
5885 { NULL, NULL, 0, NULL }
5886 };
5887
5888
5889 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
5890
5891 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
5892 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
5893 }
5894 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
5895 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
5896 }
5897 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
5898 return (void *)((wxObject *) ((wxSizerItem *) x));
5899 }
5900 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
5901 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
5902 }
5903 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
5904 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
5905 }
5906 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
5907 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
5908 }
5909 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
5910 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
5911 }
5912 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
5913 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
5914 }
5915 static void *_p_wxSizerTo_p_wxObject(void *x) {
5916 return (void *)((wxObject *) ((wxSizer *) x));
5917 }
5918 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
5919 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
5920 }
5921 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
5922 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
5923 }
5924 static void *_p_wxEventTo_p_wxObject(void *x) {
5925 return (void *)((wxObject *) ((wxEvent *) x));
5926 }
5927 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
5928 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
5929 }
5930 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
5931 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
5932 }
5933 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
5934 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
5935 }
5936 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
5937 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
5938 }
5939 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
5940 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
5941 }
5942 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
5943 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
5944 }
5945 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
5946 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
5947 }
5948 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
5949 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
5950 }
5951 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
5952 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
5953 }
5954 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
5955 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
5956 }
5957 static void *_p_wxControlTo_p_wxObject(void *x) {
5958 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
5959 }
5960 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
5961 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
5962 }
5963 static void *_p_wxFSFileTo_p_wxObject(void *x) {
5964 return (void *)((wxObject *) ((wxFSFile *) x));
5965 }
5966 static void *_p_wxPySizerTo_p_wxObject(void *x) {
5967 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
5968 }
5969 static void *_p_wxPyEventTo_p_wxObject(void *x) {
5970 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
5971 }
5972 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
5973 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
5974 }
5975 static void *_p_wxShowEventTo_p_wxObject(void *x) {
5976 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
5977 }
5978 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
5979 return (void *)((wxObject *) ((wxMenuItem *) x));
5980 }
5981 static void *_p_wxDateEventTo_p_wxObject(void *x) {
5982 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
5983 }
5984 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
5985 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
5986 }
5987 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
5988 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
5989 }
5990 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
5991 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
5992 }
5993 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
5994 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
5995 }
5996 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
5997 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
5998 }
5999 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
6000 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
6001 }
6002 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
6003 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
6004 }
6005 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
6006 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
6007 }
6008 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
6009 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
6010 }
6011 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
6012 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
6013 }
6014 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
6015 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
6016 }
6017 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
6018 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
6019 }
6020 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
6021 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
6022 }
6023 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
6024 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
6025 }
6026 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
6027 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
6028 }
6029 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
6030 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
6031 }
6032 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
6033 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
6034 }
6035 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
6036 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
6037 }
6038 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
6039 return (void *)((wxObject *) ((wxImageHandler *) x));
6040 }
6041 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
6042 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
6043 }
6044 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
6045 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
6046 }
6047 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
6048 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
6049 }
6050 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
6051 return (void *)((wxObject *) ((wxEvtHandler *) x));
6052 }
6053 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
6054 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
6055 }
6056 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
6057 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
6058 }
6059 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
6060 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
6061 }
6062 static void *_p_wxImageTo_p_wxObject(void *x) {
6063 return (void *)((wxObject *) ((wxImage *) x));
6064 }
6065 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
6066 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
6067 }
6068 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
6069 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
6070 }
6071 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
6072 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
6073 }
6074 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
6075 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
6076 }
6077 static void *_p_wxWindowTo_p_wxObject(void *x) {
6078 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
6079 }
6080 static void *_p_wxMenuTo_p_wxObject(void *x) {
6081 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
6082 }
6083 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
6084 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
6085 }
6086 static void *_p_wxActiveXWindowTo_p_wxObject(void *x) {
6087 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxActiveXWindow *) x));
6088 }
6089 static void *_p_wxActiveXEventTo_p_wxObject(void *x) {
6090 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxActiveXEvent *) x));
6091 }
6092 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
6093 return (void *)((wxObject *) ((wxFileSystem *) x));
6094 }
6095 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
6096 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
6097 }
6098 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
6099 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
6100 }
6101 static void *_p_wxIEHtmlWindowBaseTo_p_wxObject(void *x) {
6102 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxActiveXWindow *) ((wxIEHtmlWindowBase *) x));
6103 }
6104 static void *_p_wxPyAppTo_p_wxObject(void *x) {
6105 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
6106 }
6107 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
6108 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
6109 }
6110 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
6111 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
6112 }
6113 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
6114 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
6115 }
6116 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
6117 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
6118 }
6119 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
6120 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
6121 }
6122 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
6123 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
6124 }
6125 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
6126 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
6127 }
6128 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
6129 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
6130 }
6131 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
6132 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
6133 }
6134 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
6135 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
6136 }
6137 static void *_p_wxValidatorTo_p_wxObject(void *x) {
6138 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
6139 }
6140 static void *_p_wxIEHtmlWindowBaseTo_p_wxActiveXWindow(void *x) {
6141 return (void *)((wxActiveXWindow *) ((wxIEHtmlWindowBase *) x));
6142 }
6143 static void *_p_wxControlTo_p_wxWindow(void *x) {
6144 return (void *)((wxWindow *) ((wxControl *) x));
6145 }
6146 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
6147 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
6148 }
6149 static void *_p_wxActiveXWindowTo_p_wxWindow(void *x) {
6150 return (void *)((wxWindow *) ((wxActiveXWindow *) x));
6151 }
6152 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
6153 return (void *)((wxWindow *) ((wxMenuBar *) x));
6154 }
6155 static void *_p_wxIEHtmlWindowBaseTo_p_wxWindow(void *x) {
6156 return (void *)((wxWindow *) (wxActiveXWindow *) ((wxIEHtmlWindowBase *) x));
6157 }
6158 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
6159 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
6160 }
6161 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
6162 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
6163 }
6164 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
6165 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
6166 }
6167 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
6168 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
6169 }
6170 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
6171 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
6172 }
6173 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
6174 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
6175 }
6176 static void *_p_wxActiveXEventTo_p_wxCommandEvent(void *x) {
6177 return (void *)((wxCommandEvent *) ((wxActiveXEvent *) x));
6178 }
6179 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
6180 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
6181 }
6182 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
6183 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
6184 }
6185 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
6186 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
6187 }
6188 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
6189 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
6190 }
6191 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
6192 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
6193 }
6194 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
6195 return (void *)((wxEvtHandler *) ((wxWindow *) x));
6196 }
6197 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
6198 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
6199 }
6200 static void *_p_wxActiveXWindowTo_p_wxEvtHandler(void *x) {
6201 return (void *)((wxEvtHandler *) (wxWindow *) ((wxActiveXWindow *) x));
6202 }
6203 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
6204 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
6205 }
6206 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
6207 return (void *)((wxEvtHandler *) ((wxValidator *) x));
6208 }
6209 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
6210 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
6211 }
6212 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
6213 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
6214 }
6215 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
6216 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
6217 }
6218 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
6219 return (void *)((wxEvtHandler *) ((wxMenu *) x));
6220 }
6221 static void *_p_wxIEHtmlWindowBaseTo_p_wxEvtHandler(void *x) {
6222 return (void *)((wxEvtHandler *) (wxWindow *)(wxActiveXWindow *) ((wxIEHtmlWindowBase *) x));
6223 }
6224 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
6225 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
6226 }
6227 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
6228 return (void *)((wxEvent *) ((wxMenuEvent *) x));
6229 }
6230 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
6231 return (void *)((wxEvent *) ((wxCloseEvent *) x));
6232 }
6233 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
6234 return (void *)((wxEvent *) ((wxMouseEvent *) x));
6235 }
6236 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
6237 return (void *)((wxEvent *) ((wxEraseEvent *) x));
6238 }
6239 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
6240 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
6241 }
6242 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
6243 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
6244 }
6245 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
6246 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
6247 }
6248 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
6249 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
6250 }
6251 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
6252 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
6253 }
6254 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
6255 return (void *)((wxEvent *) ((wxPyEvent *) x));
6256 }
6257 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
6258 return (void *)((wxEvent *) ((wxIdleEvent *) x));
6259 }
6260 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
6261 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
6262 }
6263 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
6264 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
6265 }
6266 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
6267 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
6268 }
6269 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
6270 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
6271 }
6272 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
6273 return (void *)((wxEvent *) ((wxActivateEvent *) x));
6274 }
6275 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
6276 return (void *)((wxEvent *) ((wxSizeEvent *) x));
6277 }
6278 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
6279 return (void *)((wxEvent *) ((wxMoveEvent *) x));
6280 }
6281 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
6282 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
6283 }
6284 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
6285 return (void *)((wxEvent *) ((wxPaintEvent *) x));
6286 }
6287 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
6288 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
6289 }
6290 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
6291 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
6292 }
6293 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
6294 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
6295 }
6296 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
6297 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
6298 }
6299 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
6300 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
6301 }
6302 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
6303 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
6304 }
6305 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
6306 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
6307 }
6308 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
6309 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
6310 }
6311 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
6312 return (void *)((wxEvent *) ((wxFocusEvent *) x));
6313 }
6314 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
6315 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
6316 }
6317 static void *_p_wxActiveXEventTo_p_wxEvent(void *x) {
6318 return (void *)((wxEvent *) (wxCommandEvent *) ((wxActiveXEvent *) x));
6319 }
6320 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
6321 return (void *)((wxEvent *) ((wxShowEvent *) x));
6322 }
6323 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
6324 return (void *)((wxEvent *) ((wxCommandEvent *) x));
6325 }
6326 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
6327 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
6328 }
6329 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
6330 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
6331 }
6332 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
6333 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
6334 }
6335 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
6336 return (void *)((wxEvent *) ((wxKeyEvent *) x));
6337 }
6338 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
6339 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
6340 }
6341 static swig_type_info _swigt__p_CLSID = {"_p_CLSID", "CLSID *", 0, 0, (void*)0, 0};
6342 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
6343 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, (void*)0, 0};
6344 static swig_type_info _swigt__p_int = {"_p_int", "int *|wxEventType *", 0, 0, (void*)0, 0};
6345 static swig_type_info _swigt__p_long = {"_p_long", "long *|MEMBERID *", 0, 0, (void*)0, 0};
6346 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
6347 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
6348 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
6349 static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|VARTYPE *", 0, 0, (void*)0, 0};
6350 static swig_type_info _swigt__p_wxActiveXEvent = {"_p_wxActiveXEvent", "wxActiveXEvent *", 0, 0, (void*)0, 0};
6351 static swig_type_info _swigt__p_wxActiveXWindow = {"_p_wxActiveXWindow", "wxActiveXWindow *", 0, 0, (void*)0, 0};
6352 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
6353 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
6354 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
6355 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
6356 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
6357 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
6358 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
6359 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
6360 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
6361 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
6362 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
6363 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
6364 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
6365 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
6366 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
6367 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
6368 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
6369 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
6370 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
6371 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
6372 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
6373 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
6374 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
6375 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
6376 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
6377 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
6378 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
6379 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
6380 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
6381 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
6382 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
6383 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
6384 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
6385 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
6386 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
6387 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
6388 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
6389 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
6390 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
6391 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
6392 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
6393 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
6394 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
6395 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
6396 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
6397 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
6398 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
6399 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
6400 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", 0, 0, 0, 0, 0};
6401 static swig_type_info _swigt__p_wxFuncX = {"_p_wxFuncX", "wxFuncX *", 0, 0, (void*)0, 0};
6402 static swig_type_info _swigt__p_wxFuncXArray = {"_p_wxFuncXArray", "wxFuncXArray *", 0, 0, (void*)0, 0};
6403 static swig_type_info _swigt__p_wxIEHtmlWindowBase = {"_p_wxIEHtmlWindowBase", "wxIEHtmlWindowBase *", 0, 0, (void*)0, 0};
6404 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
6405 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
6406 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
6407 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
6408 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
6409 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
6410 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
6411 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
6412 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
6413 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
6414 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
6415 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
6416 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
6417 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
6418 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
6419 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
6420 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
6421 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
6422 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
6423 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
6424 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
6425 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
6426 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
6427 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
6428 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
6429 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
6430 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
6431 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
6432 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
6433 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
6434 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
6435 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
6436 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
6437 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
6438 static swig_type_info _swigt__p_wxParamX = {"_p_wxParamX", "wxParamX *", 0, 0, (void*)0, 0};
6439 static swig_type_info _swigt__p_wxParamXArray = {"_p_wxParamXArray", "wxParamXArray *", 0, 0, (void*)0, 0};
6440 static swig_type_info _swigt__p_wxPropX = {"_p_wxPropX", "wxPropX *", 0, 0, (void*)0, 0};
6441 static swig_type_info _swigt__p_wxPropXArray = {"_p_wxPropXArray", "wxPropXArray *", 0, 0, (void*)0, 0};
6442 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
6443
6444 static swig_type_info *swig_type_initial[] = {
6445 &_swigt__p_CLSID,
6446 &_swigt__p_char,
6447 &_swigt__p_form_ops_t,
6448 &_swigt__p_int,
6449 &_swigt__p_long,
6450 &_swigt__p_unsigned_char,
6451 &_swigt__p_unsigned_int,
6452 &_swigt__p_unsigned_long,
6453 &_swigt__p_unsigned_short,
6454 &_swigt__p_wxANIHandler,
6455 &_swigt__p_wxAcceleratorTable,
6456 &_swigt__p_wxActivateEvent,
6457 &_swigt__p_wxActiveXEvent,
6458 &_swigt__p_wxActiveXWindow,
6459 &_swigt__p_wxBMPHandler,
6460 &_swigt__p_wxBoxSizer,
6461 &_swigt__p_wxCURHandler,
6462 &_swigt__p_wxChildFocusEvent,
6463 &_swigt__p_wxClipboardTextEvent,
6464 &_swigt__p_wxCloseEvent,
6465 &_swigt__p_wxCommandEvent,
6466 &_swigt__p_wxContextMenuEvent,
6467 &_swigt__p_wxControl,
6468 &_swigt__p_wxControlWithItems,
6469 &_swigt__p_wxDateEvent,
6470 &_swigt__p_wxDisplayChangedEvent,
6471 &_swigt__p_wxDropFilesEvent,
6472 &_swigt__p_wxDuplexMode,
6473 &_swigt__p_wxEraseEvent,
6474 &_swigt__p_wxEvent,
6475 &_swigt__p_wxEventBlocker,
6476 &_swigt__p_wxEvtHandler,
6477 &_swigt__p_wxFSFile,
6478 &_swigt__p_wxFileSystem,
6479 &_swigt__p_wxFlexGridSizer,
6480 &_swigt__p_wxFocusEvent,
6481 &_swigt__p_wxFuncX,
6482 &_swigt__p_wxFuncXArray,
6483 &_swigt__p_wxGBSizerItem,
6484 &_swigt__p_wxGIFHandler,
6485 &_swigt__p_wxGridBagSizer,
6486 &_swigt__p_wxGridSizer,
6487 &_swigt__p_wxICOHandler,
6488 &_swigt__p_wxIEHtmlWindowBase,
6489 &_swigt__p_wxIconizeEvent,
6490 &_swigt__p_wxIdleEvent,
6491 &_swigt__p_wxImage,
6492 &_swigt__p_wxImageHandler,
6493 &_swigt__p_wxIndividualLayoutConstraint,
6494 &_swigt__p_wxInitDialogEvent,
6495 &_swigt__p_wxInputStream,
6496 &_swigt__p_wxJPEGHandler,
6497 &_swigt__p_wxKeyEvent,
6498 &_swigt__p_wxLayoutConstraints,
6499 &_swigt__p_wxMaximizeEvent,
6500 &_swigt__p_wxMenu,
6501 &_swigt__p_wxMenuBar,
6502 &_swigt__p_wxMenuEvent,
6503 &_swigt__p_wxMenuItem,
6504 &_swigt__p_wxMouseCaptureChangedEvent,
6505 &_swigt__p_wxMouseCaptureLostEvent,
6506 &_swigt__p_wxMouseEvent,
6507 &_swigt__p_wxMoveEvent,
6508 &_swigt__p_wxNavigationKeyEvent,
6509 &_swigt__p_wxNcPaintEvent,
6510 &_swigt__p_wxNotifyEvent,
6511 &_swigt__p_wxObject,
6512 &_swigt__p_wxPCXHandler,
6513 &_swigt__p_wxPNGHandler,
6514 &_swigt__p_wxPNMHandler,
6515 &_swigt__p_wxPaintEvent,
6516 &_swigt__p_wxPaletteChangedEvent,
6517 &_swigt__p_wxPaperSize,
6518 &_swigt__p_wxParamX,
6519 &_swigt__p_wxParamXArray,
6520 &_swigt__p_wxPropX,
6521 &_swigt__p_wxPropXArray,
6522 &_swigt__p_wxPyApp,
6523 &_swigt__p_wxPyCommandEvent,
6524 &_swigt__p_wxPyEvent,
6525 &_swigt__p_wxPyImageHandler,
6526 &_swigt__p_wxPySizer,
6527 &_swigt__p_wxPyValidator,
6528 &_swigt__p_wxQueryNewPaletteEvent,
6529 &_swigt__p_wxScrollEvent,
6530 &_swigt__p_wxScrollWinEvent,
6531 &_swigt__p_wxSetCursorEvent,
6532 &_swigt__p_wxShowEvent,
6533 &_swigt__p_wxSizeEvent,
6534 &_swigt__p_wxSizer,
6535 &_swigt__p_wxSizerItem,
6536 &_swigt__p_wxStaticBoxSizer,
6537 &_swigt__p_wxStdDialogButtonSizer,
6538 &_swigt__p_wxSysColourChangedEvent,
6539 &_swigt__p_wxTGAHandler,
6540 &_swigt__p_wxTIFFHandler,
6541 &_swigt__p_wxUpdateUIEvent,
6542 &_swigt__p_wxValidator,
6543 &_swigt__p_wxWindow,
6544 &_swigt__p_wxWindowCreateEvent,
6545 &_swigt__p_wxWindowDestroyEvent,
6546 &_swigt__p_wxXPMHandler,
6547 };
6548
6549 static swig_cast_info _swigc__p_CLSID[] = { {&_swigt__p_CLSID, 0, 0, 0},{0, 0, 0, 0}};
6550 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
6551 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
6552 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
6553 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
6554 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
6555 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
6556 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
6557 static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
6558 static swig_cast_info _swigc__p_wxActiveXEvent[] = { {&_swigt__p_wxActiveXEvent, 0, 0, 0},{0, 0, 0, 0}};
6559 static swig_cast_info _swigc__p_wxActiveXWindow[] = { {&_swigt__p_wxActiveXWindow, 0, 0, 0}, {&_swigt__p_wxIEHtmlWindowBase, _p_wxIEHtmlWindowBaseTo_p_wxActiveXWindow, 0, 0},{0, 0, 0, 0}};
6560 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
6561 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
6562 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
6563 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
6564 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
6565 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
6566 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
6567 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
6568 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
6569 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
6570 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxActiveXEvent, _p_wxActiveXEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
6571 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
6572 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
6573 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
6574 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
6575 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
6576 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
6577 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
6578 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
6579 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
6580 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
6581 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
6582 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
6583 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
6584 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
6585 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
6586 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
6587 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
6588 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
6589 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
6590 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
6591 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
6592 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
6593 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
6594 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
6595 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
6596 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
6597 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
6598 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
6599 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActiveXEvent, _p_wxActiveXEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
6600 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
6601 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
6602 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
6603 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
6604 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
6605 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
6606 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
6607 static swig_cast_info _swigc__p_wxEventBlocker[] = {{&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
6608 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxActiveXWindow, _p_wxActiveXWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxIEHtmlWindowBase, _p_wxIEHtmlWindowBaseTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
6609 static swig_cast_info _swigc__p_wxFuncX[] = { {&_swigt__p_wxFuncX, 0, 0, 0},{0, 0, 0, 0}};
6610 static swig_cast_info _swigc__p_wxFuncXArray[] = { {&_swigt__p_wxFuncXArray, 0, 0, 0},{0, 0, 0, 0}};
6611 static swig_cast_info _swigc__p_wxIEHtmlWindowBase[] = { {&_swigt__p_wxIEHtmlWindowBase, 0, 0, 0},{0, 0, 0, 0}};
6612 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
6613 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
6614 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
6615 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
6616 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
6617 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
6618 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
6619 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
6620 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
6621 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
6622 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
6623 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
6624 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
6625 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
6626 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
6627 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
6628 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
6629 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
6630 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
6631 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
6632 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
6633 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
6634 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
6635 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
6636 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
6637 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
6638 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
6639 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
6640 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
6641 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
6642 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
6643 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
6644 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActiveXEvent, _p_wxActiveXEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActiveXWindow, _p_wxActiveXWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIEHtmlWindowBase, _p_wxIEHtmlWindowBaseTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
6645 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
6646 static swig_cast_info _swigc__p_wxParamX[] = { {&_swigt__p_wxParamX, 0, 0, 0},{0, 0, 0, 0}};
6647 static swig_cast_info _swigc__p_wxParamXArray[] = { {&_swigt__p_wxParamXArray, 0, 0, 0},{0, 0, 0, 0}};
6648 static swig_cast_info _swigc__p_wxPropX[] = { {&_swigt__p_wxPropX, 0, 0, 0},{0, 0, 0, 0}};
6649 static swig_cast_info _swigc__p_wxPropXArray[] = { {&_swigt__p_wxPropXArray, 0, 0, 0},{0, 0, 0, 0}};
6650 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxActiveXWindow, _p_wxActiveXWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxIEHtmlWindowBase, _p_wxIEHtmlWindowBaseTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
6651
6652 static swig_cast_info *swig_cast_initial[] = {
6653 _swigc__p_CLSID,
6654 _swigc__p_char,
6655 _swigc__p_form_ops_t,
6656 _swigc__p_int,
6657 _swigc__p_long,
6658 _swigc__p_unsigned_char,
6659 _swigc__p_unsigned_int,
6660 _swigc__p_unsigned_long,
6661 _swigc__p_unsigned_short,
6662 _swigc__p_wxANIHandler,
6663 _swigc__p_wxAcceleratorTable,
6664 _swigc__p_wxActivateEvent,
6665 _swigc__p_wxActiveXEvent,
6666 _swigc__p_wxActiveXWindow,
6667 _swigc__p_wxBMPHandler,
6668 _swigc__p_wxBoxSizer,
6669 _swigc__p_wxCURHandler,
6670 _swigc__p_wxChildFocusEvent,
6671 _swigc__p_wxClipboardTextEvent,
6672 _swigc__p_wxCloseEvent,
6673 _swigc__p_wxCommandEvent,
6674 _swigc__p_wxContextMenuEvent,
6675 _swigc__p_wxControl,
6676 _swigc__p_wxControlWithItems,
6677 _swigc__p_wxDateEvent,
6678 _swigc__p_wxDisplayChangedEvent,
6679 _swigc__p_wxDropFilesEvent,
6680 _swigc__p_wxDuplexMode,
6681 _swigc__p_wxEraseEvent,
6682 _swigc__p_wxEvent,
6683 _swigc__p_wxEventBlocker,
6684 _swigc__p_wxEvtHandler,
6685 _swigc__p_wxFSFile,
6686 _swigc__p_wxFileSystem,
6687 _swigc__p_wxFlexGridSizer,
6688 _swigc__p_wxFocusEvent,
6689 _swigc__p_wxFuncX,
6690 _swigc__p_wxFuncXArray,
6691 _swigc__p_wxGBSizerItem,
6692 _swigc__p_wxGIFHandler,
6693 _swigc__p_wxGridBagSizer,
6694 _swigc__p_wxGridSizer,
6695 _swigc__p_wxICOHandler,
6696 _swigc__p_wxIEHtmlWindowBase,
6697 _swigc__p_wxIconizeEvent,
6698 _swigc__p_wxIdleEvent,
6699 _swigc__p_wxImage,
6700 _swigc__p_wxImageHandler,
6701 _swigc__p_wxIndividualLayoutConstraint,
6702 _swigc__p_wxInitDialogEvent,
6703 _swigc__p_wxInputStream,
6704 _swigc__p_wxJPEGHandler,
6705 _swigc__p_wxKeyEvent,
6706 _swigc__p_wxLayoutConstraints,
6707 _swigc__p_wxMaximizeEvent,
6708 _swigc__p_wxMenu,
6709 _swigc__p_wxMenuBar,
6710 _swigc__p_wxMenuEvent,
6711 _swigc__p_wxMenuItem,
6712 _swigc__p_wxMouseCaptureChangedEvent,
6713 _swigc__p_wxMouseCaptureLostEvent,
6714 _swigc__p_wxMouseEvent,
6715 _swigc__p_wxMoveEvent,
6716 _swigc__p_wxNavigationKeyEvent,
6717 _swigc__p_wxNcPaintEvent,
6718 _swigc__p_wxNotifyEvent,
6719 _swigc__p_wxObject,
6720 _swigc__p_wxPCXHandler,
6721 _swigc__p_wxPNGHandler,
6722 _swigc__p_wxPNMHandler,
6723 _swigc__p_wxPaintEvent,
6724 _swigc__p_wxPaletteChangedEvent,
6725 _swigc__p_wxPaperSize,
6726 _swigc__p_wxParamX,
6727 _swigc__p_wxParamXArray,
6728 _swigc__p_wxPropX,
6729 _swigc__p_wxPropXArray,
6730 _swigc__p_wxPyApp,
6731 _swigc__p_wxPyCommandEvent,
6732 _swigc__p_wxPyEvent,
6733 _swigc__p_wxPyImageHandler,
6734 _swigc__p_wxPySizer,
6735 _swigc__p_wxPyValidator,
6736 _swigc__p_wxQueryNewPaletteEvent,
6737 _swigc__p_wxScrollEvent,
6738 _swigc__p_wxScrollWinEvent,
6739 _swigc__p_wxSetCursorEvent,
6740 _swigc__p_wxShowEvent,
6741 _swigc__p_wxSizeEvent,
6742 _swigc__p_wxSizer,
6743 _swigc__p_wxSizerItem,
6744 _swigc__p_wxStaticBoxSizer,
6745 _swigc__p_wxStdDialogButtonSizer,
6746 _swigc__p_wxSysColourChangedEvent,
6747 _swigc__p_wxTGAHandler,
6748 _swigc__p_wxTIFFHandler,
6749 _swigc__p_wxUpdateUIEvent,
6750 _swigc__p_wxValidator,
6751 _swigc__p_wxWindow,
6752 _swigc__p_wxWindowCreateEvent,
6753 _swigc__p_wxWindowDestroyEvent,
6754 _swigc__p_wxXPMHandler,
6755 };
6756
6757
6758 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
6759
6760 static swig_const_info swig_const_table[] = {
6761 {0, 0, 0, 0.0, 0, 0}};
6762
6763 #ifdef __cplusplus
6764 }
6765 #endif
6766 /* -----------------------------------------------------------------------------
6767 * Type initialization:
6768 * This problem is tough by the requirement that no dynamic
6769 * memory is used. Also, since swig_type_info structures store pointers to
6770 * swig_cast_info structures and swig_cast_info structures store pointers back
6771 * to swig_type_info structures, we need some lookup code at initialization.
6772 * The idea is that swig generates all the structures that are needed.
6773 * The runtime then collects these partially filled structures.
6774 * The SWIG_InitializeModule function takes these initial arrays out of
6775 * swig_module, and does all the lookup, filling in the swig_module.types
6776 * array with the correct data and linking the correct swig_cast_info
6777 * structures together.
6778 *
6779 * The generated swig_type_info structures are assigned staticly to an initial
6780 * array. We just loop though that array, and handle each type individually.
6781 * First we lookup if this type has been already loaded, and if so, use the
6782 * loaded structure instead of the generated one. Then we have to fill in the
6783 * cast linked list. The cast data is initially stored in something like a
6784 * two-dimensional array. Each row corresponds to a type (there are the same
6785 * number of rows as there are in the swig_type_initial array). Each entry in
6786 * a column is one of the swig_cast_info structures for that type.
6787 * The cast_initial array is actually an array of arrays, because each row has
6788 * a variable number of columns. So to actually build the cast linked list,
6789 * we find the array of casts associated with the type, and loop through it
6790 * adding the casts to the list. The one last trick we need to do is making
6791 * sure the type pointer in the swig_cast_info struct is correct.
6792 *
6793 * First off, we lookup the cast->type name to see if it is already loaded.
6794 * There are three cases to handle:
6795 * 1) If the cast->type has already been loaded AND the type we are adding
6796 * casting info to has not been loaded (it is in this module), THEN we
6797 * replace the cast->type pointer with the type pointer that has already
6798 * been loaded.
6799 * 2) If BOTH types (the one we are adding casting info to, and the
6800 * cast->type) are loaded, THEN the cast info has already been loaded by
6801 * the previous module so we just ignore it.
6802 * 3) Finally, if cast->type has not already been loaded, then we add that
6803 * swig_cast_info to the linked list (because the cast->type) pointer will
6804 * be correct.
6805 * ----------------------------------------------------------------------------- */
6806
6807 #ifdef __cplusplus
6808 extern "C" {
6809 #if 0
6810 } /* c-mode */
6811 #endif
6812 #endif
6813
6814 #if 0
6815 #define SWIGRUNTIME_DEBUG
6816 #endif
6817
6818 SWIGRUNTIME void
6819 SWIG_InitializeModule(void *clientdata) {
6820 size_t i;
6821 swig_module_info *module_head;
6822 static int init_run = 0;
6823
6824 clientdata = clientdata;
6825
6826 if (init_run) return;
6827 init_run = 1;
6828
6829 /* Initialize the swig_module */
6830 swig_module.type_initial = swig_type_initial;
6831 swig_module.cast_initial = swig_cast_initial;
6832
6833 /* Try and load any already created modules */
6834 module_head = SWIG_GetModule(clientdata);
6835 if (module_head) {
6836 swig_module.next = module_head->next;
6837 module_head->next = &swig_module;
6838 } else {
6839 /* This is the first module loaded */
6840 swig_module.next = &swig_module;
6841 SWIG_SetModule(clientdata, &swig_module);
6842 }
6843
6844 /* Now work on filling in swig_module.types */
6845 #ifdef SWIGRUNTIME_DEBUG
6846 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
6847 #endif
6848 for (i = 0; i < swig_module.size; ++i) {
6849 swig_type_info *type = 0;
6850 swig_type_info *ret;
6851 swig_cast_info *cast;
6852
6853 #ifdef SWIGRUNTIME_DEBUG
6854 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6855 #endif
6856
6857 /* if there is another module already loaded */
6858 if (swig_module.next != &swig_module) {
6859 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
6860 }
6861 if (type) {
6862 /* Overwrite clientdata field */
6863 #ifdef SWIGRUNTIME_DEBUG
6864 printf("SWIG_InitializeModule: found type %s\n", type->name);
6865 #endif
6866 if (swig_module.type_initial[i]->clientdata) {
6867 type->clientdata = swig_module.type_initial[i]->clientdata;
6868 #ifdef SWIGRUNTIME_DEBUG
6869 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
6870 #endif
6871 }
6872 } else {
6873 type = swig_module.type_initial[i];
6874 }
6875
6876 /* Insert casting types */
6877 cast = swig_module.cast_initial[i];
6878 while (cast->type) {
6879 /* Don't need to add information already in the list */
6880 ret = 0;
6881 #ifdef SWIGRUNTIME_DEBUG
6882 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
6883 #endif
6884 if (swig_module.next != &swig_module) {
6885 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
6886 #ifdef SWIGRUNTIME_DEBUG
6887 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
6888 #endif
6889 }
6890 if (ret) {
6891 if (type == swig_module.type_initial[i]) {
6892 #ifdef SWIGRUNTIME_DEBUG
6893 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
6894 #endif
6895 cast->type = ret;
6896 ret = 0;
6897 } else {
6898 /* Check for casting already in the list */
6899 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
6900 #ifdef SWIGRUNTIME_DEBUG
6901 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
6902 #endif
6903 if (!ocast) ret = 0;
6904 }
6905 }
6906
6907 if (!ret) {
6908 #ifdef SWIGRUNTIME_DEBUG
6909 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
6910 #endif
6911 if (type->cast) {
6912 type->cast->prev = cast;
6913 cast->next = type->cast;
6914 }
6915 type->cast = cast;
6916 }
6917 cast++;
6918 }
6919 /* Set entry in modules->types array equal to the type */
6920 swig_module.types[i] = type;
6921 }
6922 swig_module.types[i] = 0;
6923
6924 #ifdef SWIGRUNTIME_DEBUG
6925 printf("**** SWIG_InitializeModule: Cast List ******\n");
6926 for (i = 0; i < swig_module.size; ++i) {
6927 int j = 0;
6928 swig_cast_info *cast = swig_module.cast_initial[i];
6929 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6930 while (cast->type) {
6931 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
6932 cast++;
6933 ++j;
6934 }
6935 printf("---- Total casts: %d\n",j);
6936 }
6937 printf("**** SWIG_InitializeModule: Cast List ******\n");
6938 #endif
6939 }
6940
6941 /* This function will propagate the clientdata field of type to
6942 * any new swig_type_info structures that have been added into the list
6943 * of equivalent types. It is like calling
6944 * SWIG_TypeClientData(type, clientdata) a second time.
6945 */
6946 SWIGRUNTIME void
6947 SWIG_PropagateClientData(void) {
6948 size_t i;
6949 swig_cast_info *equiv;
6950 static int init_run = 0;
6951
6952 if (init_run) return;
6953 init_run = 1;
6954
6955 for (i = 0; i < swig_module.size; i++) {
6956 if (swig_module.types[i]->clientdata) {
6957 equiv = swig_module.types[i]->cast;
6958 while (equiv) {
6959 if (!equiv->converter) {
6960 if (equiv->type && !equiv->type->clientdata)
6961 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
6962 }
6963 equiv = equiv->next;
6964 }
6965 }
6966 }
6967 }
6968
6969 #ifdef __cplusplus
6970 #if 0
6971 {
6972 /* c-mode */
6973 #endif
6974 }
6975 #endif
6976
6977
6978
6979 #ifdef __cplusplus
6980 extern "C" {
6981 #endif
6982
6983 /* Python-specific SWIG API */
6984 #define SWIG_newvarlink() SWIG_Python_newvarlink()
6985 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
6986 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
6987
6988 /* -----------------------------------------------------------------------------
6989 * global variable support code.
6990 * ----------------------------------------------------------------------------- */
6991
6992 typedef struct swig_globalvar {
6993 char *name; /* Name of global variable */
6994 PyObject *(*get_attr)(void); /* Return the current value */
6995 int (*set_attr)(PyObject *); /* Set the value */
6996 struct swig_globalvar *next;
6997 } swig_globalvar;
6998
6999 typedef struct swig_varlinkobject {
7000 PyObject_HEAD
7001 swig_globalvar *vars;
7002 } swig_varlinkobject;
7003
7004 SWIGINTERN PyObject *
7005 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
7006 return PyString_FromString("<Swig global variables>");
7007 }
7008
7009 SWIGINTERN PyObject *
7010 swig_varlink_str(swig_varlinkobject *v) {
7011 PyObject *str = PyString_FromString("(");
7012 swig_globalvar *var;
7013 for (var = v->vars; var; var=var->next) {
7014 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
7015 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
7016 }
7017 PyString_ConcatAndDel(&str,PyString_FromString(")"));
7018 return str;
7019 }
7020
7021 SWIGINTERN int
7022 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
7023 PyObject *str = swig_varlink_str(v);
7024 fprintf(fp,"Swig global variables ");
7025 fprintf(fp,"%s\n", PyString_AsString(str));
7026 Py_DECREF(str);
7027 return 0;
7028 }
7029
7030 SWIGINTERN void
7031 swig_varlink_dealloc(swig_varlinkobject *v) {
7032 swig_globalvar *var = v->vars;
7033 while (var) {
7034 swig_globalvar *n = var->next;
7035 free(var->name);
7036 free(var);
7037 var = n;
7038 }
7039 }
7040
7041 SWIGINTERN PyObject *
7042 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
7043 PyObject *res = NULL;
7044 swig_globalvar *var = v->vars;
7045 while (var) {
7046 if (strcmp(var->name,n) == 0) {
7047 res = (*var->get_attr)();
7048 break;
7049 }
7050 var = var->next;
7051 }
7052 if (res == NULL && !PyErr_Occurred()) {
7053 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
7054 }
7055 return res;
7056 }
7057
7058 SWIGINTERN int
7059 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
7060 int res = 1;
7061 swig_globalvar *var = v->vars;
7062 while (var) {
7063 if (strcmp(var->name,n) == 0) {
7064 res = (*var->set_attr)(p);
7065 break;
7066 }
7067 var = var->next;
7068 }
7069 if (res == 1 && !PyErr_Occurred()) {
7070 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
7071 }
7072 return res;
7073 }
7074
7075 SWIGINTERN PyTypeObject*
7076 swig_varlink_type(void) {
7077 static char varlink__doc__[] = "Swig var link object";
7078 static PyTypeObject varlink_type;
7079 static int type_init = 0;
7080 if (!type_init) {
7081 const PyTypeObject tmp
7082 = {
7083 PyObject_HEAD_INIT(NULL)
7084 0, /* Number of items in variable part (ob_size) */
7085 (char *)"swigvarlink", /* Type name (tp_name) */
7086 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
7087 0, /* Itemsize (tp_itemsize) */
7088 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
7089 (printfunc) swig_varlink_print, /* Print (tp_print) */
7090 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
7091 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
7092 0, /* tp_compare */
7093 (reprfunc) swig_varlink_repr, /* tp_repr */
7094 0, /* tp_as_number */
7095 0, /* tp_as_sequence */
7096 0, /* tp_as_mapping */
7097 0, /* tp_hash */
7098 0, /* tp_call */
7099 (reprfunc)swig_varlink_str, /* tp_str */
7100 0, /* tp_getattro */
7101 0, /* tp_setattro */
7102 0, /* tp_as_buffer */
7103 0, /* tp_flags */
7104 varlink__doc__, /* tp_doc */
7105 0, /* tp_traverse */
7106 0, /* tp_clear */
7107 0, /* tp_richcompare */
7108 0, /* tp_weaklistoffset */
7109 #if PY_VERSION_HEX >= 0x02020000
7110 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
7111 #endif
7112 #if PY_VERSION_HEX >= 0x02030000
7113 0, /* tp_del */
7114 #endif
7115 #ifdef COUNT_ALLOCS
7116 0,0,0,0 /* tp_alloc -> tp_next */
7117 #endif
7118 };
7119 varlink_type = tmp;
7120 varlink_type.ob_type = &PyType_Type;
7121 type_init = 1;
7122 }
7123 return &varlink_type;
7124 }
7125
7126 /* Create a variable linking object for use later */
7127 SWIGINTERN PyObject *
7128 SWIG_Python_newvarlink(void) {
7129 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
7130 if (result) {
7131 result->vars = 0;
7132 }
7133 return ((PyObject*) result);
7134 }
7135
7136 SWIGINTERN void
7137 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
7138 swig_varlinkobject *v = (swig_varlinkobject *) p;
7139 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
7140 if (gv) {
7141 size_t size = strlen(name)+1;
7142 gv->name = (char *)malloc(size);
7143 if (gv->name) {
7144 strncpy(gv->name,name,size);
7145 gv->get_attr = get_attr;
7146 gv->set_attr = set_attr;
7147 gv->next = v->vars;
7148 }
7149 }
7150 v->vars = gv;
7151 }
7152
7153 SWIGINTERN PyObject *
7154 SWIG_globals() {
7155 static PyObject *_SWIG_globals = 0;
7156 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
7157 return _SWIG_globals;
7158 }
7159
7160 /* -----------------------------------------------------------------------------
7161 * constants/methods manipulation
7162 * ----------------------------------------------------------------------------- */
7163
7164 /* Install Constants */
7165 SWIGINTERN void
7166 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
7167 PyObject *obj = 0;
7168 size_t i;
7169 for (i = 0; constants[i].type; ++i) {
7170 switch(constants[i].type) {
7171 case SWIG_PY_POINTER:
7172 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
7173 break;
7174 case SWIG_PY_BINARY:
7175 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
7176 break;
7177 default:
7178 obj = 0;
7179 break;
7180 }
7181 if (obj) {
7182 PyDict_SetItemString(d, constants[i].name, obj);
7183 Py_DECREF(obj);
7184 }
7185 }
7186 }
7187
7188 /* -----------------------------------------------------------------------------*/
7189 /* Fix SwigMethods to carry the callback ptrs when needed */
7190 /* -----------------------------------------------------------------------------*/
7191
7192 SWIGINTERN void
7193 SWIG_Python_FixMethods(PyMethodDef *methods,
7194 swig_const_info *const_table,
7195 swig_type_info **types,
7196 swig_type_info **types_initial) {
7197 size_t i;
7198 for (i = 0; methods[i].ml_name; ++i) {
7199 const char *c = methods[i].ml_doc;
7200 if (c && (c = strstr(c, "swig_ptr: "))) {
7201 int j;
7202 swig_const_info *ci = 0;
7203 const char *name = c + 10;
7204 for (j = 0; const_table[j].type; ++j) {
7205 if (strncmp(const_table[j].name, name,
7206 strlen(const_table[j].name)) == 0) {
7207 ci = &(const_table[j]);
7208 break;
7209 }
7210 }
7211 if (ci) {
7212 size_t shift = (ci->ptype) - types;
7213 swig_type_info *ty = types_initial[shift];
7214 size_t ldoc = (c - methods[i].ml_doc);
7215 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
7216 char *ndoc = (char*)malloc(ldoc + lptr + 10);
7217 if (ndoc) {
7218 char *buff = ndoc;
7219 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
7220 if (ptr) {
7221 strncpy(buff, methods[i].ml_doc, ldoc);
7222 buff += ldoc;
7223 strncpy(buff, "swig_ptr: ", 10);
7224 buff += 10;
7225 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
7226 methods[i].ml_doc = ndoc;
7227 }
7228 }
7229 }
7230 }
7231 }
7232 }
7233
7234 #ifdef __cplusplus
7235 }
7236 #endif
7237
7238 /* -----------------------------------------------------------------------------*
7239 * Partial Init method
7240 * -----------------------------------------------------------------------------*/
7241
7242 #ifdef __cplusplus
7243 extern "C"
7244 #endif
7245 SWIGEXPORT void SWIG_init(void) {
7246 PyObject *m, *d;
7247
7248 /* Fix SwigMethods to carry the callback ptrs when needed */
7249 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
7250
7251 m = Py_InitModule((char *) SWIG_name, SwigMethods);
7252 d = PyModule_GetDict(m);
7253
7254 SWIG_InitializeModule(0);
7255 SWIG_InstallConstants(d,swig_const_table);
7256
7257
7258 }
7259
wxWidgets (Impactor)