]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/xrc_wrap.cpp
projects / wxWidgets.git / blob
? search:


7393a9c0d120db3af0ea9deb4ff74d66af12fe40
[wxWidgets.git] / wxPython / src / gtk / xrc_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_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_wxANIHandler swig_types[6]
2473 #define SWIGTYPE_p_wxAcceleratorTable swig_types[7]
2474 #define SWIGTYPE_p_wxActivateEvent swig_types[8]
2475 #define SWIGTYPE_p_wxArtClient swig_types[9]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[10]
2477 #define SWIGTYPE_p_wxBitmap swig_types[11]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[12]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[13]
2480 #define SWIGTYPE_p_wxChildFocusEvent swig_types[14]
2481 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[15]
2482 #define SWIGTYPE_p_wxCloseEvent swig_types[16]
2483 #define SWIGTYPE_p_wxColour swig_types[17]
2484 #define SWIGTYPE_p_wxCommandEvent swig_types[18]
2485 #define SWIGTYPE_p_wxContextMenuEvent swig_types[19]
2486 #define SWIGTYPE_p_wxControl swig_types[20]
2487 #define SWIGTYPE_p_wxControlWithItems swig_types[21]
2488 #define SWIGTYPE_p_wxDateEvent swig_types[22]
2489 #define SWIGTYPE_p_wxDialog swig_types[23]
2490 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
2491 #define SWIGTYPE_p_wxDropFilesEvent swig_types[25]
2492 #define SWIGTYPE_p_wxDuplexMode swig_types[26]
2493 #define SWIGTYPE_p_wxEraseEvent swig_types[27]
2494 #define SWIGTYPE_p_wxEvent swig_types[28]
2495 #define SWIGTYPE_p_wxEvtHandler swig_types[29]
2496 #define SWIGTYPE_p_wxFSFile swig_types[30]
2497 #define SWIGTYPE_p_wxFileSystem swig_types[31]
2498 #define SWIGTYPE_p_wxFlexGridSizer swig_types[32]
2499 #define SWIGTYPE_p_wxFocusEvent swig_types[33]
2500 #define SWIGTYPE_p_wxFont swig_types[34]
2501 #define SWIGTYPE_p_wxFrame swig_types[35]
2502 #define SWIGTYPE_p_wxGBSizerItem swig_types[36]
2503 #define SWIGTYPE_p_wxGIFHandler swig_types[37]
2504 #define SWIGTYPE_p_wxGridBagSizer swig_types[38]
2505 #define SWIGTYPE_p_wxGridSizer swig_types[39]
2506 #define SWIGTYPE_p_wxICOHandler swig_types[40]
2507 #define SWIGTYPE_p_wxIcon swig_types[41]
2508 #define SWIGTYPE_p_wxIconizeEvent swig_types[42]
2509 #define SWIGTYPE_p_wxIdleEvent swig_types[43]
2510 #define SWIGTYPE_p_wxImage swig_types[44]
2511 #define SWIGTYPE_p_wxImageHandler swig_types[45]
2512 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[46]
2513 #define SWIGTYPE_p_wxInitDialogEvent swig_types[47]
2514 #define SWIGTYPE_p_wxInputStream swig_types[48]
2515 #define SWIGTYPE_p_wxJPEGHandler swig_types[49]
2516 #define SWIGTYPE_p_wxKeyEvent swig_types[50]
2517 #define SWIGTYPE_p_wxLayoutConstraints swig_types[51]
2518 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
2519 #define SWIGTYPE_p_wxMenu swig_types[53]
2520 #define SWIGTYPE_p_wxMenuBar swig_types[54]
2521 #define SWIGTYPE_p_wxMenuEvent swig_types[55]
2522 #define SWIGTYPE_p_wxMenuItem swig_types[56]
2523 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[57]
2524 #define SWIGTYPE_p_wxMouseEvent swig_types[58]
2525 #define SWIGTYPE_p_wxMoveEvent swig_types[59]
2526 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[60]
2527 #define SWIGTYPE_p_wxNcPaintEvent swig_types[61]
2528 #define SWIGTYPE_p_wxNotifyEvent swig_types[62]
2529 #define SWIGTYPE_p_wxObject swig_types[63]
2530 #define SWIGTYPE_p_wxOutputStream swig_types[64]
2531 #define SWIGTYPE_p_wxPCXHandler swig_types[65]
2532 #define SWIGTYPE_p_wxPNGHandler swig_types[66]
2533 #define SWIGTYPE_p_wxPNMHandler swig_types[67]
2534 #define SWIGTYPE_p_wxPaintEvent swig_types[68]
2535 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[69]
2536 #define SWIGTYPE_p_wxPanel swig_types[70]
2537 #define SWIGTYPE_p_wxPaperSize swig_types[71]
2538 #define SWIGTYPE_p_wxPoint swig_types[72]
2539 #define SWIGTYPE_p_wxPyApp swig_types[73]
2540 #define SWIGTYPE_p_wxPyCommandEvent swig_types[74]
2541 #define SWIGTYPE_p_wxPyEvent swig_types[75]
2542 #define SWIGTYPE_p_wxPyImageHandler swig_types[76]
2543 #define SWIGTYPE_p_wxPySizer swig_types[77]
2544 #define SWIGTYPE_p_wxPyValidator swig_types[78]
2545 #define SWIGTYPE_p_wxPyXmlResourceHandler swig_types[79]
2546 #define SWIGTYPE_p_wxPyXmlSubclassFactory swig_types[80]
2547 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[81]
2548 #define SWIGTYPE_p_wxScrollEvent swig_types[82]
2549 #define SWIGTYPE_p_wxScrollWinEvent swig_types[83]
2550 #define SWIGTYPE_p_wxSetCursorEvent swig_types[84]
2551 #define SWIGTYPE_p_wxShowEvent swig_types[85]
2552 #define SWIGTYPE_p_wxSize swig_types[86]
2553 #define SWIGTYPE_p_wxSizeEvent swig_types[87]
2554 #define SWIGTYPE_p_wxSizer swig_types[88]
2555 #define SWIGTYPE_p_wxSizerItem swig_types[89]
2556 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[90]
2557 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[91]
2558 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[92]
2559 #define SWIGTYPE_p_wxTIFFHandler swig_types[93]
2560 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[94]
2561 #define SWIGTYPE_p_wxValidator swig_types[95]
2562 #define SWIGTYPE_p_wxWindow swig_types[96]
2563 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[97]
2564 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[98]
2565 #define SWIGTYPE_p_wxXPMHandler swig_types[99]
2566 #define SWIGTYPE_p_wxXmlDocument swig_types[100]
2567 #define SWIGTYPE_p_wxXmlNode swig_types[101]
2568 #define SWIGTYPE_p_wxXmlProperty swig_types[102]
2569 #define SWIGTYPE_p_wxXmlResource swig_types[103]
2570 static swig_type_info *swig_types[105];
2571 static swig_module_info swig_module = {swig_types, 104, 0, 0, 0, 0};
2572 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2573 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2574
2575 /* -------- TYPES TABLE (END) -------- */
2576
2577 #if (PY_VERSION_HEX <= 0x02000000)
2578 # if !defined(SWIG_PYTHON_CLASSIC)
2579 # error "This python version requires to use swig with the '-classic' option"
2580 # endif
2581 #endif
2582 #if (PY_VERSION_HEX <= 0x02020000)
2583 # error "This python version requires to use swig with the '-nomodern' option"
2584 #endif
2585 #if (PY_VERSION_HEX <= 0x02020000)
2586 # error "This python version requires to use swig with the '-nomodernargs' option"
2587 #endif
2588 #ifndef METH_O
2589 # error "This python version requires to use swig with the '-nofastunpack' option"
2590 #endif
2591
2592 /*-----------------------------------------------
2593 @(target):= _xrc.so
2594 ------------------------------------------------*/
2595 #define SWIG_init init_xrc
2596
2597 #define SWIG_name "_xrc"
2598
2599 #define SWIGVERSION 0x010329
2600
2601
2602 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2603 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2604
2605
2606 #include <stdexcept>
2607
2608
2609 namespace swig {
2610 class PyObject_ptr {
2611 protected:
2612 PyObject *_obj;
2613
2614 public:
2615 PyObject_ptr() :_obj(0)
2616 {
2617 }
2618
2619 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2620 {
2621 Py_XINCREF(_obj);
2622 }
2623
2624 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2625 {
2626 if (initial_ref) Py_XINCREF(_obj);
2627 }
2628
2629 PyObject_ptr & operator=(const PyObject_ptr& item)
2630 {
2631 Py_XINCREF(item._obj);
2632 Py_XDECREF(_obj);
2633 _obj = item._obj;
2634 return *this;
2635 }
2636
2637 ~PyObject_ptr()
2638 {
2639 Py_XDECREF(_obj);
2640 }
2641
2642 operator PyObject *() const
2643 {
2644 return _obj;
2645 }
2646
2647 PyObject *operator->() const
2648 {
2649 return _obj;
2650 }
2651 };
2652 }
2653
2654
2655 namespace swig {
2656 struct PyObject_var : PyObject_ptr {
2657 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2658
2659 PyObject_var & operator = (PyObject* obj)
2660 {
2661 Py_XDECREF(_obj);
2662 _obj = obj;
2663 return *this;
2664 }
2665 };
2666 }
2667
2668
2669 #include "wx/wxPython/wxPython.h"
2670 #include "wx/wxPython/pyclasses.h"
2671 #include "wx/wxPython/pyistream.h"
2672
2673 #include <wx/xml/xml.h>
2674 #include <wx/xrc/xmlres.h>
2675
2676 static const wxString wxPyEmptyString(wxEmptyString);
2677 static const wxString wxPyUTF8String(wxT("UTF-8"));
2678 static const wxString wxPyStyleString(wxT("style"));
2679 static const wxString wxPySizeString(wxT("size"));
2680 static const wxString wxPyPosString(wxT("pos"));
2681 static const wxString wxPyBitmapString(wxT("bitmap"));
2682 static const wxString wxPyIconString(wxT("icon"));
2683 static const wxString wxPyFontString(wxT("font"));
2684
2685 #define SWIG_From_long PyInt_FromLong
2686
2687
2688 SWIGINTERNINLINE PyObject *
2689 SWIG_From_int (int value)
2690 {
2691 return SWIG_From_long (value);
2692 }
2693
2694
2695 #include <limits.h>
2696 #ifndef LLONG_MIN
2697 # define LLONG_MIN LONG_LONG_MIN
2698 #endif
2699 #ifndef LLONG_MAX
2700 # define LLONG_MAX LONG_LONG_MAX
2701 #endif
2702 #ifndef ULLONG_MAX
2703 # define ULLONG_MAX ULONG_LONG_MAX
2704 #endif
2705
2706
2707 SWIGINTERN int
2708 SWIG_AsVal_long (PyObject* obj, long* val)
2709 {
2710 if (PyNumber_Check(obj)) {
2711 if (val) *val = PyInt_AsLong(obj);
2712 return SWIG_OK;
2713 }
2714 return SWIG_TypeError;
2715 }
2716
2717
2718 SWIGINTERN int
2719 SWIG_AsVal_int (PyObject * obj, int *val)
2720 {
2721 long v;
2722 int res = SWIG_AsVal_long (obj, &v);
2723 if (SWIG_IsOK(res)) {
2724 if ((v < INT_MIN || v > INT_MAX)) {
2725 return SWIG_OverflowError;
2726 } else {
2727 if (val) *val = static_cast< int >(v);
2728 }
2729 }
2730 return res;
2731 }
2732
2733 SWIGINTERN bool wxXmlResource_LoadFromString(wxXmlResource *self,wxString const &data){
2734 static int s_memFileIdx = 0;
2735
2736 // Check for memory FS. If not present, load the handler:
2737 wxMemoryFSHandler::AddFile(wxT("XRC_resource/dummy_file"),
2738 wxT("dummy data"));
2739 wxFileSystem fsys;
2740 wxFSFile *f = fsys.OpenFile(wxT("memory:XRC_resource/dummy_file"));
2741 wxMemoryFSHandler::RemoveFile(wxT("XRC_resource/dummy_file"));
2742 if (f)
2743 delete f;
2744 else
2745 wxFileSystem::AddHandler(new wxMemoryFSHandler);
2746
2747 // Now put the resource data into the memory FS
2748 wxString filename(wxT("XRC_resource/data_string_"));
2749 filename << s_memFileIdx;
2750 s_memFileIdx += 1;
2751 wxMemoryFSHandler::AddFile(filename, data);
2752
2753 // Load the "file" into the resource object
2754 bool retval = self->Load(wxT("memory:") + filename );
2755
2756 return retval;
2757 }
2758
2759 class wxPyXmlSubclassFactory : public wxXmlSubclassFactory
2760 {
2761 public:
2762 wxPyXmlSubclassFactory() {}
2763 DEC_PYCALLBACK_OBJECT_STRING_pure(Create);
2764 PYPRIVATE;
2765 };
2766
2767 IMP_PYCALLBACK_OBJECT_STRING_pure(wxPyXmlSubclassFactory, wxXmlSubclassFactory, Create);
2768
2769 // C++ version of Python aware wxXmlResourceHandler, for the pure virtual
2770 // callbacks, as well as to make some protected things public so they can
2771 // be wrapped.
2772 class wxPyXmlResourceHandler : public wxXmlResourceHandler {
2773 public:
2774 wxPyXmlResourceHandler() : wxXmlResourceHandler() {}
2775 //~wxPyXmlResourceHandler();
2776
2777 // Base class virtuals
2778
2779 DEC_PYCALLBACK_OBJECT__pure(DoCreateResource);
2780 DEC_PYCALLBACK_BOOL_NODE_pure(CanHandle);
2781
2782
2783 // accessors for protected members
2784
2785 wxXmlResource* GetResource() { return m_resource; }
2786 wxXmlNode* GetNode() { return m_node; }
2787 wxString GetClass() { return m_class; }
2788 wxObject* GetParent() { return m_parent; }
2789 wxObject* GetInstance() { return m_instance; }
2790 wxWindow* GetParentAsWindow() { return m_parentAsWindow; }
2791
2792
2793 // turn some protected methods into public via delegation
2794
2795 bool IsOfClass(wxXmlNode *node, const wxString& classname)
2796 { return wxXmlResourceHandler::IsOfClass(node, classname); }
2797
2798 wxString GetNodeContent(wxXmlNode *node)
2799 { return wxXmlResourceHandler::GetNodeContent(node); }
2800
2801 bool HasParam(const wxString& param)
2802 { return wxXmlResourceHandler::HasParam(param); }
2803
2804 wxXmlNode *GetParamNode(const wxString& param)
2805 { return wxXmlResourceHandler::GetParamNode(param); }
2806
2807 wxString GetParamValue(const wxString& param)
2808 { return wxXmlResourceHandler::GetParamValue(param); }
2809
2810 void AddStyle(const wxString& name, int value)
2811 { wxXmlResourceHandler::AddStyle(name, value); }
2812
2813 void AddWindowStyles()
2814 { wxXmlResourceHandler::AddWindowStyles(); }
2815
2816 int GetStyle(const wxString& param = wxT("style"), int defaults = 0)
2817 { return wxXmlResourceHandler::GetStyle(param, defaults); }
2818
2819 wxString GetText(const wxString& param, bool translate = true)
2820 { return wxXmlResourceHandler::GetText(param, translate); }
2821
2822 int GetID()
2823 { return wxXmlResourceHandler::GetID(); }
2824
2825 wxString GetName()
2826 { return wxXmlResourceHandler::GetName(); }
2827
2828 bool GetBool(const wxString& param, bool defaultv = false)
2829 { return wxXmlResourceHandler::GetBool(param, defaultv); }
2830
2831 long GetLong( const wxString& param, long defaultv = 0 )
2832 { return wxXmlResourceHandler::GetLong(param, defaultv); }
2833
2834 wxColour GetColour(const wxString& param)
2835 { return wxXmlResourceHandler::GetColour(param); }
2836
2837 wxSize GetSize(const wxString& param = wxT("size"))
2838 { return wxXmlResourceHandler::GetSize(param); }
2839
2840 wxPoint GetPosition(const wxString& param = wxT("pos"))
2841 { return wxXmlResourceHandler::GetPosition(param); }
2842
2843 wxCoord GetDimension(const wxString& param, wxCoord defaultv = 0)
2844 { return wxXmlResourceHandler::GetDimension(param, defaultv); }
2845
2846 wxBitmap GetBitmap(const wxString& param = wxT("bitmap"),
2847 const wxArtClient& defaultArtClient = wxART_OTHER,
2848 wxSize size = wxDefaultSize)
2849 { return wxXmlResourceHandler::GetBitmap(param, defaultArtClient, size); }
2850
2851 wxIcon GetIcon(const wxString& param = wxT("icon"),
2852 const wxArtClient& defaultArtClient = wxART_OTHER,
2853 wxSize size = wxDefaultSize)
2854 { return wxXmlResourceHandler::GetIcon(param, defaultArtClient, size); }
2855
2856 wxFont GetFont(const wxString& param = wxT("font"))
2857 { return wxXmlResourceHandler::GetFont(param); }
2858
2859 void SetupWindow(wxWindow *wnd)
2860 { wxXmlResourceHandler::SetupWindow(wnd); }
2861
2862 void CreateChildren(wxObject *parent, bool this_hnd_only = false)
2863 { wxXmlResourceHandler::CreateChildren(parent, this_hnd_only); }
2864
2865 void CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode = NULL)
2866 { wxXmlResourceHandler::CreateChildrenPrivately(parent, rootnode); }
2867
2868 wxObject *CreateResFromNode(wxXmlNode *node,
2869 wxObject *parent, wxObject *instance = NULL)
2870 { return wxXmlResourceHandler::CreateResFromNode(node, parent, instance); }
2871
2872 wxFileSystem& GetCurFileSystem()
2873 { return wxXmlResourceHandler::GetCurFileSystem(); }
2874
2875
2876 PYPRIVATE;
2877 };
2878
2879 IMP_PYCALLBACK_OBJECT__pure(wxPyXmlResourceHandler, wxXmlResourceHandler, DoCreateResource);
2880 IMP_PYCALLBACK_BOOL_NODE_pure(wxPyXmlResourceHandler, wxXmlResourceHandler, CanHandle);
2881
2882
2883
2884 SWIGINTERN int
2885 SWIG_AsVal_bool (PyObject *obj, bool *val)
2886 {
2887 if (obj == Py_True) {
2888 if (val) *val = true;
2889 return SWIG_OK;
2890 } else if (obj == Py_False) {
2891 if (val) *val = false;
2892 return SWIG_OK;
2893 } else {
2894 long v = 0;
2895 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2896 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2897 return res;
2898 }
2899 }
2900
2901 #ifdef __cplusplus
2902 extern "C" {
2903 #endif
2904 SWIGINTERN int UTF8String_set(PyObject *) {
2905 SWIG_Error(SWIG_AttributeError,"Variable UTF8String is read-only.");
2906 return 1;
2907 }
2908
2909
2910 SWIGINTERN PyObject *UTF8String_get(void) {
2911 PyObject *pyobj = 0;
2912
2913 {
2914 #if wxUSE_UNICODE
2915 pyobj = PyUnicode_FromWideChar((&wxPyUTF8String)->c_str(), (&wxPyUTF8String)->Len());
2916 #else
2917 pyobj = PyString_FromStringAndSize((&wxPyUTF8String)->c_str(), (&wxPyUTF8String)->Len());
2918 #endif
2919 }
2920 return pyobj;
2921 }
2922
2923
2924 SWIGINTERN int StyleString_set(PyObject *) {
2925 SWIG_Error(SWIG_AttributeError,"Variable StyleString is read-only.");
2926 return 1;
2927 }
2928
2929
2930 SWIGINTERN PyObject *StyleString_get(void) {
2931 PyObject *pyobj = 0;
2932
2933 {
2934 #if wxUSE_UNICODE
2935 pyobj = PyUnicode_FromWideChar((&wxPyStyleString)->c_str(), (&wxPyStyleString)->Len());
2936 #else
2937 pyobj = PyString_FromStringAndSize((&wxPyStyleString)->c_str(), (&wxPyStyleString)->Len());
2938 #endif
2939 }
2940 return pyobj;
2941 }
2942
2943
2944 SWIGINTERN int SizeString_set(PyObject *) {
2945 SWIG_Error(SWIG_AttributeError,"Variable SizeString is read-only.");
2946 return 1;
2947 }
2948
2949
2950 SWIGINTERN PyObject *SizeString_get(void) {
2951 PyObject *pyobj = 0;
2952
2953 {
2954 #if wxUSE_UNICODE
2955 pyobj = PyUnicode_FromWideChar((&wxPySizeString)->c_str(), (&wxPySizeString)->Len());
2956 #else
2957 pyobj = PyString_FromStringAndSize((&wxPySizeString)->c_str(), (&wxPySizeString)->Len());
2958 #endif
2959 }
2960 return pyobj;
2961 }
2962
2963
2964 SWIGINTERN int PosString_set(PyObject *) {
2965 SWIG_Error(SWIG_AttributeError,"Variable PosString is read-only.");
2966 return 1;
2967 }
2968
2969
2970 SWIGINTERN PyObject *PosString_get(void) {
2971 PyObject *pyobj = 0;
2972
2973 {
2974 #if wxUSE_UNICODE
2975 pyobj = PyUnicode_FromWideChar((&wxPyPosString)->c_str(), (&wxPyPosString)->Len());
2976 #else
2977 pyobj = PyString_FromStringAndSize((&wxPyPosString)->c_str(), (&wxPyPosString)->Len());
2978 #endif
2979 }
2980 return pyobj;
2981 }
2982
2983
2984 SWIGINTERN int BitmapString_set(PyObject *) {
2985 SWIG_Error(SWIG_AttributeError,"Variable BitmapString is read-only.");
2986 return 1;
2987 }
2988
2989
2990 SWIGINTERN PyObject *BitmapString_get(void) {
2991 PyObject *pyobj = 0;
2992
2993 {
2994 #if wxUSE_UNICODE
2995 pyobj = PyUnicode_FromWideChar((&wxPyBitmapString)->c_str(), (&wxPyBitmapString)->Len());
2996 #else
2997 pyobj = PyString_FromStringAndSize((&wxPyBitmapString)->c_str(), (&wxPyBitmapString)->Len());
2998 #endif
2999 }
3000 return pyobj;
3001 }
3002
3003
3004 SWIGINTERN int IconString_set(PyObject *) {
3005 SWIG_Error(SWIG_AttributeError,"Variable IconString is read-only.");
3006 return 1;
3007 }
3008
3009
3010 SWIGINTERN PyObject *IconString_get(void) {
3011 PyObject *pyobj = 0;
3012
3013 {
3014 #if wxUSE_UNICODE
3015 pyobj = PyUnicode_FromWideChar((&wxPyIconString)->c_str(), (&wxPyIconString)->Len());
3016 #else
3017 pyobj = PyString_FromStringAndSize((&wxPyIconString)->c_str(), (&wxPyIconString)->Len());
3018 #endif
3019 }
3020 return pyobj;
3021 }
3022
3023
3024 SWIGINTERN int FontString_set(PyObject *) {
3025 SWIG_Error(SWIG_AttributeError,"Variable FontString is read-only.");
3026 return 1;
3027 }
3028
3029
3030 SWIGINTERN PyObject *FontString_get(void) {
3031 PyObject *pyobj = 0;
3032
3033 {
3034 #if wxUSE_UNICODE
3035 pyobj = PyUnicode_FromWideChar((&wxPyFontString)->c_str(), (&wxPyFontString)->Len());
3036 #else
3037 pyobj = PyString_FromStringAndSize((&wxPyFontString)->c_str(), (&wxPyFontString)->Len());
3038 #endif
3039 }
3040 return pyobj;
3041 }
3042
3043
3044 SWIGINTERN PyObject *_wrap_new_XmlResource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3045 PyObject *resultobj = 0;
3046 wxString *arg1 = 0 ;
3047 int arg2 = (int) wxXRC_USE_LOCALE ;
3048 wxXmlResource *result = 0 ;
3049 bool temp1 = false ;
3050 int val2 ;
3051 int ecode2 = 0 ;
3052 PyObject * obj0 = 0 ;
3053 PyObject * obj1 = 0 ;
3054 char * kwnames[] = {
3055 (char *) "filemask",(char *) "flags", NULL
3056 };
3057
3058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_XmlResource",kwnames,&obj0,&obj1)) SWIG_fail;
3059 {
3060 arg1 = wxString_in_helper(obj0);
3061 if (arg1 == NULL) SWIG_fail;
3062 temp1 = true;
3063 }
3064 if (obj1) {
3065 ecode2 = SWIG_AsVal_int(obj1, &val2);
3066 if (!SWIG_IsOK(ecode2)) {
3067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XmlResource" "', expected argument " "2"" of type '" "int""'");
3068 }
3069 arg2 = static_cast< int >(val2);
3070 }
3071 {
3072 PyThreadState* __tstate = wxPyBeginAllowThreads();
3073 result = (wxXmlResource *)new wxXmlResource((wxString const &)*arg1,arg2);
3074 wxPyEndAllowThreads(__tstate);
3075 if (PyErr_Occurred()) SWIG_fail;
3076 }
3077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlResource, SWIG_POINTER_NEW | 0 );
3078 {
3079 if (temp1)
3080 delete arg1;
3081 }
3082 return resultobj;
3083 fail:
3084 {
3085 if (temp1)
3086 delete arg1;
3087 }
3088 return NULL;
3089 }
3090
3091
3092 SWIGINTERN PyObject *_wrap_new_EmptyXmlResource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3093 PyObject *resultobj = 0;
3094 int arg1 = (int) wxXRC_USE_LOCALE ;
3095 wxXmlResource *result = 0 ;
3096 int val1 ;
3097 int ecode1 = 0 ;
3098 PyObject * obj0 = 0 ;
3099 char * kwnames[] = {
3100 (char *) "flags", NULL
3101 };
3102
3103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_EmptyXmlResource",kwnames,&obj0)) SWIG_fail;
3104 if (obj0) {
3105 ecode1 = SWIG_AsVal_int(obj0, &val1);
3106 if (!SWIG_IsOK(ecode1)) {
3107 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyXmlResource" "', expected argument " "1"" of type '" "int""'");
3108 }
3109 arg1 = static_cast< int >(val1);
3110 }
3111 {
3112 PyThreadState* __tstate = wxPyBeginAllowThreads();
3113 result = (wxXmlResource *)new wxXmlResource(arg1);
3114 wxPyEndAllowThreads(__tstate);
3115 if (PyErr_Occurred()) SWIG_fail;
3116 }
3117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlResource, SWIG_POINTER_OWN | 0 );
3118 return resultobj;
3119 fail:
3120 return NULL;
3121 }
3122
3123
3124 SWIGINTERN PyObject *_wrap_delete_XmlResource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3125 PyObject *resultobj = 0;
3126 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3127 void *argp1 = 0 ;
3128 int res1 = 0 ;
3129 PyObject *swig_obj[1] ;
3130
3131 if (!args) SWIG_fail;
3132 swig_obj[0] = args;
3133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlResource, SWIG_POINTER_DISOWN | 0 );
3134 if (!SWIG_IsOK(res1)) {
3135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XmlResource" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3136 }
3137 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3138 {
3139 PyThreadState* __tstate = wxPyBeginAllowThreads();
3140 delete arg1;
3141
3142 wxPyEndAllowThreads(__tstate);
3143 if (PyErr_Occurred()) SWIG_fail;
3144 }
3145 resultobj = SWIG_Py_Void();
3146 return resultobj;
3147 fail:
3148 return NULL;
3149 }
3150
3151
3152 SWIGINTERN PyObject *_wrap_XmlResource_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3153 PyObject *resultobj = 0;
3154 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3155 wxString *arg2 = 0 ;
3156 bool result;
3157 void *argp1 = 0 ;
3158 int res1 = 0 ;
3159 bool temp2 = false ;
3160 PyObject * obj0 = 0 ;
3161 PyObject * obj1 = 0 ;
3162 char * kwnames[] = {
3163 (char *) "self",(char *) "filemask", NULL
3164 };
3165
3166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_Load",kwnames,&obj0,&obj1)) SWIG_fail;
3167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3168 if (!SWIG_IsOK(res1)) {
3169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_Load" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3170 }
3171 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3172 {
3173 arg2 = wxString_in_helper(obj1);
3174 if (arg2 == NULL) SWIG_fail;
3175 temp2 = true;
3176 }
3177 {
3178 PyThreadState* __tstate = wxPyBeginAllowThreads();
3179 result = (bool)(arg1)->Load((wxString const &)*arg2);
3180 wxPyEndAllowThreads(__tstate);
3181 if (PyErr_Occurred()) SWIG_fail;
3182 }
3183 {
3184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3185 }
3186 {
3187 if (temp2)
3188 delete arg2;
3189 }
3190 return resultobj;
3191 fail:
3192 {
3193 if (temp2)
3194 delete arg2;
3195 }
3196 return NULL;
3197 }
3198
3199
3200 SWIGINTERN PyObject *_wrap_XmlResource_LoadFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3201 PyObject *resultobj = 0;
3202 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3203 wxString *arg2 = 0 ;
3204 bool result;
3205 void *argp1 = 0 ;
3206 int res1 = 0 ;
3207 bool temp2 = false ;
3208 PyObject * obj0 = 0 ;
3209 PyObject * obj1 = 0 ;
3210 char * kwnames[] = {
3211 (char *) "self",(char *) "data", NULL
3212 };
3213
3214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_LoadFromString",kwnames,&obj0,&obj1)) SWIG_fail;
3215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3216 if (!SWIG_IsOK(res1)) {
3217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadFromString" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3218 }
3219 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3220 {
3221 arg2 = wxString_in_helper(obj1);
3222 if (arg2 == NULL) SWIG_fail;
3223 temp2 = true;
3224 }
3225 {
3226 PyThreadState* __tstate = wxPyBeginAllowThreads();
3227 result = (bool)wxXmlResource_LoadFromString(arg1,(wxString const &)*arg2);
3228 wxPyEndAllowThreads(__tstate);
3229 if (PyErr_Occurred()) SWIG_fail;
3230 }
3231 {
3232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3233 }
3234 {
3235 if (temp2)
3236 delete arg2;
3237 }
3238 return resultobj;
3239 fail:
3240 {
3241 if (temp2)
3242 delete arg2;
3243 }
3244 return NULL;
3245 }
3246
3247
3248 SWIGINTERN PyObject *_wrap_XmlResource_Unload(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3249 PyObject *resultobj = 0;
3250 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3251 wxString *arg2 = 0 ;
3252 bool result;
3253 void *argp1 = 0 ;
3254 int res1 = 0 ;
3255 bool temp2 = false ;
3256 PyObject * obj0 = 0 ;
3257 PyObject * obj1 = 0 ;
3258 char * kwnames[] = {
3259 (char *) "self",(char *) "filename", NULL
3260 };
3261
3262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_Unload",kwnames,&obj0,&obj1)) SWIG_fail;
3263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3264 if (!SWIG_IsOK(res1)) {
3265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_Unload" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3266 }
3267 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3268 {
3269 arg2 = wxString_in_helper(obj1);
3270 if (arg2 == NULL) SWIG_fail;
3271 temp2 = true;
3272 }
3273 {
3274 PyThreadState* __tstate = wxPyBeginAllowThreads();
3275 result = (bool)(arg1)->Unload((wxString const &)*arg2);
3276 wxPyEndAllowThreads(__tstate);
3277 if (PyErr_Occurred()) SWIG_fail;
3278 }
3279 {
3280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3281 }
3282 {
3283 if (temp2)
3284 delete arg2;
3285 }
3286 return resultobj;
3287 fail:
3288 {
3289 if (temp2)
3290 delete arg2;
3291 }
3292 return NULL;
3293 }
3294
3295
3296 SWIGINTERN PyObject *_wrap_XmlResource_InitAllHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3297 PyObject *resultobj = 0;
3298 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3299 void *argp1 = 0 ;
3300 int res1 = 0 ;
3301 PyObject *swig_obj[1] ;
3302
3303 if (!args) SWIG_fail;
3304 swig_obj[0] = args;
3305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3306 if (!SWIG_IsOK(res1)) {
3307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_InitAllHandlers" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3308 }
3309 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3310 {
3311 PyThreadState* __tstate = wxPyBeginAllowThreads();
3312 (arg1)->InitAllHandlers();
3313 wxPyEndAllowThreads(__tstate);
3314 if (PyErr_Occurred()) SWIG_fail;
3315 }
3316 resultobj = SWIG_Py_Void();
3317 return resultobj;
3318 fail:
3319 return NULL;
3320 }
3321
3322
3323 SWIGINTERN PyObject *_wrap_XmlResource_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3324 PyObject *resultobj = 0;
3325 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3326 wxPyXmlResourceHandler *arg2 = (wxPyXmlResourceHandler *) 0 ;
3327 void *argp1 = 0 ;
3328 int res1 = 0 ;
3329 void *argp2 = 0 ;
3330 int res2 = 0 ;
3331 PyObject * obj0 = 0 ;
3332 PyObject * obj1 = 0 ;
3333 char * kwnames[] = {
3334 (char *) "self",(char *) "handler", NULL
3335 };
3336
3337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_AddHandler",kwnames,&obj0,&obj1)) SWIG_fail;
3338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3339 if (!SWIG_IsOK(res1)) {
3340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_AddHandler" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3341 }
3342 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3343 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
3344 if (!SWIG_IsOK(res2)) {
3345 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_AddHandler" "', expected argument " "2"" of type '" "wxPyXmlResourceHandler *""'");
3346 }
3347 arg2 = reinterpret_cast< wxPyXmlResourceHandler * >(argp2);
3348 {
3349 PyThreadState* __tstate = wxPyBeginAllowThreads();
3350 (arg1)->AddHandler(arg2);
3351 wxPyEndAllowThreads(__tstate);
3352 if (PyErr_Occurred()) SWIG_fail;
3353 }
3354 resultobj = SWIG_Py_Void();
3355 return resultobj;
3356 fail:
3357 return NULL;
3358 }
3359
3360
3361 SWIGINTERN PyObject *_wrap_XmlResource_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3362 PyObject *resultobj = 0;
3363 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3364 wxPyXmlResourceHandler *arg2 = (wxPyXmlResourceHandler *) 0 ;
3365 void *argp1 = 0 ;
3366 int res1 = 0 ;
3367 void *argp2 = 0 ;
3368 int res2 = 0 ;
3369 PyObject * obj0 = 0 ;
3370 PyObject * obj1 = 0 ;
3371 char * kwnames[] = {
3372 (char *) "self",(char *) "handler", NULL
3373 };
3374
3375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_InsertHandler",kwnames,&obj0,&obj1)) SWIG_fail;
3376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3377 if (!SWIG_IsOK(res1)) {
3378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_InsertHandler" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3379 }
3380 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3381 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
3382 if (!SWIG_IsOK(res2)) {
3383 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_InsertHandler" "', expected argument " "2"" of type '" "wxPyXmlResourceHandler *""'");
3384 }
3385 arg2 = reinterpret_cast< wxPyXmlResourceHandler * >(argp2);
3386 {
3387 PyThreadState* __tstate = wxPyBeginAllowThreads();
3388 (arg1)->InsertHandler(arg2);
3389 wxPyEndAllowThreads(__tstate);
3390 if (PyErr_Occurred()) SWIG_fail;
3391 }
3392 resultobj = SWIG_Py_Void();
3393 return resultobj;
3394 fail:
3395 return NULL;
3396 }
3397
3398
3399 SWIGINTERN PyObject *_wrap_XmlResource_ClearHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3400 PyObject *resultobj = 0;
3401 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3402 void *argp1 = 0 ;
3403 int res1 = 0 ;
3404 PyObject *swig_obj[1] ;
3405
3406 if (!args) SWIG_fail;
3407 swig_obj[0] = args;
3408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3409 if (!SWIG_IsOK(res1)) {
3410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_ClearHandlers" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3411 }
3412 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3413 {
3414 PyThreadState* __tstate = wxPyBeginAllowThreads();
3415 (arg1)->ClearHandlers();
3416 wxPyEndAllowThreads(__tstate);
3417 if (PyErr_Occurred()) SWIG_fail;
3418 }
3419 resultobj = SWIG_Py_Void();
3420 return resultobj;
3421 fail:
3422 return NULL;
3423 }
3424
3425
3426 SWIGINTERN PyObject *_wrap_XmlResource_AddSubclassFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3427 PyObject *resultobj = 0;
3428 wxPyXmlSubclassFactory *arg1 = (wxPyXmlSubclassFactory *) 0 ;
3429 void *argp1 = 0 ;
3430 int res1 = 0 ;
3431 PyObject * obj0 = 0 ;
3432 char * kwnames[] = {
3433 (char *) "factory", NULL
3434 };
3435
3436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlResource_AddSubclassFactory",kwnames,&obj0)) SWIG_fail;
3437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlSubclassFactory, 0 | 0 );
3438 if (!SWIG_IsOK(res1)) {
3439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_AddSubclassFactory" "', expected argument " "1"" of type '" "wxPyXmlSubclassFactory *""'");
3440 }
3441 arg1 = reinterpret_cast< wxPyXmlSubclassFactory * >(argp1);
3442 {
3443 PyThreadState* __tstate = wxPyBeginAllowThreads();
3444 wxXmlResource::AddSubclassFactory(arg1);
3445 wxPyEndAllowThreads(__tstate);
3446 if (PyErr_Occurred()) SWIG_fail;
3447 }
3448 resultobj = SWIG_Py_Void();
3449 return resultobj;
3450 fail:
3451 return NULL;
3452 }
3453
3454
3455 SWIGINTERN PyObject *_wrap_XmlResource_LoadMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3456 PyObject *resultobj = 0;
3457 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3458 wxString *arg2 = 0 ;
3459 wxMenu *result = 0 ;
3460 void *argp1 = 0 ;
3461 int res1 = 0 ;
3462 bool temp2 = false ;
3463 PyObject * obj0 = 0 ;
3464 PyObject * obj1 = 0 ;
3465 char * kwnames[] = {
3466 (char *) "self",(char *) "name", NULL
3467 };
3468
3469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_LoadMenu",kwnames,&obj0,&obj1)) SWIG_fail;
3470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3471 if (!SWIG_IsOK(res1)) {
3472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadMenu" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3473 }
3474 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3475 {
3476 arg2 = wxString_in_helper(obj1);
3477 if (arg2 == NULL) SWIG_fail;
3478 temp2 = true;
3479 }
3480 {
3481 PyThreadState* __tstate = wxPyBeginAllowThreads();
3482 result = (wxMenu *)(arg1)->LoadMenu((wxString const &)*arg2);
3483 wxPyEndAllowThreads(__tstate);
3484 if (PyErr_Occurred()) SWIG_fail;
3485 }
3486 {
3487 resultobj = wxPyMake_wxObject(result, 0);
3488 }
3489 {
3490 if (temp2)
3491 delete arg2;
3492 }
3493 return resultobj;
3494 fail:
3495 {
3496 if (temp2)
3497 delete arg2;
3498 }
3499 return NULL;
3500 }
3501
3502
3503 SWIGINTERN PyObject *_wrap_XmlResource_LoadMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3504 PyObject *resultobj = 0;
3505 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3506 wxString *arg2 = 0 ;
3507 wxMenuBar *result = 0 ;
3508 void *argp1 = 0 ;
3509 int res1 = 0 ;
3510 bool temp2 = false ;
3511 PyObject * obj0 = 0 ;
3512 PyObject * obj1 = 0 ;
3513 char * kwnames[] = {
3514 (char *) "self",(char *) "name", NULL
3515 };
3516
3517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_LoadMenuBar",kwnames,&obj0,&obj1)) SWIG_fail;
3518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3519 if (!SWIG_IsOK(res1)) {
3520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadMenuBar" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3521 }
3522 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3523 {
3524 arg2 = wxString_in_helper(obj1);
3525 if (arg2 == NULL) SWIG_fail;
3526 temp2 = true;
3527 }
3528 {
3529 PyThreadState* __tstate = wxPyBeginAllowThreads();
3530 result = (wxMenuBar *)(arg1)->LoadMenuBar((wxString const &)*arg2);
3531 wxPyEndAllowThreads(__tstate);
3532 if (PyErr_Occurred()) SWIG_fail;
3533 }
3534 {
3535 resultobj = wxPyMake_wxObject(result, 0);
3536 }
3537 {
3538 if (temp2)
3539 delete arg2;
3540 }
3541 return resultobj;
3542 fail:
3543 {
3544 if (temp2)
3545 delete arg2;
3546 }
3547 return NULL;
3548 }
3549
3550
3551 SWIGINTERN PyObject *_wrap_XmlResource_LoadMenuBarOnFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3552 PyObject *resultobj = 0;
3553 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3554 wxWindow *arg2 = (wxWindow *) 0 ;
3555 wxString *arg3 = 0 ;
3556 wxMenuBar *result = 0 ;
3557 void *argp1 = 0 ;
3558 int res1 = 0 ;
3559 void *argp2 = 0 ;
3560 int res2 = 0 ;
3561 bool temp3 = false ;
3562 PyObject * obj0 = 0 ;
3563 PyObject * obj1 = 0 ;
3564 PyObject * obj2 = 0 ;
3565 char * kwnames[] = {
3566 (char *) "self",(char *) "parent",(char *) "name", NULL
3567 };
3568
3569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResource_LoadMenuBarOnFrame",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3571 if (!SWIG_IsOK(res1)) {
3572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadMenuBarOnFrame" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3573 }
3574 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3575 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
3576 if (!SWIG_IsOK(res2)) {
3577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadMenuBarOnFrame" "', expected argument " "2"" of type '" "wxWindow *""'");
3578 }
3579 arg2 = reinterpret_cast< wxWindow * >(argp2);
3580 {
3581 arg3 = wxString_in_helper(obj2);
3582 if (arg3 == NULL) SWIG_fail;
3583 temp3 = true;
3584 }
3585 {
3586 PyThreadState* __tstate = wxPyBeginAllowThreads();
3587 result = (wxMenuBar *)(arg1)->LoadMenuBar(arg2,(wxString const &)*arg3);
3588 wxPyEndAllowThreads(__tstate);
3589 if (PyErr_Occurred()) SWIG_fail;
3590 }
3591 {
3592 resultobj = wxPyMake_wxObject(result, 0);
3593 }
3594 {
3595 if (temp3)
3596 delete arg3;
3597 }
3598 return resultobj;
3599 fail:
3600 {
3601 if (temp3)
3602 delete arg3;
3603 }
3604 return NULL;
3605 }
3606
3607
3608 SWIGINTERN PyObject *_wrap_XmlResource_LoadToolBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3609 PyObject *resultobj = 0;
3610 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3611 wxWindow *arg2 = (wxWindow *) 0 ;
3612 wxString *arg3 = 0 ;
3613 wxToolBar *result = 0 ;
3614 void *argp1 = 0 ;
3615 int res1 = 0 ;
3616 void *argp2 = 0 ;
3617 int res2 = 0 ;
3618 bool temp3 = false ;
3619 PyObject * obj0 = 0 ;
3620 PyObject * obj1 = 0 ;
3621 PyObject * obj2 = 0 ;
3622 char * kwnames[] = {
3623 (char *) "self",(char *) "parent",(char *) "name", NULL
3624 };
3625
3626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResource_LoadToolBar",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3628 if (!SWIG_IsOK(res1)) {
3629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadToolBar" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3630 }
3631 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3632 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
3633 if (!SWIG_IsOK(res2)) {
3634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadToolBar" "', expected argument " "2"" of type '" "wxWindow *""'");
3635 }
3636 arg2 = reinterpret_cast< wxWindow * >(argp2);
3637 {
3638 arg3 = wxString_in_helper(obj2);
3639 if (arg3 == NULL) SWIG_fail;
3640 temp3 = true;
3641 }
3642 {
3643 PyThreadState* __tstate = wxPyBeginAllowThreads();
3644 result = (wxToolBar *)(arg1)->LoadToolBar(arg2,(wxString const &)*arg3);
3645 wxPyEndAllowThreads(__tstate);
3646 if (PyErr_Occurred()) SWIG_fail;
3647 }
3648 {
3649 resultobj = wxPyMake_wxObject(result, (bool)0);
3650 }
3651 {
3652 if (temp3)
3653 delete arg3;
3654 }
3655 return resultobj;
3656 fail:
3657 {
3658 if (temp3)
3659 delete arg3;
3660 }
3661 return NULL;
3662 }
3663
3664
3665 SWIGINTERN PyObject *_wrap_XmlResource_LoadDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3666 PyObject *resultobj = 0;
3667 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3668 wxWindow *arg2 = (wxWindow *) 0 ;
3669 wxString *arg3 = 0 ;
3670 wxDialog *result = 0 ;
3671 void *argp1 = 0 ;
3672 int res1 = 0 ;
3673 void *argp2 = 0 ;
3674 int res2 = 0 ;
3675 bool temp3 = false ;
3676 PyObject * obj0 = 0 ;
3677 PyObject * obj1 = 0 ;
3678 PyObject * obj2 = 0 ;
3679 char * kwnames[] = {
3680 (char *) "self",(char *) "parent",(char *) "name", NULL
3681 };
3682
3683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResource_LoadDialog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3685 if (!SWIG_IsOK(res1)) {
3686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadDialog" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3687 }
3688 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3689 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
3690 if (!SWIG_IsOK(res2)) {
3691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadDialog" "', expected argument " "2"" of type '" "wxWindow *""'");
3692 }
3693 arg2 = reinterpret_cast< wxWindow * >(argp2);
3694 {
3695 arg3 = wxString_in_helper(obj2);
3696 if (arg3 == NULL) SWIG_fail;
3697 temp3 = true;
3698 }
3699 {
3700 PyThreadState* __tstate = wxPyBeginAllowThreads();
3701 result = (wxDialog *)(arg1)->LoadDialog(arg2,(wxString const &)*arg3);
3702 wxPyEndAllowThreads(__tstate);
3703 if (PyErr_Occurred()) SWIG_fail;
3704 }
3705 {
3706 resultobj = wxPyMake_wxObject(result, (bool)0);
3707 }
3708 {
3709 if (temp3)
3710 delete arg3;
3711 }
3712 return resultobj;
3713 fail:
3714 {
3715 if (temp3)
3716 delete arg3;
3717 }
3718 return NULL;
3719 }
3720
3721
3722 SWIGINTERN PyObject *_wrap_XmlResource_LoadOnDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3723 PyObject *resultobj = 0;
3724 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3725 wxDialog *arg2 = (wxDialog *) 0 ;
3726 wxWindow *arg3 = (wxWindow *) 0 ;
3727 wxString *arg4 = 0 ;
3728 bool result;
3729 void *argp1 = 0 ;
3730 int res1 = 0 ;
3731 void *argp2 = 0 ;
3732 int res2 = 0 ;
3733 void *argp3 = 0 ;
3734 int res3 = 0 ;
3735 bool temp4 = false ;
3736 PyObject * obj0 = 0 ;
3737 PyObject * obj1 = 0 ;
3738 PyObject * obj2 = 0 ;
3739 PyObject * obj3 = 0 ;
3740 char * kwnames[] = {
3741 (char *) "self",(char *) "dlg",(char *) "parent",(char *) "name", NULL
3742 };
3743
3744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:XmlResource_LoadOnDialog",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3746 if (!SWIG_IsOK(res1)) {
3747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadOnDialog" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3748 }
3749 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3750 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDialog, 0 | 0 );
3751 if (!SWIG_IsOK(res2)) {
3752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadOnDialog" "', expected argument " "2"" of type '" "wxDialog *""'");
3753 }
3754 arg2 = reinterpret_cast< wxDialog * >(argp2);
3755 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
3756 if (!SWIG_IsOK(res3)) {
3757 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResource_LoadOnDialog" "', expected argument " "3"" of type '" "wxWindow *""'");
3758 }
3759 arg3 = reinterpret_cast< wxWindow * >(argp3);
3760 {
3761 arg4 = wxString_in_helper(obj3);
3762 if (arg4 == NULL) SWIG_fail;
3763 temp4 = true;
3764 }
3765 {
3766 PyThreadState* __tstate = wxPyBeginAllowThreads();
3767 result = (bool)(arg1)->LoadDialog(arg2,arg3,(wxString const &)*arg4);
3768 wxPyEndAllowThreads(__tstate);
3769 if (PyErr_Occurred()) SWIG_fail;
3770 }
3771 {
3772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3773 }
3774 {
3775 if (temp4)
3776 delete arg4;
3777 }
3778 return resultobj;
3779 fail:
3780 {
3781 if (temp4)
3782 delete arg4;
3783 }
3784 return NULL;
3785 }
3786
3787
3788 SWIGINTERN PyObject *_wrap_XmlResource_LoadPanel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3789 PyObject *resultobj = 0;
3790 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3791 wxWindow *arg2 = (wxWindow *) 0 ;
3792 wxString *arg3 = 0 ;
3793 wxPanel *result = 0 ;
3794 void *argp1 = 0 ;
3795 int res1 = 0 ;
3796 void *argp2 = 0 ;
3797 int res2 = 0 ;
3798 bool temp3 = false ;
3799 PyObject * obj0 = 0 ;
3800 PyObject * obj1 = 0 ;
3801 PyObject * obj2 = 0 ;
3802 char * kwnames[] = {
3803 (char *) "self",(char *) "parent",(char *) "name", NULL
3804 };
3805
3806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResource_LoadPanel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3808 if (!SWIG_IsOK(res1)) {
3809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadPanel" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3810 }
3811 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3812 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
3813 if (!SWIG_IsOK(res2)) {
3814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadPanel" "', expected argument " "2"" of type '" "wxWindow *""'");
3815 }
3816 arg2 = reinterpret_cast< wxWindow * >(argp2);
3817 {
3818 arg3 = wxString_in_helper(obj2);
3819 if (arg3 == NULL) SWIG_fail;
3820 temp3 = true;
3821 }
3822 {
3823 PyThreadState* __tstate = wxPyBeginAllowThreads();
3824 result = (wxPanel *)(arg1)->LoadPanel(arg2,(wxString const &)*arg3);
3825 wxPyEndAllowThreads(__tstate);
3826 if (PyErr_Occurred()) SWIG_fail;
3827 }
3828 {
3829 resultobj = wxPyMake_wxObject(result, (bool)0);
3830 }
3831 {
3832 if (temp3)
3833 delete arg3;
3834 }
3835 return resultobj;
3836 fail:
3837 {
3838 if (temp3)
3839 delete arg3;
3840 }
3841 return NULL;
3842 }
3843
3844
3845 SWIGINTERN PyObject *_wrap_XmlResource_LoadOnPanel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3846 PyObject *resultobj = 0;
3847 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3848 wxPanel *arg2 = (wxPanel *) 0 ;
3849 wxWindow *arg3 = (wxWindow *) 0 ;
3850 wxString *arg4 = 0 ;
3851 bool result;
3852 void *argp1 = 0 ;
3853 int res1 = 0 ;
3854 void *argp2 = 0 ;
3855 int res2 = 0 ;
3856 void *argp3 = 0 ;
3857 int res3 = 0 ;
3858 bool temp4 = false ;
3859 PyObject * obj0 = 0 ;
3860 PyObject * obj1 = 0 ;
3861 PyObject * obj2 = 0 ;
3862 PyObject * obj3 = 0 ;
3863 char * kwnames[] = {
3864 (char *) "self",(char *) "panel",(char *) "parent",(char *) "name", NULL
3865 };
3866
3867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:XmlResource_LoadOnPanel",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3869 if (!SWIG_IsOK(res1)) {
3870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadOnPanel" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3871 }
3872 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3873 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPanel, 0 | 0 );
3874 if (!SWIG_IsOK(res2)) {
3875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadOnPanel" "', expected argument " "2"" of type '" "wxPanel *""'");
3876 }
3877 arg2 = reinterpret_cast< wxPanel * >(argp2);
3878 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
3879 if (!SWIG_IsOK(res3)) {
3880 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResource_LoadOnPanel" "', expected argument " "3"" of type '" "wxWindow *""'");
3881 }
3882 arg3 = reinterpret_cast< wxWindow * >(argp3);
3883 {
3884 arg4 = wxString_in_helper(obj3);
3885 if (arg4 == NULL) SWIG_fail;
3886 temp4 = true;
3887 }
3888 {
3889 PyThreadState* __tstate = wxPyBeginAllowThreads();
3890 result = (bool)(arg1)->LoadPanel(arg2,arg3,(wxString const &)*arg4);
3891 wxPyEndAllowThreads(__tstate);
3892 if (PyErr_Occurred()) SWIG_fail;
3893 }
3894 {
3895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3896 }
3897 {
3898 if (temp4)
3899 delete arg4;
3900 }
3901 return resultobj;
3902 fail:
3903 {
3904 if (temp4)
3905 delete arg4;
3906 }
3907 return NULL;
3908 }
3909
3910
3911 SWIGINTERN PyObject *_wrap_XmlResource_LoadFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3912 PyObject *resultobj = 0;
3913 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3914 wxWindow *arg2 = (wxWindow *) 0 ;
3915 wxString *arg3 = 0 ;
3916 wxFrame *result = 0 ;
3917 void *argp1 = 0 ;
3918 int res1 = 0 ;
3919 void *argp2 = 0 ;
3920 int res2 = 0 ;
3921 bool temp3 = false ;
3922 PyObject * obj0 = 0 ;
3923 PyObject * obj1 = 0 ;
3924 PyObject * obj2 = 0 ;
3925 char * kwnames[] = {
3926 (char *) "self",(char *) "parent",(char *) "name", NULL
3927 };
3928
3929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResource_LoadFrame",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3931 if (!SWIG_IsOK(res1)) {
3932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadFrame" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3933 }
3934 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3935 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
3936 if (!SWIG_IsOK(res2)) {
3937 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadFrame" "', expected argument " "2"" of type '" "wxWindow *""'");
3938 }
3939 arg2 = reinterpret_cast< wxWindow * >(argp2);
3940 {
3941 arg3 = wxString_in_helper(obj2);
3942 if (arg3 == NULL) SWIG_fail;
3943 temp3 = true;
3944 }
3945 {
3946 PyThreadState* __tstate = wxPyBeginAllowThreads();
3947 result = (wxFrame *)(arg1)->LoadFrame(arg2,(wxString const &)*arg3);
3948 wxPyEndAllowThreads(__tstate);
3949 if (PyErr_Occurred()) SWIG_fail;
3950 }
3951 {
3952 resultobj = wxPyMake_wxObject(result, (bool)0);
3953 }
3954 {
3955 if (temp3)
3956 delete arg3;
3957 }
3958 return resultobj;
3959 fail:
3960 {
3961 if (temp3)
3962 delete arg3;
3963 }
3964 return NULL;
3965 }
3966
3967
3968 SWIGINTERN PyObject *_wrap_XmlResource_LoadOnFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3969 PyObject *resultobj = 0;
3970 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3971 wxFrame *arg2 = (wxFrame *) 0 ;
3972 wxWindow *arg3 = (wxWindow *) 0 ;
3973 wxString *arg4 = 0 ;
3974 bool result;
3975 void *argp1 = 0 ;
3976 int res1 = 0 ;
3977 void *argp2 = 0 ;
3978 int res2 = 0 ;
3979 void *argp3 = 0 ;
3980 int res3 = 0 ;
3981 bool temp4 = false ;
3982 PyObject * obj0 = 0 ;
3983 PyObject * obj1 = 0 ;
3984 PyObject * obj2 = 0 ;
3985 PyObject * obj3 = 0 ;
3986 char * kwnames[] = {
3987 (char *) "self",(char *) "frame",(char *) "parent",(char *) "name", NULL
3988 };
3989
3990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:XmlResource_LoadOnFrame",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3992 if (!SWIG_IsOK(res1)) {
3993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadOnFrame" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3994 }
3995 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3996 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
3997 if (!SWIG_IsOK(res2)) {
3998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadOnFrame" "', expected argument " "2"" of type '" "wxFrame *""'");
3999 }
4000 arg2 = reinterpret_cast< wxFrame * >(argp2);
4001 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
4002 if (!SWIG_IsOK(res3)) {
4003 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResource_LoadOnFrame" "', expected argument " "3"" of type '" "wxWindow *""'");
4004 }
4005 arg3 = reinterpret_cast< wxWindow * >(argp3);
4006 {
4007 arg4 = wxString_in_helper(obj3);
4008 if (arg4 == NULL) SWIG_fail;
4009 temp4 = true;
4010 }
4011 {
4012 PyThreadState* __tstate = wxPyBeginAllowThreads();
4013 result = (bool)(arg1)->LoadFrame(arg2,arg3,(wxString const &)*arg4);
4014 wxPyEndAllowThreads(__tstate);
4015 if (PyErr_Occurred()) SWIG_fail;
4016 }
4017 {
4018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4019 }
4020 {
4021 if (temp4)
4022 delete arg4;
4023 }
4024 return resultobj;
4025 fail:
4026 {
4027 if (temp4)
4028 delete arg4;
4029 }
4030 return NULL;
4031 }
4032
4033
4034 SWIGINTERN PyObject *_wrap_XmlResource_LoadObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4035 PyObject *resultobj = 0;
4036 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4037 wxWindow *arg2 = (wxWindow *) 0 ;
4038 wxString *arg3 = 0 ;
4039 wxString *arg4 = 0 ;
4040 wxObject *result = 0 ;
4041 void *argp1 = 0 ;
4042 int res1 = 0 ;
4043 void *argp2 = 0 ;
4044 int res2 = 0 ;
4045 bool temp3 = false ;
4046 bool temp4 = false ;
4047 PyObject * obj0 = 0 ;
4048 PyObject * obj1 = 0 ;
4049 PyObject * obj2 = 0 ;
4050 PyObject * obj3 = 0 ;
4051 char * kwnames[] = {
4052 (char *) "self",(char *) "parent",(char *) "name",(char *) "classname", NULL
4053 };
4054
4055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:XmlResource_LoadObject",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4057 if (!SWIG_IsOK(res1)) {
4058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadObject" "', expected argument " "1"" of type '" "wxXmlResource *""'");
4059 }
4060 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4061 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4062 if (!SWIG_IsOK(res2)) {
4063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadObject" "', expected argument " "2"" of type '" "wxWindow *""'");
4064 }
4065 arg2 = reinterpret_cast< wxWindow * >(argp2);
4066 {
4067 arg3 = wxString_in_helper(obj2);
4068 if (arg3 == NULL) SWIG_fail;
4069 temp3 = true;
4070 }
4071 {
4072 arg4 = wxString_in_helper(obj3);
4073 if (arg4 == NULL) SWIG_fail;
4074 temp4 = true;
4075 }
4076 {
4077 PyThreadState* __tstate = wxPyBeginAllowThreads();
4078 result = (wxObject *)(arg1)->LoadObject(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
4079 wxPyEndAllowThreads(__tstate);
4080 if (PyErr_Occurred()) SWIG_fail;
4081 }
4082 {
4083 resultobj = wxPyMake_wxObject(result, (bool)0);
4084 }
4085 {
4086 if (temp3)
4087 delete arg3;
4088 }
4089 {
4090 if (temp4)
4091 delete arg4;
4092 }
4093 return resultobj;
4094 fail:
4095 {
4096 if (temp3)
4097 delete arg3;
4098 }
4099 {
4100 if (temp4)
4101 delete arg4;
4102 }
4103 return NULL;
4104 }
4105
4106
4107 SWIGINTERN PyObject *_wrap_XmlResource_LoadOnObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4108 PyObject *resultobj = 0;
4109 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4110 wxObject *arg2 = (wxObject *) 0 ;
4111 wxWindow *arg3 = (wxWindow *) 0 ;
4112 wxString *arg4 = 0 ;
4113 wxString *arg5 = 0 ;
4114 bool result;
4115 void *argp1 = 0 ;
4116 int res1 = 0 ;
4117 void *argp2 = 0 ;
4118 int res2 = 0 ;
4119 void *argp3 = 0 ;
4120 int res3 = 0 ;
4121 bool temp4 = false ;
4122 bool temp5 = false ;
4123 PyObject * obj0 = 0 ;
4124 PyObject * obj1 = 0 ;
4125 PyObject * obj2 = 0 ;
4126 PyObject * obj3 = 0 ;
4127 PyObject * obj4 = 0 ;
4128 char * kwnames[] = {
4129 (char *) "self",(char *) "instance",(char *) "parent",(char *) "name",(char *) "classname", NULL
4130 };
4131
4132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:XmlResource_LoadOnObject",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
4133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4134 if (!SWIG_IsOK(res1)) {
4135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadOnObject" "', expected argument " "1"" of type '" "wxXmlResource *""'");
4136 }
4137 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4138 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
4139 if (!SWIG_IsOK(res2)) {
4140 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadOnObject" "', expected argument " "2"" of type '" "wxObject *""'");
4141 }
4142 arg2 = reinterpret_cast< wxObject * >(argp2);
4143 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
4144 if (!SWIG_IsOK(res3)) {
4145 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResource_LoadOnObject" "', expected argument " "3"" of type '" "wxWindow *""'");
4146 }
4147 arg3 = reinterpret_cast< wxWindow * >(argp3);
4148 {
4149 arg4 = wxString_in_helper(obj3);
4150 if (arg4 == NULL) SWIG_fail;
4151 temp4 = true;
4152 }
4153 {
4154 arg5 = wxString_in_helper(obj4);
4155 if (arg5 == NULL) SWIG_fail;
4156 temp5 = true;
4157 }
4158 {
4159 PyThreadState* __tstate = wxPyBeginAllowThreads();
4160 result = (bool)(arg1)->LoadObject(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
4161 wxPyEndAllowThreads(__tstate);
4162 if (PyErr_Occurred()) SWIG_fail;
4163 }
4164 {
4165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4166 }
4167 {
4168 if (temp4)
4169 delete arg4;
4170 }
4171 {
4172 if (temp5)
4173 delete arg5;
4174 }
4175 return resultobj;
4176 fail:
4177 {
4178 if (temp4)
4179 delete arg4;
4180 }
4181 {
4182 if (temp5)
4183 delete arg5;
4184 }
4185 return NULL;
4186 }
4187
4188
4189 SWIGINTERN PyObject *_wrap_XmlResource_LoadBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4190 PyObject *resultobj = 0;
4191 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4192 wxString *arg2 = 0 ;
4193 wxBitmap result;
4194 void *argp1 = 0 ;
4195 int res1 = 0 ;
4196 bool temp2 = false ;
4197 PyObject * obj0 = 0 ;
4198 PyObject * obj1 = 0 ;
4199 char * kwnames[] = {
4200 (char *) "self",(char *) "name", NULL
4201 };
4202
4203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_LoadBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
4204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4205 if (!SWIG_IsOK(res1)) {
4206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadBitmap" "', expected argument " "1"" of type '" "wxXmlResource *""'");
4207 }
4208 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4209 {
4210 arg2 = wxString_in_helper(obj1);
4211 if (arg2 == NULL) SWIG_fail;
4212 temp2 = true;
4213 }
4214 {
4215 PyThreadState* __tstate = wxPyBeginAllowThreads();
4216 result = (arg1)->LoadBitmap((wxString const &)*arg2);
4217 wxPyEndAllowThreads(__tstate);
4218 if (PyErr_Occurred()) SWIG_fail;
4219 }
4220 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
4221 {
4222 if (temp2)
4223 delete arg2;
4224 }
4225 return resultobj;
4226 fail:
4227 {
4228 if (temp2)
4229 delete arg2;
4230 }
4231 return NULL;
4232 }
4233
4234
4235 SWIGINTERN PyObject *_wrap_XmlResource_LoadIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4236 PyObject *resultobj = 0;
4237 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4238 wxString *arg2 = 0 ;
4239 wxIcon result;
4240 void *argp1 = 0 ;
4241 int res1 = 0 ;
4242 bool temp2 = false ;
4243 PyObject * obj0 = 0 ;
4244 PyObject * obj1 = 0 ;
4245 char * kwnames[] = {
4246 (char *) "self",(char *) "name", NULL
4247 };
4248
4249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_LoadIcon",kwnames,&obj0,&obj1)) SWIG_fail;
4250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4251 if (!SWIG_IsOK(res1)) {
4252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadIcon" "', expected argument " "1"" of type '" "wxXmlResource *""'");
4253 }
4254 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4255 {
4256 arg2 = wxString_in_helper(obj1);
4257 if (arg2 == NULL) SWIG_fail;
4258 temp2 = true;
4259 }
4260 {
4261 PyThreadState* __tstate = wxPyBeginAllowThreads();
4262 result = (arg1)->LoadIcon((wxString const &)*arg2);
4263 wxPyEndAllowThreads(__tstate);
4264 if (PyErr_Occurred()) SWIG_fail;
4265 }
4266 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
4267 {
4268 if (temp2)
4269 delete arg2;
4270 }
4271 return resultobj;
4272 fail:
4273 {
4274 if (temp2)
4275 delete arg2;
4276 }
4277 return NULL;
4278 }
4279
4280
4281 SWIGINTERN PyObject *_wrap_XmlResource_AttachUnknownControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4282 PyObject *resultobj = 0;
4283 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4284 wxString *arg2 = 0 ;
4285 wxWindow *arg3 = (wxWindow *) 0 ;
4286 wxWindow *arg4 = (wxWindow *) NULL ;
4287 bool result;
4288 void *argp1 = 0 ;
4289 int res1 = 0 ;
4290 bool temp2 = false ;
4291 void *argp3 = 0 ;
4292 int res3 = 0 ;
4293 void *argp4 = 0 ;
4294 int res4 = 0 ;
4295 PyObject * obj0 = 0 ;
4296 PyObject * obj1 = 0 ;
4297 PyObject * obj2 = 0 ;
4298 PyObject * obj3 = 0 ;
4299 char * kwnames[] = {
4300 (char *) "self",(char *) "name",(char *) "control",(char *) "parent", NULL
4301 };
4302
4303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:XmlResource_AttachUnknownControl",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4305 if (!SWIG_IsOK(res1)) {
4306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_AttachUnknownControl" "', expected argument " "1"" of type '" "wxXmlResource *""'");
4307 }
4308 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4309 {
4310 arg2 = wxString_in_helper(obj1);
4311 if (arg2 == NULL) SWIG_fail;
4312 temp2 = true;
4313 }
4314 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
4315 if (!SWIG_IsOK(res3)) {
4316 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResource_AttachUnknownControl" "', expected argument " "3"" of type '" "wxWindow *""'");
4317 }
4318 arg3 = reinterpret_cast< wxWindow * >(argp3);
4319 if (obj3) {
4320 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
4321 if (!SWIG_IsOK(res4)) {
4322 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "XmlResource_AttachUnknownControl" "', expected argument " "4"" of type '" "wxWindow *""'");
4323 }
4324 arg4 = reinterpret_cast< wxWindow * >(argp4);
4325 }
4326 {
4327 PyThreadState* __tstate = wxPyBeginAllowThreads();
4328 result = (bool)(arg1)->AttachUnknownControl((wxString const &)*arg2,arg3,arg4);
4329 wxPyEndAllowThreads(__tstate);
4330 if (PyErr_Occurred()) SWIG_fail;
4331 }
4332 {
4333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4334 }
4335 {
4336 if (temp2)
4337 delete arg2;
4338 }
4339 return resultobj;
4340 fail:
4341 {
4342 if (temp2)
4343 delete arg2;
4344 }
4345 return NULL;
4346 }
4347
4348
4349 SWIGINTERN PyObject *_wrap_XmlResource_GetXRCID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4350 PyObject *resultobj = 0;
4351 wxString *arg1 = 0 ;
4352 int arg2 = (int) wxID_NONE ;
4353 int result;
4354 bool temp1 = false ;
4355 int val2 ;
4356 int ecode2 = 0 ;
4357 PyObject * obj0 = 0 ;
4358 PyObject * obj1 = 0 ;
4359 char * kwnames[] = {
4360 (char *) "str_id",(char *) "value_if_not_found", NULL
4361 };
4362
4363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:XmlResource_GetXRCID",kwnames,&obj0,&obj1)) SWIG_fail;
4364 {
4365 arg1 = wxString_in_helper(obj0);
4366 if (arg1 == NULL) SWIG_fail;
4367 temp1 = true;
4368 }
4369 if (obj1) {
4370 ecode2 = SWIG_AsVal_int(obj1, &val2);
4371 if (!SWIG_IsOK(ecode2)) {
4372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XmlResource_GetXRCID" "', expected argument " "2"" of type '" "int""'");
4373 }
4374 arg2 = static_cast< int >(val2);
4375 }
4376 {
4377 PyThreadState* __tstate = wxPyBeginAllowThreads();
4378 result = (int)wxXmlResource::GetXRCID((wxString const &)*arg1,arg2);
4379 wxPyEndAllowThreads(__tstate);
4380 if (PyErr_Occurred()) SWIG_fail;
4381 }
4382 resultobj = SWIG_From_int(static_cast< int >(result));
4383 {
4384 if (temp1)
4385 delete arg1;
4386 }
4387 return resultobj;
4388 fail:
4389 {
4390 if (temp1)
4391 delete arg1;
4392 }
4393 return NULL;
4394 }
4395
4396
4397 SWIGINTERN PyObject *_wrap_XmlResource_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4398 PyObject *resultobj = 0;
4399 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4400 long result;
4401 void *argp1 = 0 ;
4402 int res1 = 0 ;
4403 PyObject *swig_obj[1] ;
4404
4405 if (!args) SWIG_fail;
4406 swig_obj[0] = args;
4407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4408 if (!SWIG_IsOK(res1)) {
4409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_GetVersion" "', expected argument " "1"" of type '" "wxXmlResource const *""'");
4410 }
4411 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4412 {
4413 PyThreadState* __tstate = wxPyBeginAllowThreads();
4414 result = (long)((wxXmlResource const *)arg1)->GetVersion();
4415 wxPyEndAllowThreads(__tstate);
4416 if (PyErr_Occurred()) SWIG_fail;
4417 }
4418 resultobj = SWIG_From_long(static_cast< long >(result));
4419 return resultobj;
4420 fail:
4421 return NULL;
4422 }
4423
4424
4425 SWIGINTERN PyObject *_wrap_XmlResource_CompareVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4426 PyObject *resultobj = 0;
4427 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4428 int arg2 ;
4429 int arg3 ;
4430 int arg4 ;
4431 int arg5 ;
4432 int result;
4433 void *argp1 = 0 ;
4434 int res1 = 0 ;
4435 int val2 ;
4436 int ecode2 = 0 ;
4437 int val3 ;
4438 int ecode3 = 0 ;
4439 int val4 ;
4440 int ecode4 = 0 ;
4441 int val5 ;
4442 int ecode5 = 0 ;
4443 PyObject * obj0 = 0 ;
4444 PyObject * obj1 = 0 ;
4445 PyObject * obj2 = 0 ;
4446 PyObject * obj3 = 0 ;
4447 PyObject * obj4 = 0 ;
4448 char * kwnames[] = {
4449 (char *) "self",(char *) "major",(char *) "minor",(char *) "release",(char *) "revision", NULL
4450 };
4451
4452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:XmlResource_CompareVersion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
4453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4454 if (!SWIG_IsOK(res1)) {
4455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_CompareVersion" "', expected argument " "1"" of type '" "wxXmlResource const *""'");
4456 }
4457 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4458 ecode2 = SWIG_AsVal_int(obj1, &val2);
4459 if (!SWIG_IsOK(ecode2)) {
4460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XmlResource_CompareVersion" "', expected argument " "2"" of type '" "int""'");
4461 }
4462 arg2 = static_cast< int >(val2);
4463 ecode3 = SWIG_AsVal_int(obj2, &val3);
4464 if (!SWIG_IsOK(ecode3)) {
4465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XmlResource_CompareVersion" "', expected argument " "3"" of type '" "int""'");
4466 }
4467 arg3 = static_cast< int >(val3);
4468 ecode4 = SWIG_AsVal_int(obj3, &val4);
4469 if (!SWIG_IsOK(ecode4)) {
4470 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XmlResource_CompareVersion" "', expected argument " "4"" of type '" "int""'");
4471 }
4472 arg4 = static_cast< int >(val4);
4473 ecode5 = SWIG_AsVal_int(obj4, &val5);
4474 if (!SWIG_IsOK(ecode5)) {
4475 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XmlResource_CompareVersion" "', expected argument " "5"" of type '" "int""'");
4476 }
4477 arg5 = static_cast< int >(val5);
4478 {
4479 PyThreadState* __tstate = wxPyBeginAllowThreads();
4480 result = (int)((wxXmlResource const *)arg1)->CompareVersion(arg2,arg3,arg4,arg5);
4481 wxPyEndAllowThreads(__tstate);
4482 if (PyErr_Occurred()) SWIG_fail;
4483 }
4484 resultobj = SWIG_From_int(static_cast< int >(result));
4485 return resultobj;
4486 fail:
4487 return NULL;
4488 }
4489
4490
4491 SWIGINTERN PyObject *_wrap_XmlResource_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4492 PyObject *resultobj = 0;
4493 wxXmlResource *result = 0 ;
4494
4495 if (!SWIG_Python_UnpackTuple(args,"XmlResource_Get",0,0,0)) SWIG_fail;
4496 {
4497 PyThreadState* __tstate = wxPyBeginAllowThreads();
4498 result = (wxXmlResource *)wxXmlResource::Get();
4499 wxPyEndAllowThreads(__tstate);
4500 if (PyErr_Occurred()) SWIG_fail;
4501 }
4502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlResource, 0 | 0 );
4503 return resultobj;
4504 fail:
4505 return NULL;
4506 }
4507
4508
4509 SWIGINTERN PyObject *_wrap_XmlResource_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4510 PyObject *resultobj = 0;
4511 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4512 wxXmlResource *result = 0 ;
4513 void *argp1 = 0 ;
4514 int res1 = 0 ;
4515 PyObject * obj0 = 0 ;
4516 char * kwnames[] = {
4517 (char *) "res", NULL
4518 };
4519
4520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlResource_Set",kwnames,&obj0)) SWIG_fail;
4521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4522 if (!SWIG_IsOK(res1)) {
4523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_Set" "', expected argument " "1"" of type '" "wxXmlResource *""'");
4524 }
4525 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4526 {
4527 PyThreadState* __tstate = wxPyBeginAllowThreads();
4528 result = (wxXmlResource *)wxXmlResource::Set(arg1);
4529 wxPyEndAllowThreads(__tstate);
4530 if (PyErr_Occurred()) SWIG_fail;
4531 }
4532 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlResource, 0 | 0 );
4533 return resultobj;
4534 fail:
4535 return NULL;
4536 }
4537
4538
4539 SWIGINTERN PyObject *_wrap_XmlResource_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4540 PyObject *resultobj = 0;
4541 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4542 int result;
4543 void *argp1 = 0 ;
4544 int res1 = 0 ;
4545 PyObject *swig_obj[1] ;
4546
4547 if (!args) SWIG_fail;
4548 swig_obj[0] = args;
4549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4550 if (!SWIG_IsOK(res1)) {
4551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_GetFlags" "', expected argument " "1"" of type '" "wxXmlResource *""'");
4552 }
4553 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4554 {
4555 PyThreadState* __tstate = wxPyBeginAllowThreads();
4556 result = (int)(arg1)->GetFlags();
4557 wxPyEndAllowThreads(__tstate);
4558 if (PyErr_Occurred()) SWIG_fail;
4559 }
4560 resultobj = SWIG_From_int(static_cast< int >(result));
4561 return resultobj;
4562 fail:
4563 return NULL;
4564 }
4565
4566
4567 SWIGINTERN PyObject *_wrap_XmlResource_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4568 PyObject *resultobj = 0;
4569 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4570 int arg2 ;
4571 void *argp1 = 0 ;
4572 int res1 = 0 ;
4573 int val2 ;
4574 int ecode2 = 0 ;
4575 PyObject * obj0 = 0 ;
4576 PyObject * obj1 = 0 ;
4577 char * kwnames[] = {
4578 (char *) "self",(char *) "flags", NULL
4579 };
4580
4581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
4582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4583 if (!SWIG_IsOK(res1)) {
4584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_SetFlags" "', expected argument " "1"" of type '" "wxXmlResource *""'");
4585 }
4586 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4587 ecode2 = SWIG_AsVal_int(obj1, &val2);
4588 if (!SWIG_IsOK(ecode2)) {
4589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XmlResource_SetFlags" "', expected argument " "2"" of type '" "int""'");
4590 }
4591 arg2 = static_cast< int >(val2);
4592 {
4593 PyThreadState* __tstate = wxPyBeginAllowThreads();
4594 (arg1)->SetFlags(arg2);
4595 wxPyEndAllowThreads(__tstate);
4596 if (PyErr_Occurred()) SWIG_fail;
4597 }
4598 resultobj = SWIG_Py_Void();
4599 return resultobj;
4600 fail:
4601 return NULL;
4602 }
4603
4604
4605 SWIGINTERN PyObject *XmlResource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4606 PyObject *obj;
4607 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4608 SWIG_TypeNewClientData(SWIGTYPE_p_wxXmlResource, SWIG_NewClientData(obj));
4609 return SWIG_Py_Void();
4610 }
4611
4612 SWIGINTERN PyObject *XmlResource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4613 return SWIG_Python_InitShadowInstance(args);
4614 }
4615
4616 SWIGINTERN PyObject *_wrap_new_XmlSubclassFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4617 PyObject *resultobj = 0;
4618 wxPyXmlSubclassFactory *result = 0 ;
4619
4620 if (!SWIG_Python_UnpackTuple(args,"new_XmlSubclassFactory",0,0,0)) SWIG_fail;
4621 {
4622 PyThreadState* __tstate = wxPyBeginAllowThreads();
4623 result = (wxPyXmlSubclassFactory *)new wxPyXmlSubclassFactory();
4624 wxPyEndAllowThreads(__tstate);
4625 if (PyErr_Occurred()) SWIG_fail;
4626 }
4627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyXmlSubclassFactory, SWIG_POINTER_NEW | 0 );
4628 return resultobj;
4629 fail:
4630 return NULL;
4631 }
4632
4633
4634 SWIGINTERN PyObject *_wrap_XmlSubclassFactory__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4635 PyObject *resultobj = 0;
4636 wxPyXmlSubclassFactory *arg1 = (wxPyXmlSubclassFactory *) 0 ;
4637 PyObject *arg2 = (PyObject *) 0 ;
4638 PyObject *arg3 = (PyObject *) 0 ;
4639 void *argp1 = 0 ;
4640 int res1 = 0 ;
4641 PyObject * obj0 = 0 ;
4642 PyObject * obj1 = 0 ;
4643 PyObject * obj2 = 0 ;
4644 char * kwnames[] = {
4645 (char *) "self",(char *) "self",(char *) "_class", NULL
4646 };
4647
4648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlSubclassFactory__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlSubclassFactory, 0 | 0 );
4650 if (!SWIG_IsOK(res1)) {
4651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlSubclassFactory__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyXmlSubclassFactory *""'");
4652 }
4653 arg1 = reinterpret_cast< wxPyXmlSubclassFactory * >(argp1);
4654 arg2 = obj1;
4655 arg3 = obj2;
4656 {
4657 PyThreadState* __tstate = wxPyBeginAllowThreads();
4658 (arg1)->_setCallbackInfo(arg2,arg3);
4659 wxPyEndAllowThreads(__tstate);
4660 if (PyErr_Occurred()) SWIG_fail;
4661 }
4662 resultobj = SWIG_Py_Void();
4663 return resultobj;
4664 fail:
4665 return NULL;
4666 }
4667
4668
4669 SWIGINTERN PyObject *XmlSubclassFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4670 PyObject *obj;
4671 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4672 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyXmlSubclassFactory, SWIG_NewClientData(obj));
4673 return SWIG_Py_Void();
4674 }
4675
4676 SWIGINTERN PyObject *XmlSubclassFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4677 return SWIG_Python_InitShadowInstance(args);
4678 }
4679
4680 SWIGINTERN PyObject *_wrap_new_XmlProperty(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4681 PyObject *resultobj = 0;
4682 wxString const &arg1_defvalue = wxPyEmptyString ;
4683 wxString *arg1 = (wxString *) &arg1_defvalue ;
4684 wxString const &arg2_defvalue = wxPyEmptyString ;
4685 wxString *arg2 = (wxString *) &arg2_defvalue ;
4686 wxXmlProperty *arg3 = (wxXmlProperty *) NULL ;
4687 wxXmlProperty *result = 0 ;
4688 bool temp1 = false ;
4689 bool temp2 = false ;
4690 void *argp3 = 0 ;
4691 int res3 = 0 ;
4692 PyObject * obj0 = 0 ;
4693 PyObject * obj1 = 0 ;
4694 PyObject * obj2 = 0 ;
4695 char * kwnames[] = {
4696 (char *) "name",(char *) "value",(char *) "next", NULL
4697 };
4698
4699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_XmlProperty",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4700 if (obj0) {
4701 {
4702 arg1 = wxString_in_helper(obj0);
4703 if (arg1 == NULL) SWIG_fail;
4704 temp1 = true;
4705 }
4706 }
4707 if (obj1) {
4708 {
4709 arg2 = wxString_in_helper(obj1);
4710 if (arg2 == NULL) SWIG_fail;
4711 temp2 = true;
4712 }
4713 }
4714 if (obj2) {
4715 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4716 if (!SWIG_IsOK(res3)) {
4717 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_XmlProperty" "', expected argument " "3"" of type '" "wxXmlProperty *""'");
4718 }
4719 arg3 = reinterpret_cast< wxXmlProperty * >(argp3);
4720 }
4721 {
4722 PyThreadState* __tstate = wxPyBeginAllowThreads();
4723 result = (wxXmlProperty *)new wxXmlProperty((wxString const &)*arg1,(wxString const &)*arg2,arg3);
4724 wxPyEndAllowThreads(__tstate);
4725 if (PyErr_Occurred()) SWIG_fail;
4726 }
4727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlProperty, SWIG_POINTER_NEW | 0 );
4728 {
4729 if (temp1)
4730 delete arg1;
4731 }
4732 {
4733 if (temp2)
4734 delete arg2;
4735 }
4736 return resultobj;
4737 fail:
4738 {
4739 if (temp1)
4740 delete arg1;
4741 }
4742 {
4743 if (temp2)
4744 delete arg2;
4745 }
4746 return NULL;
4747 }
4748
4749
4750 SWIGINTERN PyObject *_wrap_XmlProperty_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4751 PyObject *resultobj = 0;
4752 wxXmlProperty *arg1 = (wxXmlProperty *) 0 ;
4753 wxString result;
4754 void *argp1 = 0 ;
4755 int res1 = 0 ;
4756 PyObject *swig_obj[1] ;
4757
4758 if (!args) SWIG_fail;
4759 swig_obj[0] = args;
4760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4761 if (!SWIG_IsOK(res1)) {
4762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlProperty_GetName" "', expected argument " "1"" of type '" "wxXmlProperty const *""'");
4763 }
4764 arg1 = reinterpret_cast< wxXmlProperty * >(argp1);
4765 {
4766 PyThreadState* __tstate = wxPyBeginAllowThreads();
4767 result = ((wxXmlProperty const *)arg1)->GetName();
4768 wxPyEndAllowThreads(__tstate);
4769 if (PyErr_Occurred()) SWIG_fail;
4770 }
4771 {
4772 #if wxUSE_UNICODE
4773 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4774 #else
4775 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4776 #endif
4777 }
4778 return resultobj;
4779 fail:
4780 return NULL;
4781 }
4782
4783
4784 SWIGINTERN PyObject *_wrap_XmlProperty_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4785 PyObject *resultobj = 0;
4786 wxXmlProperty *arg1 = (wxXmlProperty *) 0 ;
4787 wxString result;
4788 void *argp1 = 0 ;
4789 int res1 = 0 ;
4790 PyObject *swig_obj[1] ;
4791
4792 if (!args) SWIG_fail;
4793 swig_obj[0] = args;
4794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4795 if (!SWIG_IsOK(res1)) {
4796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlProperty_GetValue" "', expected argument " "1"" of type '" "wxXmlProperty const *""'");
4797 }
4798 arg1 = reinterpret_cast< wxXmlProperty * >(argp1);
4799 {
4800 PyThreadState* __tstate = wxPyBeginAllowThreads();
4801 result = ((wxXmlProperty const *)arg1)->GetValue();
4802 wxPyEndAllowThreads(__tstate);
4803 if (PyErr_Occurred()) SWIG_fail;
4804 }
4805 {
4806 #if wxUSE_UNICODE
4807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4808 #else
4809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4810 #endif
4811 }
4812 return resultobj;
4813 fail:
4814 return NULL;
4815 }
4816
4817
4818 SWIGINTERN PyObject *_wrap_XmlProperty_GetNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4819 PyObject *resultobj = 0;
4820 wxXmlProperty *arg1 = (wxXmlProperty *) 0 ;
4821 wxXmlProperty *result = 0 ;
4822 void *argp1 = 0 ;
4823 int res1 = 0 ;
4824 PyObject *swig_obj[1] ;
4825
4826 if (!args) SWIG_fail;
4827 swig_obj[0] = args;
4828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4829 if (!SWIG_IsOK(res1)) {
4830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlProperty_GetNext" "', expected argument " "1"" of type '" "wxXmlProperty const *""'");
4831 }
4832 arg1 = reinterpret_cast< wxXmlProperty * >(argp1);
4833 {
4834 PyThreadState* __tstate = wxPyBeginAllowThreads();
4835 result = (wxXmlProperty *)((wxXmlProperty const *)arg1)->GetNext();
4836 wxPyEndAllowThreads(__tstate);
4837 if (PyErr_Occurred()) SWIG_fail;
4838 }
4839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4840 return resultobj;
4841 fail:
4842 return NULL;
4843 }
4844
4845
4846 SWIGINTERN PyObject *_wrap_XmlProperty_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4847 PyObject *resultobj = 0;
4848 wxXmlProperty *arg1 = (wxXmlProperty *) 0 ;
4849 wxString *arg2 = 0 ;
4850 void *argp1 = 0 ;
4851 int res1 = 0 ;
4852 bool temp2 = false ;
4853 PyObject * obj0 = 0 ;
4854 PyObject * obj1 = 0 ;
4855 char * kwnames[] = {
4856 (char *) "self",(char *) "name", NULL
4857 };
4858
4859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlProperty_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
4860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4861 if (!SWIG_IsOK(res1)) {
4862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlProperty_SetName" "', expected argument " "1"" of type '" "wxXmlProperty *""'");
4863 }
4864 arg1 = reinterpret_cast< wxXmlProperty * >(argp1);
4865 {
4866 arg2 = wxString_in_helper(obj1);
4867 if (arg2 == NULL) SWIG_fail;
4868 temp2 = true;
4869 }
4870 {
4871 PyThreadState* __tstate = wxPyBeginAllowThreads();
4872 (arg1)->SetName((wxString const &)*arg2);
4873 wxPyEndAllowThreads(__tstate);
4874 if (PyErr_Occurred()) SWIG_fail;
4875 }
4876 resultobj = SWIG_Py_Void();
4877 {
4878 if (temp2)
4879 delete arg2;
4880 }
4881 return resultobj;
4882 fail:
4883 {
4884 if (temp2)
4885 delete arg2;
4886 }
4887 return NULL;
4888 }
4889
4890
4891 SWIGINTERN PyObject *_wrap_XmlProperty_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4892 PyObject *resultobj = 0;
4893 wxXmlProperty *arg1 = (wxXmlProperty *) 0 ;
4894 wxString *arg2 = 0 ;
4895 void *argp1 = 0 ;
4896 int res1 = 0 ;
4897 bool temp2 = false ;
4898 PyObject * obj0 = 0 ;
4899 PyObject * obj1 = 0 ;
4900 char * kwnames[] = {
4901 (char *) "self",(char *) "value", NULL
4902 };
4903
4904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlProperty_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
4905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4906 if (!SWIG_IsOK(res1)) {
4907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlProperty_SetValue" "', expected argument " "1"" of type '" "wxXmlProperty *""'");
4908 }
4909 arg1 = reinterpret_cast< wxXmlProperty * >(argp1);
4910 {
4911 arg2 = wxString_in_helper(obj1);
4912 if (arg2 == NULL) SWIG_fail;
4913 temp2 = true;
4914 }
4915 {
4916 PyThreadState* __tstate = wxPyBeginAllowThreads();
4917 (arg1)->SetValue((wxString const &)*arg2);
4918 wxPyEndAllowThreads(__tstate);
4919 if (PyErr_Occurred()) SWIG_fail;
4920 }
4921 resultobj = SWIG_Py_Void();
4922 {
4923 if (temp2)
4924 delete arg2;
4925 }
4926 return resultobj;
4927 fail:
4928 {
4929 if (temp2)
4930 delete arg2;
4931 }
4932 return NULL;
4933 }
4934
4935
4936 SWIGINTERN PyObject *_wrap_XmlProperty_SetNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4937 PyObject *resultobj = 0;
4938 wxXmlProperty *arg1 = (wxXmlProperty *) 0 ;
4939 wxXmlProperty *arg2 = (wxXmlProperty *) 0 ;
4940 void *argp1 = 0 ;
4941 int res1 = 0 ;
4942 void *argp2 = 0 ;
4943 int res2 = 0 ;
4944 PyObject * obj0 = 0 ;
4945 PyObject * obj1 = 0 ;
4946 char * kwnames[] = {
4947 (char *) "self",(char *) "next", NULL
4948 };
4949
4950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlProperty_SetNext",kwnames,&obj0,&obj1)) SWIG_fail;
4951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4952 if (!SWIG_IsOK(res1)) {
4953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlProperty_SetNext" "', expected argument " "1"" of type '" "wxXmlProperty *""'");
4954 }
4955 arg1 = reinterpret_cast< wxXmlProperty * >(argp1);
4956 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4957 if (!SWIG_IsOK(res2)) {
4958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlProperty_SetNext" "', expected argument " "2"" of type '" "wxXmlProperty *""'");
4959 }
4960 arg2 = reinterpret_cast< wxXmlProperty * >(argp2);
4961 {
4962 PyThreadState* __tstate = wxPyBeginAllowThreads();
4963 (arg1)->SetNext(arg2);
4964 wxPyEndAllowThreads(__tstate);
4965 if (PyErr_Occurred()) SWIG_fail;
4966 }
4967 resultobj = SWIG_Py_Void();
4968 return resultobj;
4969 fail:
4970 return NULL;
4971 }
4972
4973
4974 SWIGINTERN PyObject *XmlProperty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4975 PyObject *obj;
4976 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4977 SWIG_TypeNewClientData(SWIGTYPE_p_wxXmlProperty, SWIG_NewClientData(obj));
4978 return SWIG_Py_Void();
4979 }
4980
4981 SWIGINTERN PyObject *XmlProperty_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4982 return SWIG_Python_InitShadowInstance(args);
4983 }
4984
4985 SWIGINTERN PyObject *_wrap_new_XmlNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4986 PyObject *resultobj = 0;
4987 wxXmlNode *arg1 = (wxXmlNode *) NULL ;
4988 wxXmlNodeType arg2 = (wxXmlNodeType) 0 ;
4989 wxString const &arg3_defvalue = wxPyEmptyString ;
4990 wxString *arg3 = (wxString *) &arg3_defvalue ;
4991 wxString const &arg4_defvalue = wxPyEmptyString ;
4992 wxString *arg4 = (wxString *) &arg4_defvalue ;
4993 wxXmlProperty *arg5 = (wxXmlProperty *) NULL ;
4994 wxXmlNode *arg6 = (wxXmlNode *) NULL ;
4995 wxXmlNode *result = 0 ;
4996 void *argp1 = 0 ;
4997 int res1 = 0 ;
4998 int val2 ;
4999 int ecode2 = 0 ;
5000 bool temp3 = false ;
5001 bool temp4 = false ;
5002 void *argp5 = 0 ;
5003 int res5 = 0 ;
5004 void *argp6 = 0 ;
5005 int res6 = 0 ;
5006 PyObject * obj0 = 0 ;
5007 PyObject * obj1 = 0 ;
5008 PyObject * obj2 = 0 ;
5009 PyObject * obj3 = 0 ;
5010 PyObject * obj4 = 0 ;
5011 PyObject * obj5 = 0 ;
5012 char * kwnames[] = {
5013 (char *) "parent",(char *) "type",(char *) "name",(char *) "content",(char *) "props",(char *) "next", NULL
5014 };
5015
5016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_XmlNode",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5017 if (obj0) {
5018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5019 if (!SWIG_IsOK(res1)) {
5020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XmlNode" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5021 }
5022 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5023 }
5024 if (obj1) {
5025 ecode2 = SWIG_AsVal_int(obj1, &val2);
5026 if (!SWIG_IsOK(ecode2)) {
5027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XmlNode" "', expected argument " "2"" of type '" "wxXmlNodeType""'");
5028 }
5029 arg2 = static_cast< wxXmlNodeType >(val2);
5030 }
5031 if (obj2) {
5032 {
5033 arg3 = wxString_in_helper(obj2);
5034 if (arg3 == NULL) SWIG_fail;
5035 temp3 = true;
5036 }
5037 }
5038 if (obj3) {
5039 {
5040 arg4 = wxString_in_helper(obj3);
5041 if (arg4 == NULL) SWIG_fail;
5042 temp4 = true;
5043 }
5044 }
5045 if (obj4) {
5046 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
5047 if (!SWIG_IsOK(res5)) {
5048 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_XmlNode" "', expected argument " "5"" of type '" "wxXmlProperty *""'");
5049 }
5050 arg5 = reinterpret_cast< wxXmlProperty * >(argp5);
5051 }
5052 if (obj5) {
5053 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5054 if (!SWIG_IsOK(res6)) {
5055 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_XmlNode" "', expected argument " "6"" of type '" "wxXmlNode *""'");
5056 }
5057 arg6 = reinterpret_cast< wxXmlNode * >(argp6);
5058 }
5059 {
5060 PyThreadState* __tstate = wxPyBeginAllowThreads();
5061 result = (wxXmlNode *)new wxXmlNode(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
5062 wxPyEndAllowThreads(__tstate);
5063 if (PyErr_Occurred()) SWIG_fail;
5064 }
5065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlNode, SWIG_POINTER_NEW | 0 );
5066 {
5067 if (temp3)
5068 delete arg3;
5069 }
5070 {
5071 if (temp4)
5072 delete arg4;
5073 }
5074 return resultobj;
5075 fail:
5076 {
5077 if (temp3)
5078 delete arg3;
5079 }
5080 {
5081 if (temp4)
5082 delete arg4;
5083 }
5084 return NULL;
5085 }
5086
5087
5088 SWIGINTERN PyObject *_wrap_delete_XmlNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5089 PyObject *resultobj = 0;
5090 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5091 void *argp1 = 0 ;
5092 int res1 = 0 ;
5093 PyObject *swig_obj[1] ;
5094
5095 if (!args) SWIG_fail;
5096 swig_obj[0] = args;
5097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlNode, SWIG_POINTER_DISOWN | 0 );
5098 if (!SWIG_IsOK(res1)) {
5099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XmlNode" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5100 }
5101 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5102 {
5103 PyThreadState* __tstate = wxPyBeginAllowThreads();
5104 delete arg1;
5105
5106 wxPyEndAllowThreads(__tstate);
5107 if (PyErr_Occurred()) SWIG_fail;
5108 }
5109 resultobj = SWIG_Py_Void();
5110 return resultobj;
5111 fail:
5112 return NULL;
5113 }
5114
5115
5116 SWIGINTERN PyObject *_wrap_new_XmlNodeEasy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5117 PyObject *resultobj = 0;
5118 wxXmlNodeType arg1 ;
5119 wxString *arg2 = 0 ;
5120 wxString const &arg3_defvalue = wxPyEmptyString ;
5121 wxString *arg3 = (wxString *) &arg3_defvalue ;
5122 wxXmlNode *result = 0 ;
5123 int val1 ;
5124 int ecode1 = 0 ;
5125 bool temp2 = false ;
5126 bool temp3 = false ;
5127 PyObject * obj0 = 0 ;
5128 PyObject * obj1 = 0 ;
5129 PyObject * obj2 = 0 ;
5130 char * kwnames[] = {
5131 (char *) "type",(char *) "name",(char *) "content", NULL
5132 };
5133
5134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_XmlNodeEasy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5135 ecode1 = SWIG_AsVal_int(obj0, &val1);
5136 if (!SWIG_IsOK(ecode1)) {
5137 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_XmlNodeEasy" "', expected argument " "1"" of type '" "wxXmlNodeType""'");
5138 }
5139 arg1 = static_cast< wxXmlNodeType >(val1);
5140 {
5141 arg2 = wxString_in_helper(obj1);
5142 if (arg2 == NULL) SWIG_fail;
5143 temp2 = true;
5144 }
5145 if (obj2) {
5146 {
5147 arg3 = wxString_in_helper(obj2);
5148 if (arg3 == NULL) SWIG_fail;
5149 temp3 = true;
5150 }
5151 }
5152 {
5153 PyThreadState* __tstate = wxPyBeginAllowThreads();
5154 result = (wxXmlNode *)new wxXmlNode(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
5155 wxPyEndAllowThreads(__tstate);
5156 if (PyErr_Occurred()) SWIG_fail;
5157 }
5158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlNode, SWIG_POINTER_OWN | 0 );
5159 {
5160 if (temp2)
5161 delete arg2;
5162 }
5163 {
5164 if (temp3)
5165 delete arg3;
5166 }
5167 return resultobj;
5168 fail:
5169 {
5170 if (temp2)
5171 delete arg2;
5172 }
5173 {
5174 if (temp3)
5175 delete arg3;
5176 }
5177 return NULL;
5178 }
5179
5180
5181 SWIGINTERN PyObject *_wrap_XmlNode_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5182 PyObject *resultobj = 0;
5183 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5184 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
5185 void *argp1 = 0 ;
5186 int res1 = 0 ;
5187 void *argp2 = 0 ;
5188 int res2 = 0 ;
5189 PyObject * obj0 = 0 ;
5190 PyObject * obj1 = 0 ;
5191 char * kwnames[] = {
5192 (char *) "self",(char *) "child", NULL
5193 };
5194
5195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
5196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5197 if (!SWIG_IsOK(res1)) {
5198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_AddChild" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5199 }
5200 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5201 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5202 if (!SWIG_IsOK(res2)) {
5203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlNode_AddChild" "', expected argument " "2"" of type '" "wxXmlNode *""'");
5204 }
5205 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
5206 {
5207 PyThreadState* __tstate = wxPyBeginAllowThreads();
5208 (arg1)->AddChild(arg2);
5209 wxPyEndAllowThreads(__tstate);
5210 if (PyErr_Occurred()) SWIG_fail;
5211 }
5212 resultobj = SWIG_Py_Void();
5213 return resultobj;
5214 fail:
5215 return NULL;
5216 }
5217
5218
5219 SWIGINTERN PyObject *_wrap_XmlNode_InsertChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5220 PyObject *resultobj = 0;
5221 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5222 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
5223 wxXmlNode *arg3 = (wxXmlNode *) 0 ;
5224 void *argp1 = 0 ;
5225 int res1 = 0 ;
5226 void *argp2 = 0 ;
5227 int res2 = 0 ;
5228 void *argp3 = 0 ;
5229 int res3 = 0 ;
5230 PyObject * obj0 = 0 ;
5231 PyObject * obj1 = 0 ;
5232 PyObject * obj2 = 0 ;
5233 char * kwnames[] = {
5234 (char *) "self",(char *) "child",(char *) "before_node", NULL
5235 };
5236
5237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlNode_InsertChild",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5239 if (!SWIG_IsOK(res1)) {
5240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_InsertChild" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5241 }
5242 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5243 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5244 if (!SWIG_IsOK(res2)) {
5245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlNode_InsertChild" "', expected argument " "2"" of type '" "wxXmlNode *""'");
5246 }
5247 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
5248 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5249 if (!SWIG_IsOK(res3)) {
5250 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlNode_InsertChild" "', expected argument " "3"" of type '" "wxXmlNode *""'");
5251 }
5252 arg3 = reinterpret_cast< wxXmlNode * >(argp3);
5253 {
5254 PyThreadState* __tstate = wxPyBeginAllowThreads();
5255 (arg1)->InsertChild(arg2,arg3);
5256 wxPyEndAllowThreads(__tstate);
5257 if (PyErr_Occurred()) SWIG_fail;
5258 }
5259 resultobj = SWIG_Py_Void();
5260 return resultobj;
5261 fail:
5262 return NULL;
5263 }
5264
5265
5266 SWIGINTERN PyObject *_wrap_XmlNode_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5267 PyObject *resultobj = 0;
5268 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5269 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
5270 bool result;
5271 void *argp1 = 0 ;
5272 int res1 = 0 ;
5273 void *argp2 = 0 ;
5274 int res2 = 0 ;
5275 PyObject * obj0 = 0 ;
5276 PyObject * obj1 = 0 ;
5277 char * kwnames[] = {
5278 (char *) "self",(char *) "child", NULL
5279 };
5280
5281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
5282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5283 if (!SWIG_IsOK(res1)) {
5284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_RemoveChild" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5285 }
5286 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5287 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5288 if (!SWIG_IsOK(res2)) {
5289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlNode_RemoveChild" "', expected argument " "2"" of type '" "wxXmlNode *""'");
5290 }
5291 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
5292 {
5293 PyThreadState* __tstate = wxPyBeginAllowThreads();
5294 result = (bool)(arg1)->RemoveChild(arg2);
5295 wxPyEndAllowThreads(__tstate);
5296 if (PyErr_Occurred()) SWIG_fail;
5297 }
5298 {
5299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5300 }
5301 return resultobj;
5302 fail:
5303 return NULL;
5304 }
5305
5306
5307 SWIGINTERN PyObject *_wrap_XmlNode_AddProperty(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5308 PyObject *resultobj = 0;
5309 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5310 wxXmlProperty *arg2 = (wxXmlProperty *) 0 ;
5311 void *argp1 = 0 ;
5312 int res1 = 0 ;
5313 void *argp2 = 0 ;
5314 int res2 = 0 ;
5315 PyObject * obj0 = 0 ;
5316 PyObject * obj1 = 0 ;
5317 char * kwnames[] = {
5318 (char *) "self",(char *) "prop", NULL
5319 };
5320
5321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_AddProperty",kwnames,&obj0,&obj1)) SWIG_fail;
5322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5323 if (!SWIG_IsOK(res1)) {
5324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_AddProperty" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5325 }
5326 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5327 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
5328 if (!SWIG_IsOK(res2)) {
5329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlNode_AddProperty" "', expected argument " "2"" of type '" "wxXmlProperty *""'");
5330 }
5331 arg2 = reinterpret_cast< wxXmlProperty * >(argp2);
5332 {
5333 PyThreadState* __tstate = wxPyBeginAllowThreads();
5334 (arg1)->AddProperty(arg2);
5335 wxPyEndAllowThreads(__tstate);
5336 if (PyErr_Occurred()) SWIG_fail;
5337 }
5338 resultobj = SWIG_Py_Void();
5339 return resultobj;
5340 fail:
5341 return NULL;
5342 }
5343
5344
5345 SWIGINTERN PyObject *_wrap_XmlNode_AddPropertyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5346 PyObject *resultobj = 0;
5347 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5348 wxString *arg2 = 0 ;
5349 wxString *arg3 = 0 ;
5350 void *argp1 = 0 ;
5351 int res1 = 0 ;
5352 bool temp2 = false ;
5353 bool temp3 = false ;
5354 PyObject * obj0 = 0 ;
5355 PyObject * obj1 = 0 ;
5356 PyObject * obj2 = 0 ;
5357 char * kwnames[] = {
5358 (char *) "self",(char *) "name",(char *) "value", NULL
5359 };
5360
5361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlNode_AddPropertyName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5363 if (!SWIG_IsOK(res1)) {
5364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_AddPropertyName" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5365 }
5366 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5367 {
5368 arg2 = wxString_in_helper(obj1);
5369 if (arg2 == NULL) SWIG_fail;
5370 temp2 = true;
5371 }
5372 {
5373 arg3 = wxString_in_helper(obj2);
5374 if (arg3 == NULL) SWIG_fail;
5375 temp3 = true;
5376 }
5377 {
5378 PyThreadState* __tstate = wxPyBeginAllowThreads();
5379 (arg1)->AddProperty((wxString const &)*arg2,(wxString const &)*arg3);
5380 wxPyEndAllowThreads(__tstate);
5381 if (PyErr_Occurred()) SWIG_fail;
5382 }
5383 resultobj = SWIG_Py_Void();
5384 {
5385 if (temp2)
5386 delete arg2;
5387 }
5388 {
5389 if (temp3)
5390 delete arg3;
5391 }
5392 return resultobj;
5393 fail:
5394 {
5395 if (temp2)
5396 delete arg2;
5397 }
5398 {
5399 if (temp3)
5400 delete arg3;
5401 }
5402 return NULL;
5403 }
5404
5405
5406 SWIGINTERN PyObject *_wrap_XmlNode_DeleteProperty(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5407 PyObject *resultobj = 0;
5408 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5409 wxString *arg2 = 0 ;
5410 bool result;
5411 void *argp1 = 0 ;
5412 int res1 = 0 ;
5413 bool temp2 = false ;
5414 PyObject * obj0 = 0 ;
5415 PyObject * obj1 = 0 ;
5416 char * kwnames[] = {
5417 (char *) "self",(char *) "name", NULL
5418 };
5419
5420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_DeleteProperty",kwnames,&obj0,&obj1)) SWIG_fail;
5421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5422 if (!SWIG_IsOK(res1)) {
5423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_DeleteProperty" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5424 }
5425 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5426 {
5427 arg2 = wxString_in_helper(obj1);
5428 if (arg2 == NULL) SWIG_fail;
5429 temp2 = true;
5430 }
5431 {
5432 PyThreadState* __tstate = wxPyBeginAllowThreads();
5433 result = (bool)(arg1)->DeleteProperty((wxString const &)*arg2);
5434 wxPyEndAllowThreads(__tstate);
5435 if (PyErr_Occurred()) SWIG_fail;
5436 }
5437 {
5438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5439 }
5440 {
5441 if (temp2)
5442 delete arg2;
5443 }
5444 return resultobj;
5445 fail:
5446 {
5447 if (temp2)
5448 delete arg2;
5449 }
5450 return NULL;
5451 }
5452
5453
5454 SWIGINTERN PyObject *_wrap_XmlNode_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5455 PyObject *resultobj = 0;
5456 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5457 wxXmlNodeType result;
5458 void *argp1 = 0 ;
5459 int res1 = 0 ;
5460 PyObject *swig_obj[1] ;
5461
5462 if (!args) SWIG_fail;
5463 swig_obj[0] = args;
5464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5465 if (!SWIG_IsOK(res1)) {
5466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_GetType" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5467 }
5468 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5469 {
5470 PyThreadState* __tstate = wxPyBeginAllowThreads();
5471 result = (wxXmlNodeType)((wxXmlNode const *)arg1)->GetType();
5472 wxPyEndAllowThreads(__tstate);
5473 if (PyErr_Occurred()) SWIG_fail;
5474 }
5475 resultobj = SWIG_From_int(static_cast< int >(result));
5476 return resultobj;
5477 fail:
5478 return NULL;
5479 }
5480
5481
5482 SWIGINTERN PyObject *_wrap_XmlNode_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5483 PyObject *resultobj = 0;
5484 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5485 wxString result;
5486 void *argp1 = 0 ;
5487 int res1 = 0 ;
5488 PyObject *swig_obj[1] ;
5489
5490 if (!args) SWIG_fail;
5491 swig_obj[0] = args;
5492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5493 if (!SWIG_IsOK(res1)) {
5494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_GetName" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5495 }
5496 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5497 {
5498 PyThreadState* __tstate = wxPyBeginAllowThreads();
5499 result = ((wxXmlNode const *)arg1)->GetName();
5500 wxPyEndAllowThreads(__tstate);
5501 if (PyErr_Occurred()) SWIG_fail;
5502 }
5503 {
5504 #if wxUSE_UNICODE
5505 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5506 #else
5507 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5508 #endif
5509 }
5510 return resultobj;
5511 fail:
5512 return NULL;
5513 }
5514
5515
5516 SWIGINTERN PyObject *_wrap_XmlNode_GetContent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5517 PyObject *resultobj = 0;
5518 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5519 wxString result;
5520 void *argp1 = 0 ;
5521 int res1 = 0 ;
5522 PyObject *swig_obj[1] ;
5523
5524 if (!args) SWIG_fail;
5525 swig_obj[0] = args;
5526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5527 if (!SWIG_IsOK(res1)) {
5528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_GetContent" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5529 }
5530 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5531 {
5532 PyThreadState* __tstate = wxPyBeginAllowThreads();
5533 result = ((wxXmlNode const *)arg1)->GetContent();
5534 wxPyEndAllowThreads(__tstate);
5535 if (PyErr_Occurred()) SWIG_fail;
5536 }
5537 {
5538 #if wxUSE_UNICODE
5539 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5540 #else
5541 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5542 #endif
5543 }
5544 return resultobj;
5545 fail:
5546 return NULL;
5547 }
5548
5549
5550 SWIGINTERN PyObject *_wrap_XmlNode_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5551 PyObject *resultobj = 0;
5552 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5553 wxXmlNode *result = 0 ;
5554 void *argp1 = 0 ;
5555 int res1 = 0 ;
5556 PyObject *swig_obj[1] ;
5557
5558 if (!args) SWIG_fail;
5559 swig_obj[0] = args;
5560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5561 if (!SWIG_IsOK(res1)) {
5562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_GetParent" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5563 }
5564 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5565 {
5566 PyThreadState* __tstate = wxPyBeginAllowThreads();
5567 result = (wxXmlNode *)((wxXmlNode const *)arg1)->GetParent();
5568 wxPyEndAllowThreads(__tstate);
5569 if (PyErr_Occurred()) SWIG_fail;
5570 }
5571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlNode, 0 | 0 );
5572 return resultobj;
5573 fail:
5574 return NULL;
5575 }
5576
5577
5578 SWIGINTERN PyObject *_wrap_XmlNode_GetNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5579 PyObject *resultobj = 0;
5580 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5581 wxXmlNode *result = 0 ;
5582 void *argp1 = 0 ;
5583 int res1 = 0 ;
5584 PyObject *swig_obj[1] ;
5585
5586 if (!args) SWIG_fail;
5587 swig_obj[0] = args;
5588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5589 if (!SWIG_IsOK(res1)) {
5590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_GetNext" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5591 }
5592 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5593 {
5594 PyThreadState* __tstate = wxPyBeginAllowThreads();
5595 result = (wxXmlNode *)((wxXmlNode const *)arg1)->GetNext();
5596 wxPyEndAllowThreads(__tstate);
5597 if (PyErr_Occurred()) SWIG_fail;
5598 }
5599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlNode, 0 | 0 );
5600 return resultobj;
5601 fail:
5602 return NULL;
5603 }
5604
5605
5606 SWIGINTERN PyObject *_wrap_XmlNode_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5607 PyObject *resultobj = 0;
5608 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5609 wxXmlNode *result = 0 ;
5610 void *argp1 = 0 ;
5611 int res1 = 0 ;
5612 PyObject *swig_obj[1] ;
5613
5614 if (!args) SWIG_fail;
5615 swig_obj[0] = args;
5616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5617 if (!SWIG_IsOK(res1)) {
5618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_GetChildren" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5619 }
5620 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5621 {
5622 PyThreadState* __tstate = wxPyBeginAllowThreads();
5623 result = (wxXmlNode *)((wxXmlNode const *)arg1)->GetChildren();
5624 wxPyEndAllowThreads(__tstate);
5625 if (PyErr_Occurred()) SWIG_fail;
5626 }
5627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlNode, 0 | 0 );
5628 return resultobj;
5629 fail:
5630 return NULL;
5631 }
5632
5633
5634 SWIGINTERN PyObject *_wrap_XmlNode_GetProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5635 PyObject *resultobj = 0;
5636 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5637 wxXmlProperty *result = 0 ;
5638 void *argp1 = 0 ;
5639 int res1 = 0 ;
5640 PyObject *swig_obj[1] ;
5641
5642 if (!args) SWIG_fail;
5643 swig_obj[0] = args;
5644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5645 if (!SWIG_IsOK(res1)) {
5646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_GetProperties" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5647 }
5648 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5649 {
5650 PyThreadState* __tstate = wxPyBeginAllowThreads();
5651 result = (wxXmlProperty *)((wxXmlNode const *)arg1)->GetProperties();
5652 wxPyEndAllowThreads(__tstate);
5653 if (PyErr_Occurred()) SWIG_fail;
5654 }
5655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlProperty, 0 | 0 );
5656 return resultobj;
5657 fail:
5658 return NULL;
5659 }
5660
5661
5662 SWIGINTERN PyObject *_wrap_XmlNode_GetPropVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5663 PyObject *resultobj = 0;
5664 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5665 wxString *arg2 = 0 ;
5666 wxString *arg3 = 0 ;
5667 wxString result;
5668 void *argp1 = 0 ;
5669 int res1 = 0 ;
5670 bool temp2 = false ;
5671 bool temp3 = false ;
5672 PyObject * obj0 = 0 ;
5673 PyObject * obj1 = 0 ;
5674 PyObject * obj2 = 0 ;
5675 char * kwnames[] = {
5676 (char *) "self",(char *) "propName",(char *) "defaultVal", NULL
5677 };
5678
5679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlNode_GetPropVal",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5681 if (!SWIG_IsOK(res1)) {
5682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_GetPropVal" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5683 }
5684 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5685 {
5686 arg2 = wxString_in_helper(obj1);
5687 if (arg2 == NULL) SWIG_fail;
5688 temp2 = true;
5689 }
5690 {
5691 arg3 = wxString_in_helper(obj2);
5692 if (arg3 == NULL) SWIG_fail;
5693 temp3 = true;
5694 }
5695 {
5696 PyThreadState* __tstate = wxPyBeginAllowThreads();
5697 result = ((wxXmlNode const *)arg1)->GetPropVal((wxString const &)*arg2,(wxString const &)*arg3);
5698 wxPyEndAllowThreads(__tstate);
5699 if (PyErr_Occurred()) SWIG_fail;
5700 }
5701 {
5702 #if wxUSE_UNICODE
5703 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5704 #else
5705 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5706 #endif
5707 }
5708 {
5709 if (temp2)
5710 delete arg2;
5711 }
5712 {
5713 if (temp3)
5714 delete arg3;
5715 }
5716 return resultobj;
5717 fail:
5718 {
5719 if (temp2)
5720 delete arg2;
5721 }
5722 {
5723 if (temp3)
5724 delete arg3;
5725 }
5726 return NULL;
5727 }
5728
5729
5730 SWIGINTERN PyObject *_wrap_XmlNode_HasProp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5731 PyObject *resultobj = 0;
5732 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5733 wxString *arg2 = 0 ;
5734 bool result;
5735 void *argp1 = 0 ;
5736 int res1 = 0 ;
5737 bool temp2 = false ;
5738 PyObject * obj0 = 0 ;
5739 PyObject * obj1 = 0 ;
5740 char * kwnames[] = {
5741 (char *) "self",(char *) "propName", NULL
5742 };
5743
5744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_HasProp",kwnames,&obj0,&obj1)) SWIG_fail;
5745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5746 if (!SWIG_IsOK(res1)) {
5747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_HasProp" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5748 }
5749 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5750 {
5751 arg2 = wxString_in_helper(obj1);
5752 if (arg2 == NULL) SWIG_fail;
5753 temp2 = true;
5754 }
5755 {
5756 PyThreadState* __tstate = wxPyBeginAllowThreads();
5757 result = (bool)((wxXmlNode const *)arg1)->HasProp((wxString const &)*arg2);
5758 wxPyEndAllowThreads(__tstate);
5759 if (PyErr_Occurred()) SWIG_fail;
5760 }
5761 {
5762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5763 }
5764 {
5765 if (temp2)
5766 delete arg2;
5767 }
5768 return resultobj;
5769 fail:
5770 {
5771 if (temp2)
5772 delete arg2;
5773 }
5774 return NULL;
5775 }
5776
5777
5778 SWIGINTERN PyObject *_wrap_XmlNode_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5779 PyObject *resultobj = 0;
5780 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5781 wxXmlNodeType arg2 ;
5782 void *argp1 = 0 ;
5783 int res1 = 0 ;
5784 int val2 ;
5785 int ecode2 = 0 ;
5786 PyObject * obj0 = 0 ;
5787 PyObject * obj1 = 0 ;
5788 char * kwnames[] = {
5789 (char *) "self",(char *) "type", NULL
5790 };
5791
5792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
5793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5794 if (!SWIG_IsOK(res1)) {
5795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_SetType" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5796 }
5797 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5798 ecode2 = SWIG_AsVal_int(obj1, &val2);
5799 if (!SWIG_IsOK(ecode2)) {
5800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XmlNode_SetType" "', expected argument " "2"" of type '" "wxXmlNodeType""'");
5801 }
5802 arg2 = static_cast< wxXmlNodeType >(val2);
5803 {
5804 PyThreadState* __tstate = wxPyBeginAllowThreads();
5805 (arg1)->SetType(arg2);
5806 wxPyEndAllowThreads(__tstate);
5807 if (PyErr_Occurred()) SWIG_fail;
5808 }
5809 resultobj = SWIG_Py_Void();
5810 return resultobj;
5811 fail:
5812 return NULL;
5813 }
5814
5815
5816 SWIGINTERN PyObject *_wrap_XmlNode_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5817 PyObject *resultobj = 0;
5818 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5819 wxString *arg2 = 0 ;
5820 void *argp1 = 0 ;
5821 int res1 = 0 ;
5822 bool temp2 = false ;
5823 PyObject * obj0 = 0 ;
5824 PyObject * obj1 = 0 ;
5825 char * kwnames[] = {
5826 (char *) "self",(char *) "name", NULL
5827 };
5828
5829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
5830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5831 if (!SWIG_IsOK(res1)) {
5832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_SetName" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5833 }
5834 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5835 {
5836 arg2 = wxString_in_helper(obj1);
5837 if (arg2 == NULL) SWIG_fail;
5838 temp2 = true;
5839 }
5840 {
5841 PyThreadState* __tstate = wxPyBeginAllowThreads();
5842 (arg1)->SetName((wxString const &)*arg2);
5843 wxPyEndAllowThreads(__tstate);
5844 if (PyErr_Occurred()) SWIG_fail;
5845 }
5846 resultobj = SWIG_Py_Void();
5847 {
5848 if (temp2)
5849 delete arg2;
5850 }
5851 return resultobj;
5852 fail:
5853 {
5854 if (temp2)
5855 delete arg2;
5856 }
5857 return NULL;
5858 }
5859
5860
5861 SWIGINTERN PyObject *_wrap_XmlNode_SetContent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5862 PyObject *resultobj = 0;
5863 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5864 wxString *arg2 = 0 ;
5865 void *argp1 = 0 ;
5866 int res1 = 0 ;
5867 bool temp2 = false ;
5868 PyObject * obj0 = 0 ;
5869 PyObject * obj1 = 0 ;
5870 char * kwnames[] = {
5871 (char *) "self",(char *) "con", NULL
5872 };
5873
5874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_SetContent",kwnames,&obj0,&obj1)) SWIG_fail;
5875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5876 if (!SWIG_IsOK(res1)) {
5877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_SetContent" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5878 }
5879 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5880 {
5881 arg2 = wxString_in_helper(obj1);
5882 if (arg2 == NULL) SWIG_fail;
5883 temp2 = true;
5884 }
5885 {
5886 PyThreadState* __tstate = wxPyBeginAllowThreads();
5887 (arg1)->SetContent((wxString const &)*arg2);
5888 wxPyEndAllowThreads(__tstate);
5889 if (PyErr_Occurred()) SWIG_fail;
5890 }
5891 resultobj = SWIG_Py_Void();
5892 {
5893 if (temp2)
5894 delete arg2;
5895 }
5896 return resultobj;
5897 fail:
5898 {
5899 if (temp2)
5900 delete arg2;
5901 }
5902 return NULL;
5903 }
5904
5905
5906 SWIGINTERN PyObject *_wrap_XmlNode_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5907 PyObject *resultobj = 0;
5908 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5909 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
5910 void *argp1 = 0 ;
5911 int res1 = 0 ;
5912 void *argp2 = 0 ;
5913 int res2 = 0 ;
5914 PyObject * obj0 = 0 ;
5915 PyObject * obj1 = 0 ;
5916 char * kwnames[] = {
5917 (char *) "self",(char *) "parent", NULL
5918 };
5919
5920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
5921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5922 if (!SWIG_IsOK(res1)) {
5923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_SetParent" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5924 }
5925 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5926 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5927 if (!SWIG_IsOK(res2)) {
5928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlNode_SetParent" "', expected argument " "2"" of type '" "wxXmlNode *""'");
5929 }
5930 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
5931 {
5932 PyThreadState* __tstate = wxPyBeginAllowThreads();
5933 (arg1)->SetParent(arg2);
5934 wxPyEndAllowThreads(__tstate);
5935 if (PyErr_Occurred()) SWIG_fail;
5936 }
5937 resultobj = SWIG_Py_Void();
5938 return resultobj;
5939 fail:
5940 return NULL;
5941 }
5942
5943
5944 SWIGINTERN PyObject *_wrap_XmlNode_SetNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5945 PyObject *resultobj = 0;
5946 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5947 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
5948 void *argp1 = 0 ;
5949 int res1 = 0 ;
5950 void *argp2 = 0 ;
5951 int res2 = 0 ;
5952 PyObject * obj0 = 0 ;
5953 PyObject * obj1 = 0 ;
5954 char * kwnames[] = {
5955 (char *) "self",(char *) "next", NULL
5956 };
5957
5958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_SetNext",kwnames,&obj0,&obj1)) SWIG_fail;
5959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5960 if (!SWIG_IsOK(res1)) {
5961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_SetNext" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5962 }
5963 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5964 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5965 if (!SWIG_IsOK(res2)) {
5966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlNode_SetNext" "', expected argument " "2"" of type '" "wxXmlNode *""'");
5967 }
5968 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
5969 {
5970 PyThreadState* __tstate = wxPyBeginAllowThreads();
5971 (arg1)->SetNext(arg2);
5972 wxPyEndAllowThreads(__tstate);
5973 if (PyErr_Occurred()) SWIG_fail;
5974 }
5975 resultobj = SWIG_Py_Void();
5976 return resultobj;
5977 fail:
5978 return NULL;
5979 }
5980
5981
5982 SWIGINTERN PyObject *_wrap_XmlNode_SetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5983 PyObject *resultobj = 0;
5984 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5985 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
5986 void *argp1 = 0 ;
5987 int res1 = 0 ;
5988 void *argp2 = 0 ;
5989 int res2 = 0 ;
5990 PyObject * obj0 = 0 ;
5991 PyObject * obj1 = 0 ;
5992 char * kwnames[] = {
5993 (char *) "self",(char *) "child", NULL
5994 };
5995
5996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_SetChildren",kwnames,&obj0,&obj1)) SWIG_fail;
5997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5998 if (!SWIG_IsOK(res1)) {
5999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_SetChildren" "', expected argument " "1"" of type '" "wxXmlNode *""'");
6000 }
6001 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
6002 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
6003 if (!SWIG_IsOK(res2)) {
6004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlNode_SetChildren" "', expected argument " "2"" of type '" "wxXmlNode *""'");
6005 }
6006 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
6007 {
6008 PyThreadState* __tstate = wxPyBeginAllowThreads();
6009 (arg1)->SetChildren(arg2);
6010 wxPyEndAllowThreads(__tstate);
6011 if (PyErr_Occurred()) SWIG_fail;
6012 }
6013 resultobj = SWIG_Py_Void();
6014 return resultobj;
6015 fail:
6016 return NULL;
6017 }
6018
6019
6020 SWIGINTERN PyObject *_wrap_XmlNode_SetProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6021 PyObject *resultobj = 0;
6022 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
6023 wxXmlProperty *arg2 = (wxXmlProperty *) 0 ;
6024 void *argp1 = 0 ;
6025 int res1 = 0 ;
6026 void *argp2 = 0 ;
6027 int res2 = 0 ;
6028 PyObject * obj0 = 0 ;
6029 PyObject * obj1 = 0 ;
6030 char * kwnames[] = {
6031 (char *) "self",(char *) "prop", NULL
6032 };
6033
6034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_SetProperties",kwnames,&obj0,&obj1)) SWIG_fail;
6035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
6036 if (!SWIG_IsOK(res1)) {
6037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_SetProperties" "', expected argument " "1"" of type '" "wxXmlNode *""'");
6038 }
6039 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
6040 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
6041 if (!SWIG_IsOK(res2)) {
6042 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlNode_SetProperties" "', expected argument " "2"" of type '" "wxXmlProperty *""'");
6043 }
6044 arg2 = reinterpret_cast< wxXmlProperty * >(argp2);
6045 {
6046 PyThreadState* __tstate = wxPyBeginAllowThreads();
6047 (arg1)->SetProperties(arg2);
6048 wxPyEndAllowThreads(__tstate);
6049 if (PyErr_Occurred()) SWIG_fail;
6050 }
6051 resultobj = SWIG_Py_Void();
6052 return resultobj;
6053 fail:
6054 return NULL;
6055 }
6056
6057
6058 SWIGINTERN PyObject *XmlNode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6059 PyObject *obj;
6060 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6061 SWIG_TypeNewClientData(SWIGTYPE_p_wxXmlNode, SWIG_NewClientData(obj));
6062 return SWIG_Py_Void();
6063 }
6064
6065 SWIGINTERN PyObject *XmlNode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6066 return SWIG_Python_InitShadowInstance(args);
6067 }
6068
6069 SWIGINTERN PyObject *_wrap_new_XmlDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6070 PyObject *resultobj = 0;
6071 wxString *arg1 = 0 ;
6072 wxString const &arg2_defvalue = wxPyUTF8String ;
6073 wxString *arg2 = (wxString *) &arg2_defvalue ;
6074 wxXmlDocument *result = 0 ;
6075 bool temp1 = false ;
6076 bool temp2 = false ;
6077 PyObject * obj0 = 0 ;
6078 PyObject * obj1 = 0 ;
6079 char * kwnames[] = {
6080 (char *) "filename",(char *) "encoding", NULL
6081 };
6082
6083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_XmlDocument",kwnames,&obj0,&obj1)) SWIG_fail;
6084 {
6085 arg1 = wxString_in_helper(obj0);
6086 if (arg1 == NULL) SWIG_fail;
6087 temp1 = true;
6088 }
6089 if (obj1) {
6090 {
6091 arg2 = wxString_in_helper(obj1);
6092 if (arg2 == NULL) SWIG_fail;
6093 temp2 = true;
6094 }
6095 }
6096 {
6097 PyThreadState* __tstate = wxPyBeginAllowThreads();
6098 result = (wxXmlDocument *)new wxXmlDocument((wxString const &)*arg1,(wxString const &)*arg2);
6099 wxPyEndAllowThreads(__tstate);
6100 if (PyErr_Occurred()) SWIG_fail;
6101 }
6102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_NEW | 0 );
6103 {
6104 if (temp1)
6105 delete arg1;
6106 }
6107 {
6108 if (temp2)
6109 delete arg2;
6110 }
6111 return resultobj;
6112 fail:
6113 {
6114 if (temp1)
6115 delete arg1;
6116 }
6117 {
6118 if (temp2)
6119 delete arg2;
6120 }
6121 return NULL;
6122 }
6123
6124
6125 SWIGINTERN PyObject *_wrap_new_XmlDocumentFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6126 PyObject *resultobj = 0;
6127 wxInputStream *arg1 = 0 ;
6128 wxString const &arg2_defvalue = wxPyUTF8String ;
6129 wxString *arg2 = (wxString *) &arg2_defvalue ;
6130 wxXmlDocument *result = 0 ;
6131 wxPyInputStream *temp1 ;
6132 bool created1 ;
6133 bool temp2 = false ;
6134 PyObject * obj0 = 0 ;
6135 PyObject * obj1 = 0 ;
6136 char * kwnames[] = {
6137 (char *) "stream",(char *) "encoding", NULL
6138 };
6139
6140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_XmlDocumentFromStream",kwnames,&obj0,&obj1)) SWIG_fail;
6141 {
6142 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
6143 arg1 = temp1->m_wxis;
6144 created1 = false;
6145 } else {
6146 PyErr_Clear(); // clear the failure of the wxPyConvert above
6147 arg1 = wxPyCBInputStream_create(obj0, false);
6148 if (arg1 == NULL) {
6149 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
6150 SWIG_fail;
6151 }
6152 created1 = true;
6153 }
6154 }
6155 if (obj1) {
6156 {
6157 arg2 = wxString_in_helper(obj1);
6158 if (arg2 == NULL) SWIG_fail;
6159 temp2 = true;
6160 }
6161 }
6162 {
6163 PyThreadState* __tstate = wxPyBeginAllowThreads();
6164 result = (wxXmlDocument *)new wxXmlDocument(*arg1,(wxString const &)*arg2);
6165 wxPyEndAllowThreads(__tstate);
6166 if (PyErr_Occurred()) SWIG_fail;
6167 }
6168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_OWN | 0 );
6169 {
6170 if (created1) delete arg1;
6171 }
6172 {
6173 if (temp2)
6174 delete arg2;
6175 }
6176 return resultobj;
6177 fail:
6178 {
6179 if (created1) delete arg1;
6180 }
6181 {
6182 if (temp2)
6183 delete arg2;
6184 }
6185 return NULL;
6186 }
6187
6188
6189 SWIGINTERN PyObject *_wrap_new_EmptyXmlDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6190 PyObject *resultobj = 0;
6191 wxXmlDocument *result = 0 ;
6192
6193 if (!SWIG_Python_UnpackTuple(args,"new_EmptyXmlDocument",0,0,0)) SWIG_fail;
6194 {
6195 PyThreadState* __tstate = wxPyBeginAllowThreads();
6196 result = (wxXmlDocument *)new wxXmlDocument();
6197 wxPyEndAllowThreads(__tstate);
6198 if (PyErr_Occurred()) SWIG_fail;
6199 }
6200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_OWN | 0 );
6201 return resultobj;
6202 fail:
6203 return NULL;
6204 }
6205
6206
6207 SWIGINTERN PyObject *_wrap_delete_XmlDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6208 PyObject *resultobj = 0;
6209 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6210 void *argp1 = 0 ;
6211 int res1 = 0 ;
6212 PyObject *swig_obj[1] ;
6213
6214 if (!args) SWIG_fail;
6215 swig_obj[0] = args;
6216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_DISOWN | 0 );
6217 if (!SWIG_IsOK(res1)) {
6218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XmlDocument" "', expected argument " "1"" of type '" "wxXmlDocument *""'");
6219 }
6220 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6221 {
6222 PyThreadState* __tstate = wxPyBeginAllowThreads();
6223 delete arg1;
6224
6225 wxPyEndAllowThreads(__tstate);
6226 if (PyErr_Occurred()) SWIG_fail;
6227 }
6228 resultobj = SWIG_Py_Void();
6229 return resultobj;
6230 fail:
6231 return NULL;
6232 }
6233
6234
6235 SWIGINTERN PyObject *_wrap_XmlDocument_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6236 PyObject *resultobj = 0;
6237 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6238 wxString *arg2 = 0 ;
6239 wxString const &arg3_defvalue = wxPyUTF8String ;
6240 wxString *arg3 = (wxString *) &arg3_defvalue ;
6241 bool result;
6242 void *argp1 = 0 ;
6243 int res1 = 0 ;
6244 bool temp2 = false ;
6245 bool temp3 = false ;
6246 PyObject * obj0 = 0 ;
6247 PyObject * obj1 = 0 ;
6248 PyObject * obj2 = 0 ;
6249 char * kwnames[] = {
6250 (char *) "self",(char *) "filename",(char *) "encoding", NULL
6251 };
6252
6253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlDocument_Load",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6255 if (!SWIG_IsOK(res1)) {
6256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_Load" "', expected argument " "1"" of type '" "wxXmlDocument *""'");
6257 }
6258 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6259 {
6260 arg2 = wxString_in_helper(obj1);
6261 if (arg2 == NULL) SWIG_fail;
6262 temp2 = true;
6263 }
6264 if (obj2) {
6265 {
6266 arg3 = wxString_in_helper(obj2);
6267 if (arg3 == NULL) SWIG_fail;
6268 temp3 = true;
6269 }
6270 }
6271 {
6272 PyThreadState* __tstate = wxPyBeginAllowThreads();
6273 result = (bool)(arg1)->Load((wxString const &)*arg2,(wxString const &)*arg3);
6274 wxPyEndAllowThreads(__tstate);
6275 if (PyErr_Occurred()) SWIG_fail;
6276 }
6277 {
6278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6279 }
6280 {
6281 if (temp2)
6282 delete arg2;
6283 }
6284 {
6285 if (temp3)
6286 delete arg3;
6287 }
6288 return resultobj;
6289 fail:
6290 {
6291 if (temp2)
6292 delete arg2;
6293 }
6294 {
6295 if (temp3)
6296 delete arg3;
6297 }
6298 return NULL;
6299 }
6300
6301
6302 SWIGINTERN PyObject *_wrap_XmlDocument_LoadFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6303 PyObject *resultobj = 0;
6304 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6305 wxInputStream *arg2 = 0 ;
6306 wxString const &arg3_defvalue = wxPyUTF8String ;
6307 wxString *arg3 = (wxString *) &arg3_defvalue ;
6308 bool result;
6309 void *argp1 = 0 ;
6310 int res1 = 0 ;
6311 wxPyInputStream *temp2 ;
6312 bool created2 ;
6313 bool temp3 = false ;
6314 PyObject * obj0 = 0 ;
6315 PyObject * obj1 = 0 ;
6316 PyObject * obj2 = 0 ;
6317 char * kwnames[] = {
6318 (char *) "self",(char *) "stream",(char *) "encoding", NULL
6319 };
6320
6321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlDocument_LoadFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6323 if (!SWIG_IsOK(res1)) {
6324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_LoadFromStream" "', expected argument " "1"" of type '" "wxXmlDocument *""'");
6325 }
6326 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6327 {
6328 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
6329 arg2 = temp2->m_wxis;
6330 created2 = false;
6331 } else {
6332 PyErr_Clear(); // clear the failure of the wxPyConvert above
6333 arg2 = wxPyCBInputStream_create(obj1, false);
6334 if (arg2 == NULL) {
6335 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
6336 SWIG_fail;
6337 }
6338 created2 = true;
6339 }
6340 }
6341 if (obj2) {
6342 {
6343 arg3 = wxString_in_helper(obj2);
6344 if (arg3 == NULL) SWIG_fail;
6345 temp3 = true;
6346 }
6347 }
6348 {
6349 PyThreadState* __tstate = wxPyBeginAllowThreads();
6350 result = (bool)(arg1)->Load(*arg2,(wxString const &)*arg3);
6351 wxPyEndAllowThreads(__tstate);
6352 if (PyErr_Occurred()) SWIG_fail;
6353 }
6354 {
6355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6356 }
6357 {
6358 if (created2) delete arg2;
6359 }
6360 {
6361 if (temp3)
6362 delete arg3;
6363 }
6364 return resultobj;
6365 fail:
6366 {
6367 if (created2) delete arg2;
6368 }
6369 {
6370 if (temp3)
6371 delete arg3;
6372 }
6373 return NULL;
6374 }
6375
6376
6377 SWIGINTERN PyObject *_wrap_XmlDocument_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6378 PyObject *resultobj = 0;
6379 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6380 wxString *arg2 = 0 ;
6381 bool result;
6382 void *argp1 = 0 ;
6383 int res1 = 0 ;
6384 bool temp2 = false ;
6385 PyObject * obj0 = 0 ;
6386 PyObject * obj1 = 0 ;
6387 char * kwnames[] = {
6388 (char *) "self",(char *) "filename", NULL
6389 };
6390
6391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlDocument_Save",kwnames,&obj0,&obj1)) SWIG_fail;
6392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6393 if (!SWIG_IsOK(res1)) {
6394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_Save" "', expected argument " "1"" of type '" "wxXmlDocument const *""'");
6395 }
6396 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6397 {
6398 arg2 = wxString_in_helper(obj1);
6399 if (arg2 == NULL) SWIG_fail;
6400 temp2 = true;
6401 }
6402 {
6403 PyThreadState* __tstate = wxPyBeginAllowThreads();
6404 result = (bool)((wxXmlDocument const *)arg1)->Save((wxString const &)*arg2);
6405 wxPyEndAllowThreads(__tstate);
6406 if (PyErr_Occurred()) SWIG_fail;
6407 }
6408 {
6409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6410 }
6411 {
6412 if (temp2)
6413 delete arg2;
6414 }
6415 return resultobj;
6416 fail:
6417 {
6418 if (temp2)
6419 delete arg2;
6420 }
6421 return NULL;
6422 }
6423
6424
6425 SWIGINTERN PyObject *_wrap_XmlDocument_SaveToStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6426 PyObject *resultobj = 0;
6427 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6428 wxOutputStream *arg2 = 0 ;
6429 bool result;
6430 void *argp1 = 0 ;
6431 int res1 = 0 ;
6432 void *argp2 = 0 ;
6433 int res2 = 0 ;
6434 PyObject * obj0 = 0 ;
6435 PyObject * obj1 = 0 ;
6436 char * kwnames[] = {
6437 (char *) "self",(char *) "stream", NULL
6438 };
6439
6440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlDocument_SaveToStream",kwnames,&obj0,&obj1)) SWIG_fail;
6441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6442 if (!SWIG_IsOK(res1)) {
6443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_SaveToStream" "', expected argument " "1"" of type '" "wxXmlDocument const *""'");
6444 }
6445 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6446 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxOutputStream, 0 );
6447 if (!SWIG_IsOK(res2)) {
6448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlDocument_SaveToStream" "', expected argument " "2"" of type '" "wxOutputStream &""'");
6449 }
6450 if (!argp2) {
6451 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XmlDocument_SaveToStream" "', expected argument " "2"" of type '" "wxOutputStream &""'");
6452 }
6453 arg2 = reinterpret_cast< wxOutputStream * >(argp2);
6454 {
6455 PyThreadState* __tstate = wxPyBeginAllowThreads();
6456 result = (bool)((wxXmlDocument const *)arg1)->Save(*arg2);
6457 wxPyEndAllowThreads(__tstate);
6458 if (PyErr_Occurred()) SWIG_fail;
6459 }
6460 {
6461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6462 }
6463 return resultobj;
6464 fail:
6465 return NULL;
6466 }
6467
6468
6469 SWIGINTERN PyObject *_wrap_XmlDocument_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6470 PyObject *resultobj = 0;
6471 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6472 bool result;
6473 void *argp1 = 0 ;
6474 int res1 = 0 ;
6475 PyObject *swig_obj[1] ;
6476
6477 if (!args) SWIG_fail;
6478 swig_obj[0] = args;
6479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6480 if (!SWIG_IsOK(res1)) {
6481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_IsOk" "', expected argument " "1"" of type '" "wxXmlDocument const *""'");
6482 }
6483 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6484 {
6485 PyThreadState* __tstate = wxPyBeginAllowThreads();
6486 result = (bool)((wxXmlDocument const *)arg1)->IsOk();
6487 wxPyEndAllowThreads(__tstate);
6488 if (PyErr_Occurred()) SWIG_fail;
6489 }
6490 {
6491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6492 }
6493 return resultobj;
6494 fail:
6495 return NULL;
6496 }
6497
6498
6499 SWIGINTERN PyObject *_wrap_XmlDocument_GetRoot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6500 PyObject *resultobj = 0;
6501 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6502 wxXmlNode *result = 0 ;
6503 void *argp1 = 0 ;
6504 int res1 = 0 ;
6505 PyObject *swig_obj[1] ;
6506
6507 if (!args) SWIG_fail;
6508 swig_obj[0] = args;
6509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6510 if (!SWIG_IsOK(res1)) {
6511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_GetRoot" "', expected argument " "1"" of type '" "wxXmlDocument const *""'");
6512 }
6513 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6514 {
6515 PyThreadState* __tstate = wxPyBeginAllowThreads();
6516 result = (wxXmlNode *)((wxXmlDocument const *)arg1)->GetRoot();
6517 wxPyEndAllowThreads(__tstate);
6518 if (PyErr_Occurred()) SWIG_fail;
6519 }
6520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlNode, 0 | 0 );
6521 return resultobj;
6522 fail:
6523 return NULL;
6524 }
6525
6526
6527 SWIGINTERN PyObject *_wrap_XmlDocument_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6528 PyObject *resultobj = 0;
6529 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6530 wxString result;
6531 void *argp1 = 0 ;
6532 int res1 = 0 ;
6533 PyObject *swig_obj[1] ;
6534
6535 if (!args) SWIG_fail;
6536 swig_obj[0] = args;
6537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6538 if (!SWIG_IsOK(res1)) {
6539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_GetVersion" "', expected argument " "1"" of type '" "wxXmlDocument const *""'");
6540 }
6541 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6542 {
6543 PyThreadState* __tstate = wxPyBeginAllowThreads();
6544 result = ((wxXmlDocument const *)arg1)->GetVersion();
6545 wxPyEndAllowThreads(__tstate);
6546 if (PyErr_Occurred()) SWIG_fail;
6547 }
6548 {
6549 #if wxUSE_UNICODE
6550 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6551 #else
6552 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6553 #endif
6554 }
6555 return resultobj;
6556 fail:
6557 return NULL;
6558 }
6559
6560
6561 SWIGINTERN PyObject *_wrap_XmlDocument_GetFileEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6562 PyObject *resultobj = 0;
6563 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6564 wxString result;
6565 void *argp1 = 0 ;
6566 int res1 = 0 ;
6567 PyObject *swig_obj[1] ;
6568
6569 if (!args) SWIG_fail;
6570 swig_obj[0] = args;
6571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6572 if (!SWIG_IsOK(res1)) {
6573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_GetFileEncoding" "', expected argument " "1"" of type '" "wxXmlDocument const *""'");
6574 }
6575 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6576 {
6577 PyThreadState* __tstate = wxPyBeginAllowThreads();
6578 result = ((wxXmlDocument const *)arg1)->GetFileEncoding();
6579 wxPyEndAllowThreads(__tstate);
6580 if (PyErr_Occurred()) SWIG_fail;
6581 }
6582 {
6583 #if wxUSE_UNICODE
6584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6585 #else
6586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6587 #endif
6588 }
6589 return resultobj;
6590 fail:
6591 return NULL;
6592 }
6593
6594
6595 SWIGINTERN PyObject *_wrap_XmlDocument_SetRoot(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6596 PyObject *resultobj = 0;
6597 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6598 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
6599 void *argp1 = 0 ;
6600 int res1 = 0 ;
6601 void *argp2 = 0 ;
6602 int res2 = 0 ;
6603 PyObject * obj0 = 0 ;
6604 PyObject * obj1 = 0 ;
6605 char * kwnames[] = {
6606 (char *) "self",(char *) "node", NULL
6607 };
6608
6609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlDocument_SetRoot",kwnames,&obj0,&obj1)) SWIG_fail;
6610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6611 if (!SWIG_IsOK(res1)) {
6612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_SetRoot" "', expected argument " "1"" of type '" "wxXmlDocument *""'");
6613 }
6614 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6615 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
6616 if (!SWIG_IsOK(res2)) {
6617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlDocument_SetRoot" "', expected argument " "2"" of type '" "wxXmlNode *""'");
6618 }
6619 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
6620 {
6621 PyThreadState* __tstate = wxPyBeginAllowThreads();
6622 (arg1)->SetRoot(arg2);
6623 wxPyEndAllowThreads(__tstate);
6624 if (PyErr_Occurred()) SWIG_fail;
6625 }
6626 resultobj = SWIG_Py_Void();
6627 return resultobj;
6628 fail:
6629 return NULL;
6630 }
6631
6632
6633 SWIGINTERN PyObject *_wrap_XmlDocument_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6634 PyObject *resultobj = 0;
6635 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6636 wxString *arg2 = 0 ;
6637 void *argp1 = 0 ;
6638 int res1 = 0 ;
6639 bool temp2 = false ;
6640 PyObject * obj0 = 0 ;
6641 PyObject * obj1 = 0 ;
6642 char * kwnames[] = {
6643 (char *) "self",(char *) "version", NULL
6644 };
6645
6646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlDocument_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
6647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6648 if (!SWIG_IsOK(res1)) {
6649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_SetVersion" "', expected argument " "1"" of type '" "wxXmlDocument *""'");
6650 }
6651 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6652 {
6653 arg2 = wxString_in_helper(obj1);
6654 if (arg2 == NULL) SWIG_fail;
6655 temp2 = true;
6656 }
6657 {
6658 PyThreadState* __tstate = wxPyBeginAllowThreads();
6659 (arg1)->SetVersion((wxString const &)*arg2);
6660 wxPyEndAllowThreads(__tstate);
6661 if (PyErr_Occurred()) SWIG_fail;
6662 }
6663 resultobj = SWIG_Py_Void();
6664 {
6665 if (temp2)
6666 delete arg2;
6667 }
6668 return resultobj;
6669 fail:
6670 {
6671 if (temp2)
6672 delete arg2;
6673 }
6674 return NULL;
6675 }
6676
6677
6678 SWIGINTERN PyObject *_wrap_XmlDocument_SetFileEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6679 PyObject *resultobj = 0;
6680 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6681 wxString *arg2 = 0 ;
6682 void *argp1 = 0 ;
6683 int res1 = 0 ;
6684 bool temp2 = false ;
6685 PyObject * obj0 = 0 ;
6686 PyObject * obj1 = 0 ;
6687 char * kwnames[] = {
6688 (char *) "self",(char *) "encoding", NULL
6689 };
6690
6691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlDocument_SetFileEncoding",kwnames,&obj0,&obj1)) SWIG_fail;
6692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6693 if (!SWIG_IsOK(res1)) {
6694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_SetFileEncoding" "', expected argument " "1"" of type '" "wxXmlDocument *""'");
6695 }
6696 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6697 {
6698 arg2 = wxString_in_helper(obj1);
6699 if (arg2 == NULL) SWIG_fail;
6700 temp2 = true;
6701 }
6702 {
6703 PyThreadState* __tstate = wxPyBeginAllowThreads();
6704 (arg1)->SetFileEncoding((wxString const &)*arg2);
6705 wxPyEndAllowThreads(__tstate);
6706 if (PyErr_Occurred()) SWIG_fail;
6707 }
6708 resultobj = SWIG_Py_Void();
6709 {
6710 if (temp2)
6711 delete arg2;
6712 }
6713 return resultobj;
6714 fail:
6715 {
6716 if (temp2)
6717 delete arg2;
6718 }
6719 return NULL;
6720 }
6721
6722
6723 SWIGINTERN PyObject *XmlDocument_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6724 PyObject *obj;
6725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6726 SWIG_TypeNewClientData(SWIGTYPE_p_wxXmlDocument, SWIG_NewClientData(obj));
6727 return SWIG_Py_Void();
6728 }
6729
6730 SWIGINTERN PyObject *XmlDocument_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6731 return SWIG_Python_InitShadowInstance(args);
6732 }
6733
6734 SWIGINTERN PyObject *_wrap_new_XmlResourceHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6735 PyObject *resultobj = 0;
6736 wxPyXmlResourceHandler *result = 0 ;
6737
6738 if (!SWIG_Python_UnpackTuple(args,"new_XmlResourceHandler",0,0,0)) SWIG_fail;
6739 {
6740 PyThreadState* __tstate = wxPyBeginAllowThreads();
6741 result = (wxPyXmlResourceHandler *)new wxPyXmlResourceHandler();
6742 wxPyEndAllowThreads(__tstate);
6743 if (PyErr_Occurred()) SWIG_fail;
6744 }
6745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_NEW | 0 );
6746 return resultobj;
6747 fail:
6748 return NULL;
6749 }
6750
6751
6752 SWIGINTERN PyObject *_wrap_XmlResourceHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6753 PyObject *resultobj = 0;
6754 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6755 PyObject *arg2 = (PyObject *) 0 ;
6756 PyObject *arg3 = (PyObject *) 0 ;
6757 void *argp1 = 0 ;
6758 int res1 = 0 ;
6759 PyObject * obj0 = 0 ;
6760 PyObject * obj1 = 0 ;
6761 PyObject * obj2 = 0 ;
6762 char * kwnames[] = {
6763 (char *) "self",(char *) "self",(char *) "_class", NULL
6764 };
6765
6766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResourceHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
6768 if (!SWIG_IsOK(res1)) {
6769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
6770 }
6771 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
6772 arg2 = obj1;
6773 arg3 = obj2;
6774 {
6775 PyThreadState* __tstate = wxPyBeginAllowThreads();
6776 (arg1)->_setCallbackInfo(arg2,arg3);
6777 wxPyEndAllowThreads(__tstate);
6778 if (PyErr_Occurred()) SWIG_fail;
6779 }
6780 resultobj = SWIG_Py_Void();
6781 return resultobj;
6782 fail:
6783 return NULL;
6784 }
6785
6786
6787 SWIGINTERN PyObject *_wrap_XmlResourceHandler_CreateResource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6788 PyObject *resultobj = 0;
6789 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6790 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
6791 wxObject *arg3 = (wxObject *) 0 ;
6792 wxObject *arg4 = (wxObject *) 0 ;
6793 wxObject *result = 0 ;
6794 void *argp1 = 0 ;
6795 int res1 = 0 ;
6796 void *argp2 = 0 ;
6797 int res2 = 0 ;
6798 void *argp3 = 0 ;
6799 int res3 = 0 ;
6800 void *argp4 = 0 ;
6801 int res4 = 0 ;
6802 PyObject * obj0 = 0 ;
6803 PyObject * obj1 = 0 ;
6804 PyObject * obj2 = 0 ;
6805 PyObject * obj3 = 0 ;
6806 char * kwnames[] = {
6807 (char *) "self",(char *) "node",(char *) "parent",(char *) "instance", NULL
6808 };
6809
6810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:XmlResourceHandler_CreateResource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
6812 if (!SWIG_IsOK(res1)) {
6813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_CreateResource" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
6814 }
6815 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
6816 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
6817 if (!SWIG_IsOK(res2)) {
6818 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResourceHandler_CreateResource" "', expected argument " "2"" of type '" "wxXmlNode *""'");
6819 }
6820 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
6821 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
6822 if (!SWIG_IsOK(res3)) {
6823 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResourceHandler_CreateResource" "', expected argument " "3"" of type '" "wxObject *""'");
6824 }
6825 arg3 = reinterpret_cast< wxObject * >(argp3);
6826 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxObject, 0 | 0 );
6827 if (!SWIG_IsOK(res4)) {
6828 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "XmlResourceHandler_CreateResource" "', expected argument " "4"" of type '" "wxObject *""'");
6829 }
6830 arg4 = reinterpret_cast< wxObject * >(argp4);
6831 {
6832 PyThreadState* __tstate = wxPyBeginAllowThreads();
6833 result = (wxObject *)(arg1)->CreateResource(arg2,arg3,arg4);
6834 wxPyEndAllowThreads(__tstate);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 {
6838 resultobj = wxPyMake_wxObject(result, (bool)0);
6839 }
6840 return resultobj;
6841 fail:
6842 return NULL;
6843 }
6844
6845
6846 SWIGINTERN PyObject *_wrap_XmlResourceHandler_SetParentResource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6847 PyObject *resultobj = 0;
6848 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6849 wxXmlResource *arg2 = (wxXmlResource *) 0 ;
6850 void *argp1 = 0 ;
6851 int res1 = 0 ;
6852 void *argp2 = 0 ;
6853 int res2 = 0 ;
6854 PyObject * obj0 = 0 ;
6855 PyObject * obj1 = 0 ;
6856 char * kwnames[] = {
6857 (char *) "self",(char *) "res", NULL
6858 };
6859
6860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_SetParentResource",kwnames,&obj0,&obj1)) SWIG_fail;
6861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
6862 if (!SWIG_IsOK(res1)) {
6863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_SetParentResource" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
6864 }
6865 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
6866 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlResource, 0 | 0 );
6867 if (!SWIG_IsOK(res2)) {
6868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResourceHandler_SetParentResource" "', expected argument " "2"" of type '" "wxXmlResource *""'");
6869 }
6870 arg2 = reinterpret_cast< wxXmlResource * >(argp2);
6871 {
6872 PyThreadState* __tstate = wxPyBeginAllowThreads();
6873 (arg1)->SetParentResource(arg2);
6874 wxPyEndAllowThreads(__tstate);
6875 if (PyErr_Occurred()) SWIG_fail;
6876 }
6877 resultobj = SWIG_Py_Void();
6878 return resultobj;
6879 fail:
6880 return NULL;
6881 }
6882
6883
6884 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetResource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6885 PyObject *resultobj = 0;
6886 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6887 wxXmlResource *result = 0 ;
6888 void *argp1 = 0 ;
6889 int res1 = 0 ;
6890 PyObject *swig_obj[1] ;
6891
6892 if (!args) SWIG_fail;
6893 swig_obj[0] = args;
6894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
6895 if (!SWIG_IsOK(res1)) {
6896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetResource" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
6897 }
6898 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
6899 {
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 result = (wxXmlResource *)(arg1)->GetResource();
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlResource, 0 | 0 );
6906 return resultobj;
6907 fail:
6908 return NULL;
6909 }
6910
6911
6912 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6913 PyObject *resultobj = 0;
6914 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6915 wxXmlNode *result = 0 ;
6916 void *argp1 = 0 ;
6917 int res1 = 0 ;
6918 PyObject *swig_obj[1] ;
6919
6920 if (!args) SWIG_fail;
6921 swig_obj[0] = args;
6922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
6923 if (!SWIG_IsOK(res1)) {
6924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetNode" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
6925 }
6926 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
6927 {
6928 PyThreadState* __tstate = wxPyBeginAllowThreads();
6929 result = (wxXmlNode *)(arg1)->GetNode();
6930 wxPyEndAllowThreads(__tstate);
6931 if (PyErr_Occurred()) SWIG_fail;
6932 }
6933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlNode, 0 | 0 );
6934 return resultobj;
6935 fail:
6936 return NULL;
6937 }
6938
6939
6940 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6941 PyObject *resultobj = 0;
6942 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6943 wxString result;
6944 void *argp1 = 0 ;
6945 int res1 = 0 ;
6946 PyObject *swig_obj[1] ;
6947
6948 if (!args) SWIG_fail;
6949 swig_obj[0] = args;
6950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
6951 if (!SWIG_IsOK(res1)) {
6952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetClass" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
6953 }
6954 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
6955 {
6956 PyThreadState* __tstate = wxPyBeginAllowThreads();
6957 result = (arg1)->GetClass();
6958 wxPyEndAllowThreads(__tstate);
6959 if (PyErr_Occurred()) SWIG_fail;
6960 }
6961 {
6962 #if wxUSE_UNICODE
6963 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6964 #else
6965 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6966 #endif
6967 }
6968 return resultobj;
6969 fail:
6970 return NULL;
6971 }
6972
6973
6974 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6975 PyObject *resultobj = 0;
6976 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6977 wxObject *result = 0 ;
6978 void *argp1 = 0 ;
6979 int res1 = 0 ;
6980 PyObject *swig_obj[1] ;
6981
6982 if (!args) SWIG_fail;
6983 swig_obj[0] = args;
6984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
6985 if (!SWIG_IsOK(res1)) {
6986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetParent" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
6987 }
6988 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
6989 {
6990 PyThreadState* __tstate = wxPyBeginAllowThreads();
6991 result = (wxObject *)(arg1)->GetParent();
6992 wxPyEndAllowThreads(__tstate);
6993 if (PyErr_Occurred()) SWIG_fail;
6994 }
6995 {
6996 resultobj = wxPyMake_wxObject(result, (bool)0);
6997 }
6998 return resultobj;
6999 fail:
7000 return NULL;
7001 }
7002
7003
7004 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetInstance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7005 PyObject *resultobj = 0;
7006 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7007 wxObject *result = 0 ;
7008 void *argp1 = 0 ;
7009 int res1 = 0 ;
7010 PyObject *swig_obj[1] ;
7011
7012 if (!args) SWIG_fail;
7013 swig_obj[0] = args;
7014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7015 if (!SWIG_IsOK(res1)) {
7016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetInstance" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7017 }
7018 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7019 {
7020 PyThreadState* __tstate = wxPyBeginAllowThreads();
7021 result = (wxObject *)(arg1)->GetInstance();
7022 wxPyEndAllowThreads(__tstate);
7023 if (PyErr_Occurred()) SWIG_fail;
7024 }
7025 {
7026 resultobj = wxPyMake_wxObject(result, (bool)0);
7027 }
7028 return resultobj;
7029 fail:
7030 return NULL;
7031 }
7032
7033
7034 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetParentAsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7035 PyObject *resultobj = 0;
7036 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7037 wxWindow *result = 0 ;
7038 void *argp1 = 0 ;
7039 int res1 = 0 ;
7040 PyObject *swig_obj[1] ;
7041
7042 if (!args) SWIG_fail;
7043 swig_obj[0] = args;
7044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7045 if (!SWIG_IsOK(res1)) {
7046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetParentAsWindow" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7047 }
7048 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7049 {
7050 PyThreadState* __tstate = wxPyBeginAllowThreads();
7051 result = (wxWindow *)(arg1)->GetParentAsWindow();
7052 wxPyEndAllowThreads(__tstate);
7053 if (PyErr_Occurred()) SWIG_fail;
7054 }
7055 {
7056 resultobj = wxPyMake_wxObject(result, 0);
7057 }
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 SWIGINTERN PyObject *_wrap_XmlResourceHandler_IsOfClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj = 0;
7066 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7067 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
7068 wxString *arg3 = 0 ;
7069 bool result;
7070 void *argp1 = 0 ;
7071 int res1 = 0 ;
7072 void *argp2 = 0 ;
7073 int res2 = 0 ;
7074 bool temp3 = false ;
7075 PyObject * obj0 = 0 ;
7076 PyObject * obj1 = 0 ;
7077 PyObject * obj2 = 0 ;
7078 char * kwnames[] = {
7079 (char *) "self",(char *) "node",(char *) "classname", NULL
7080 };
7081
7082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResourceHandler_IsOfClass",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7084 if (!SWIG_IsOK(res1)) {
7085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_IsOfClass" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7086 }
7087 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7088 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
7089 if (!SWIG_IsOK(res2)) {
7090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResourceHandler_IsOfClass" "', expected argument " "2"" of type '" "wxXmlNode *""'");
7091 }
7092 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
7093 {
7094 arg3 = wxString_in_helper(obj2);
7095 if (arg3 == NULL) SWIG_fail;
7096 temp3 = true;
7097 }
7098 {
7099 PyThreadState* __tstate = wxPyBeginAllowThreads();
7100 result = (bool)(arg1)->IsOfClass(arg2,(wxString const &)*arg3);
7101 wxPyEndAllowThreads(__tstate);
7102 if (PyErr_Occurred()) SWIG_fail;
7103 }
7104 {
7105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7106 }
7107 {
7108 if (temp3)
7109 delete arg3;
7110 }
7111 return resultobj;
7112 fail:
7113 {
7114 if (temp3)
7115 delete arg3;
7116 }
7117 return NULL;
7118 }
7119
7120
7121 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetNodeContent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7122 PyObject *resultobj = 0;
7123 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7124 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
7125 wxString result;
7126 void *argp1 = 0 ;
7127 int res1 = 0 ;
7128 void *argp2 = 0 ;
7129 int res2 = 0 ;
7130 PyObject * obj0 = 0 ;
7131 PyObject * obj1 = 0 ;
7132 char * kwnames[] = {
7133 (char *) "self",(char *) "node", NULL
7134 };
7135
7136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_GetNodeContent",kwnames,&obj0,&obj1)) SWIG_fail;
7137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7138 if (!SWIG_IsOK(res1)) {
7139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetNodeContent" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7140 }
7141 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7142 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
7143 if (!SWIG_IsOK(res2)) {
7144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResourceHandler_GetNodeContent" "', expected argument " "2"" of type '" "wxXmlNode *""'");
7145 }
7146 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
7147 {
7148 PyThreadState* __tstate = wxPyBeginAllowThreads();
7149 result = (arg1)->GetNodeContent(arg2);
7150 wxPyEndAllowThreads(__tstate);
7151 if (PyErr_Occurred()) SWIG_fail;
7152 }
7153 {
7154 #if wxUSE_UNICODE
7155 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7156 #else
7157 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7158 #endif
7159 }
7160 return resultobj;
7161 fail:
7162 return NULL;
7163 }
7164
7165
7166 SWIGINTERN PyObject *_wrap_XmlResourceHandler_HasParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7167 PyObject *resultobj = 0;
7168 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7169 wxString *arg2 = 0 ;
7170 bool result;
7171 void *argp1 = 0 ;
7172 int res1 = 0 ;
7173 bool temp2 = false ;
7174 PyObject * obj0 = 0 ;
7175 PyObject * obj1 = 0 ;
7176 char * kwnames[] = {
7177 (char *) "self",(char *) "param", NULL
7178 };
7179
7180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_HasParam",kwnames,&obj0,&obj1)) SWIG_fail;
7181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7182 if (!SWIG_IsOK(res1)) {
7183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_HasParam" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7184 }
7185 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7186 {
7187 arg2 = wxString_in_helper(obj1);
7188 if (arg2 == NULL) SWIG_fail;
7189 temp2 = true;
7190 }
7191 {
7192 PyThreadState* __tstate = wxPyBeginAllowThreads();
7193 result = (bool)(arg1)->HasParam((wxString const &)*arg2);
7194 wxPyEndAllowThreads(__tstate);
7195 if (PyErr_Occurred()) SWIG_fail;
7196 }
7197 {
7198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7199 }
7200 {
7201 if (temp2)
7202 delete arg2;
7203 }
7204 return resultobj;
7205 fail:
7206 {
7207 if (temp2)
7208 delete arg2;
7209 }
7210 return NULL;
7211 }
7212
7213
7214 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetParamNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7215 PyObject *resultobj = 0;
7216 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7217 wxString *arg2 = 0 ;
7218 wxXmlNode *result = 0 ;
7219 void *argp1 = 0 ;
7220 int res1 = 0 ;
7221 bool temp2 = false ;
7222 PyObject * obj0 = 0 ;
7223 PyObject * obj1 = 0 ;
7224 char * kwnames[] = {
7225 (char *) "self",(char *) "param", NULL
7226 };
7227
7228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_GetParamNode",kwnames,&obj0,&obj1)) SWIG_fail;
7229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7230 if (!SWIG_IsOK(res1)) {
7231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetParamNode" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7232 }
7233 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7234 {
7235 arg2 = wxString_in_helper(obj1);
7236 if (arg2 == NULL) SWIG_fail;
7237 temp2 = true;
7238 }
7239 {
7240 PyThreadState* __tstate = wxPyBeginAllowThreads();
7241 result = (wxXmlNode *)(arg1)->GetParamNode((wxString const &)*arg2);
7242 wxPyEndAllowThreads(__tstate);
7243 if (PyErr_Occurred()) SWIG_fail;
7244 }
7245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlNode, 0 | 0 );
7246 {
7247 if (temp2)
7248 delete arg2;
7249 }
7250 return resultobj;
7251 fail:
7252 {
7253 if (temp2)
7254 delete arg2;
7255 }
7256 return NULL;
7257 }
7258
7259
7260 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetParamValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7261 PyObject *resultobj = 0;
7262 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7263 wxString *arg2 = 0 ;
7264 wxString result;
7265 void *argp1 = 0 ;
7266 int res1 = 0 ;
7267 bool temp2 = false ;
7268 PyObject * obj0 = 0 ;
7269 PyObject * obj1 = 0 ;
7270 char * kwnames[] = {
7271 (char *) "self",(char *) "param", NULL
7272 };
7273
7274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_GetParamValue",kwnames,&obj0,&obj1)) SWIG_fail;
7275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7276 if (!SWIG_IsOK(res1)) {
7277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetParamValue" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7278 }
7279 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7280 {
7281 arg2 = wxString_in_helper(obj1);
7282 if (arg2 == NULL) SWIG_fail;
7283 temp2 = true;
7284 }
7285 {
7286 PyThreadState* __tstate = wxPyBeginAllowThreads();
7287 result = (arg1)->GetParamValue((wxString const &)*arg2);
7288 wxPyEndAllowThreads(__tstate);
7289 if (PyErr_Occurred()) SWIG_fail;
7290 }
7291 {
7292 #if wxUSE_UNICODE
7293 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7294 #else
7295 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7296 #endif
7297 }
7298 {
7299 if (temp2)
7300 delete arg2;
7301 }
7302 return resultobj;
7303 fail:
7304 {
7305 if (temp2)
7306 delete arg2;
7307 }
7308 return NULL;
7309 }
7310
7311
7312 SWIGINTERN PyObject *_wrap_XmlResourceHandler_AddStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7313 PyObject *resultobj = 0;
7314 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7315 wxString *arg2 = 0 ;
7316 int arg3 ;
7317 void *argp1 = 0 ;
7318 int res1 = 0 ;
7319 bool temp2 = false ;
7320 int val3 ;
7321 int ecode3 = 0 ;
7322 PyObject * obj0 = 0 ;
7323 PyObject * obj1 = 0 ;
7324 PyObject * obj2 = 0 ;
7325 char * kwnames[] = {
7326 (char *) "self",(char *) "name",(char *) "value", NULL
7327 };
7328
7329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResourceHandler_AddStyle",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7331 if (!SWIG_IsOK(res1)) {
7332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_AddStyle" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7333 }
7334 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7335 {
7336 arg2 = wxString_in_helper(obj1);
7337 if (arg2 == NULL) SWIG_fail;
7338 temp2 = true;
7339 }
7340 ecode3 = SWIG_AsVal_int(obj2, &val3);
7341 if (!SWIG_IsOK(ecode3)) {
7342 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XmlResourceHandler_AddStyle" "', expected argument " "3"" of type '" "int""'");
7343 }
7344 arg3 = static_cast< int >(val3);
7345 {
7346 PyThreadState* __tstate = wxPyBeginAllowThreads();
7347 (arg1)->AddStyle((wxString const &)*arg2,arg3);
7348 wxPyEndAllowThreads(__tstate);
7349 if (PyErr_Occurred()) SWIG_fail;
7350 }
7351 resultobj = SWIG_Py_Void();
7352 {
7353 if (temp2)
7354 delete arg2;
7355 }
7356 return resultobj;
7357 fail:
7358 {
7359 if (temp2)
7360 delete arg2;
7361 }
7362 return NULL;
7363 }
7364
7365
7366 SWIGINTERN PyObject *_wrap_XmlResourceHandler_AddWindowStyles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7367 PyObject *resultobj = 0;
7368 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7369 void *argp1 = 0 ;
7370 int res1 = 0 ;
7371 PyObject *swig_obj[1] ;
7372
7373 if (!args) SWIG_fail;
7374 swig_obj[0] = args;
7375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7376 if (!SWIG_IsOK(res1)) {
7377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_AddWindowStyles" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7378 }
7379 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7380 {
7381 PyThreadState* __tstate = wxPyBeginAllowThreads();
7382 (arg1)->AddWindowStyles();
7383 wxPyEndAllowThreads(__tstate);
7384 if (PyErr_Occurred()) SWIG_fail;
7385 }
7386 resultobj = SWIG_Py_Void();
7387 return resultobj;
7388 fail:
7389 return NULL;
7390 }
7391
7392
7393 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7394 PyObject *resultobj = 0;
7395 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7396 wxString const &arg2_defvalue = wxPyStyleString ;
7397 wxString *arg2 = (wxString *) &arg2_defvalue ;
7398 int arg3 = (int) 0 ;
7399 int result;
7400 void *argp1 = 0 ;
7401 int res1 = 0 ;
7402 bool temp2 = false ;
7403 int val3 ;
7404 int ecode3 = 0 ;
7405 PyObject * obj0 = 0 ;
7406 PyObject * obj1 = 0 ;
7407 PyObject * obj2 = 0 ;
7408 char * kwnames[] = {
7409 (char *) "self",(char *) "param",(char *) "defaults", NULL
7410 };
7411
7412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:XmlResourceHandler_GetStyle",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7414 if (!SWIG_IsOK(res1)) {
7415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetStyle" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7416 }
7417 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7418 if (obj1) {
7419 {
7420 arg2 = wxString_in_helper(obj1);
7421 if (arg2 == NULL) SWIG_fail;
7422 temp2 = true;
7423 }
7424 }
7425 if (obj2) {
7426 ecode3 = SWIG_AsVal_int(obj2, &val3);
7427 if (!SWIG_IsOK(ecode3)) {
7428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XmlResourceHandler_GetStyle" "', expected argument " "3"" of type '" "int""'");
7429 }
7430 arg3 = static_cast< int >(val3);
7431 }
7432 {
7433 PyThreadState* __tstate = wxPyBeginAllowThreads();
7434 result = (int)(arg1)->GetStyle((wxString const &)*arg2,arg3);
7435 wxPyEndAllowThreads(__tstate);
7436 if (PyErr_Occurred()) SWIG_fail;
7437 }
7438 resultobj = SWIG_From_int(static_cast< int >(result));
7439 {
7440 if (temp2)
7441 delete arg2;
7442 }
7443 return resultobj;
7444 fail:
7445 {
7446 if (temp2)
7447 delete arg2;
7448 }
7449 return NULL;
7450 }
7451
7452
7453 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7454 PyObject *resultobj = 0;
7455 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7456 wxString *arg2 = 0 ;
7457 bool arg3 = (bool) true ;
7458 wxString result;
7459 void *argp1 = 0 ;
7460 int res1 = 0 ;
7461 bool temp2 = false ;
7462 bool val3 ;
7463 int ecode3 = 0 ;
7464 PyObject * obj0 = 0 ;
7465 PyObject * obj1 = 0 ;
7466 PyObject * obj2 = 0 ;
7467 char * kwnames[] = {
7468 (char *) "self",(char *) "param",(char *) "translate", NULL
7469 };
7470
7471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_GetText",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7473 if (!SWIG_IsOK(res1)) {
7474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetText" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7475 }
7476 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7477 {
7478 arg2 = wxString_in_helper(obj1);
7479 if (arg2 == NULL) SWIG_fail;
7480 temp2 = true;
7481 }
7482 if (obj2) {
7483 ecode3 = SWIG_AsVal_bool(obj2, &val3);
7484 if (!SWIG_IsOK(ecode3)) {
7485 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XmlResourceHandler_GetText" "', expected argument " "3"" of type '" "bool""'");
7486 }
7487 arg3 = static_cast< bool >(val3);
7488 }
7489 {
7490 PyThreadState* __tstate = wxPyBeginAllowThreads();
7491 result = (arg1)->GetText((wxString const &)*arg2,arg3);
7492 wxPyEndAllowThreads(__tstate);
7493 if (PyErr_Occurred()) SWIG_fail;
7494 }
7495 {
7496 #if wxUSE_UNICODE
7497 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7498 #else
7499 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7500 #endif
7501 }
7502 {
7503 if (temp2)
7504 delete arg2;
7505 }
7506 return resultobj;
7507 fail:
7508 {
7509 if (temp2)
7510 delete arg2;
7511 }
7512 return NULL;
7513 }
7514
7515
7516 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7517 PyObject *resultobj = 0;
7518 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7519 int result;
7520 void *argp1 = 0 ;
7521 int res1 = 0 ;
7522 PyObject *swig_obj[1] ;
7523
7524 if (!args) SWIG_fail;
7525 swig_obj[0] = args;
7526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7527 if (!SWIG_IsOK(res1)) {
7528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetID" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7529 }
7530 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7531 {
7532 PyThreadState* __tstate = wxPyBeginAllowThreads();
7533 result = (int)(arg1)->GetID();
7534 wxPyEndAllowThreads(__tstate);
7535 if (PyErr_Occurred()) SWIG_fail;
7536 }
7537 resultobj = SWIG_From_int(static_cast< int >(result));
7538 return resultobj;
7539 fail:
7540 return NULL;
7541 }
7542
7543
7544 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7545 PyObject *resultobj = 0;
7546 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7547 wxString result;
7548 void *argp1 = 0 ;
7549 int res1 = 0 ;
7550 PyObject *swig_obj[1] ;
7551
7552 if (!args) SWIG_fail;
7553 swig_obj[0] = args;
7554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7555 if (!SWIG_IsOK(res1)) {
7556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetName" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7557 }
7558 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7559 {
7560 PyThreadState* __tstate = wxPyBeginAllowThreads();
7561 result = (arg1)->GetName();
7562 wxPyEndAllowThreads(__tstate);
7563 if (PyErr_Occurred()) SWIG_fail;
7564 }
7565 {
7566 #if wxUSE_UNICODE
7567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7568 #else
7569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7570 #endif
7571 }
7572 return resultobj;
7573 fail:
7574 return NULL;
7575 }
7576
7577
7578 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7579 PyObject *resultobj = 0;
7580 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7581 wxString *arg2 = 0 ;
7582 bool arg3 = (bool) false ;
7583 bool result;
7584 void *argp1 = 0 ;
7585 int res1 = 0 ;
7586 bool temp2 = false ;
7587 bool val3 ;
7588 int ecode3 = 0 ;
7589 PyObject * obj0 = 0 ;
7590 PyObject * obj1 = 0 ;
7591 PyObject * obj2 = 0 ;
7592 char * kwnames[] = {
7593 (char *) "self",(char *) "param",(char *) "defaultv", NULL
7594 };
7595
7596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_GetBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7598 if (!SWIG_IsOK(res1)) {
7599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetBool" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7600 }
7601 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7602 {
7603 arg2 = wxString_in_helper(obj1);
7604 if (arg2 == NULL) SWIG_fail;
7605 temp2 = true;
7606 }
7607 if (obj2) {
7608 ecode3 = SWIG_AsVal_bool(obj2, &val3);
7609 if (!SWIG_IsOK(ecode3)) {
7610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XmlResourceHandler_GetBool" "', expected argument " "3"" of type '" "bool""'");
7611 }
7612 arg3 = static_cast< bool >(val3);
7613 }
7614 {
7615 PyThreadState* __tstate = wxPyBeginAllowThreads();
7616 result = (bool)(arg1)->GetBool((wxString const &)*arg2,arg3);
7617 wxPyEndAllowThreads(__tstate);
7618 if (PyErr_Occurred()) SWIG_fail;
7619 }
7620 {
7621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7622 }
7623 {
7624 if (temp2)
7625 delete arg2;
7626 }
7627 return resultobj;
7628 fail:
7629 {
7630 if (temp2)
7631 delete arg2;
7632 }
7633 return NULL;
7634 }
7635
7636
7637 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7638 PyObject *resultobj = 0;
7639 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7640 wxString *arg2 = 0 ;
7641 long arg3 = (long) 0 ;
7642 long result;
7643 void *argp1 = 0 ;
7644 int res1 = 0 ;
7645 bool temp2 = false ;
7646 long val3 ;
7647 int ecode3 = 0 ;
7648 PyObject * obj0 = 0 ;
7649 PyObject * obj1 = 0 ;
7650 PyObject * obj2 = 0 ;
7651 char * kwnames[] = {
7652 (char *) "self",(char *) "param",(char *) "defaultv", NULL
7653 };
7654
7655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_GetLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7657 if (!SWIG_IsOK(res1)) {
7658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetLong" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7659 }
7660 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7661 {
7662 arg2 = wxString_in_helper(obj1);
7663 if (arg2 == NULL) SWIG_fail;
7664 temp2 = true;
7665 }
7666 if (obj2) {
7667 ecode3 = SWIG_AsVal_long(obj2, &val3);
7668 if (!SWIG_IsOK(ecode3)) {
7669 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XmlResourceHandler_GetLong" "', expected argument " "3"" of type '" "long""'");
7670 }
7671 arg3 = static_cast< long >(val3);
7672 }
7673 {
7674 PyThreadState* __tstate = wxPyBeginAllowThreads();
7675 result = (long)(arg1)->GetLong((wxString const &)*arg2,arg3);
7676 wxPyEndAllowThreads(__tstate);
7677 if (PyErr_Occurred()) SWIG_fail;
7678 }
7679 resultobj = SWIG_From_long(static_cast< long >(result));
7680 {
7681 if (temp2)
7682 delete arg2;
7683 }
7684 return resultobj;
7685 fail:
7686 {
7687 if (temp2)
7688 delete arg2;
7689 }
7690 return NULL;
7691 }
7692
7693
7694 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7695 PyObject *resultobj = 0;
7696 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7697 wxString *arg2 = 0 ;
7698 wxColour result;
7699 void *argp1 = 0 ;
7700 int res1 = 0 ;
7701 bool temp2 = false ;
7702 PyObject * obj0 = 0 ;
7703 PyObject * obj1 = 0 ;
7704 char * kwnames[] = {
7705 (char *) "self",(char *) "param", NULL
7706 };
7707
7708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_GetColour",kwnames,&obj0,&obj1)) SWIG_fail;
7709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7710 if (!SWIG_IsOK(res1)) {
7711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetColour" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7712 }
7713 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7714 {
7715 arg2 = wxString_in_helper(obj1);
7716 if (arg2 == NULL) SWIG_fail;
7717 temp2 = true;
7718 }
7719 {
7720 PyThreadState* __tstate = wxPyBeginAllowThreads();
7721 result = (arg1)->GetColour((wxString const &)*arg2);
7722 wxPyEndAllowThreads(__tstate);
7723 if (PyErr_Occurred()) SWIG_fail;
7724 }
7725 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
7726 {
7727 if (temp2)
7728 delete arg2;
7729 }
7730 return resultobj;
7731 fail:
7732 {
7733 if (temp2)
7734 delete arg2;
7735 }
7736 return NULL;
7737 }
7738
7739
7740 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7741 PyObject *resultobj = 0;
7742 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7743 wxString const &arg2_defvalue = wxPySizeString ;
7744 wxString *arg2 = (wxString *) &arg2_defvalue ;
7745 wxSize result;
7746 void *argp1 = 0 ;
7747 int res1 = 0 ;
7748 bool temp2 = false ;
7749 PyObject * obj0 = 0 ;
7750 PyObject * obj1 = 0 ;
7751 char * kwnames[] = {
7752 (char *) "self",(char *) "param", NULL
7753 };
7754
7755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:XmlResourceHandler_GetSize",kwnames,&obj0,&obj1)) SWIG_fail;
7756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7757 if (!SWIG_IsOK(res1)) {
7758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetSize" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7759 }
7760 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7761 if (obj1) {
7762 {
7763 arg2 = wxString_in_helper(obj1);
7764 if (arg2 == NULL) SWIG_fail;
7765 temp2 = true;
7766 }
7767 }
7768 {
7769 PyThreadState* __tstate = wxPyBeginAllowThreads();
7770 result = (arg1)->GetSize((wxString const &)*arg2);
7771 wxPyEndAllowThreads(__tstate);
7772 if (PyErr_Occurred()) SWIG_fail;
7773 }
7774 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
7775 {
7776 if (temp2)
7777 delete arg2;
7778 }
7779 return resultobj;
7780 fail:
7781 {
7782 if (temp2)
7783 delete arg2;
7784 }
7785 return NULL;
7786 }
7787
7788
7789 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7790 PyObject *resultobj = 0;
7791 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7792 wxString const &arg2_defvalue = wxPyPosString ;
7793 wxString *arg2 = (wxString *) &arg2_defvalue ;
7794 wxPoint result;
7795 void *argp1 = 0 ;
7796 int res1 = 0 ;
7797 bool temp2 = false ;
7798 PyObject * obj0 = 0 ;
7799 PyObject * obj1 = 0 ;
7800 char * kwnames[] = {
7801 (char *) "self",(char *) "param", NULL
7802 };
7803
7804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:XmlResourceHandler_GetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
7805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7806 if (!SWIG_IsOK(res1)) {
7807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetPosition" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7808 }
7809 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7810 if (obj1) {
7811 {
7812 arg2 = wxString_in_helper(obj1);
7813 if (arg2 == NULL) SWIG_fail;
7814 temp2 = true;
7815 }
7816 }
7817 {
7818 PyThreadState* __tstate = wxPyBeginAllowThreads();
7819 result = (arg1)->GetPosition((wxString const &)*arg2);
7820 wxPyEndAllowThreads(__tstate);
7821 if (PyErr_Occurred()) SWIG_fail;
7822 }
7823 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7824 {
7825 if (temp2)
7826 delete arg2;
7827 }
7828 return resultobj;
7829 fail:
7830 {
7831 if (temp2)
7832 delete arg2;
7833 }
7834 return NULL;
7835 }
7836
7837
7838 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7839 PyObject *resultobj = 0;
7840 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7841 wxString *arg2 = 0 ;
7842 int arg3 = (int) 0 ;
7843 int result;
7844 void *argp1 = 0 ;
7845 int res1 = 0 ;
7846 bool temp2 = false ;
7847 int val3 ;
7848 int ecode3 = 0 ;
7849 PyObject * obj0 = 0 ;
7850 PyObject * obj1 = 0 ;
7851 PyObject * obj2 = 0 ;
7852 char * kwnames[] = {
7853 (char *) "self",(char *) "param",(char *) "defaultv", NULL
7854 };
7855
7856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_GetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7858 if (!SWIG_IsOK(res1)) {
7859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetDimension" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7860 }
7861 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7862 {
7863 arg2 = wxString_in_helper(obj1);
7864 if (arg2 == NULL) SWIG_fail;
7865 temp2 = true;
7866 }
7867 if (obj2) {
7868 ecode3 = SWIG_AsVal_int(obj2, &val3);
7869 if (!SWIG_IsOK(ecode3)) {
7870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XmlResourceHandler_GetDimension" "', expected argument " "3"" of type '" "int""'");
7871 }
7872 arg3 = static_cast< int >(val3);
7873 }
7874 {
7875 PyThreadState* __tstate = wxPyBeginAllowThreads();
7876 result = (int)(arg1)->GetDimension((wxString const &)*arg2,arg3);
7877 wxPyEndAllowThreads(__tstate);
7878 if (PyErr_Occurred()) SWIG_fail;
7879 }
7880 resultobj = SWIG_From_int(static_cast< int >(result));
7881 {
7882 if (temp2)
7883 delete arg2;
7884 }
7885 return resultobj;
7886 fail:
7887 {
7888 if (temp2)
7889 delete arg2;
7890 }
7891 return NULL;
7892 }
7893
7894
7895 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7896 PyObject *resultobj = 0;
7897 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7898 wxString const &arg2_defvalue = wxPyBitmapString ;
7899 wxString *arg2 = (wxString *) &arg2_defvalue ;
7900 wxArtClient const &arg3_defvalue = wxART_OTHER ;
7901 wxArtClient *arg3 = (wxArtClient *) &arg3_defvalue ;
7902 wxSize arg4 = (wxSize) wxDefaultSize ;
7903 wxBitmap result;
7904 void *argp1 = 0 ;
7905 int res1 = 0 ;
7906 bool temp2 = false ;
7907 void *argp3 = 0 ;
7908 int res3 = 0 ;
7909 void *argp4 ;
7910 int res4 = 0 ;
7911 PyObject * obj0 = 0 ;
7912 PyObject * obj1 = 0 ;
7913 PyObject * obj2 = 0 ;
7914 PyObject * obj3 = 0 ;
7915 char * kwnames[] = {
7916 (char *) "self",(char *) "param",(char *) "defaultArtClient",(char *) "size", NULL
7917 };
7918
7919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:XmlResourceHandler_GetBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7921 if (!SWIG_IsOK(res1)) {
7922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetBitmap" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7923 }
7924 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7925 if (obj1) {
7926 {
7927 arg2 = wxString_in_helper(obj1);
7928 if (arg2 == NULL) SWIG_fail;
7929 temp2 = true;
7930 }
7931 }
7932 if (obj2) {
7933 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxArtClient, 0 | 0);
7934 if (!SWIG_IsOK(res3)) {
7935 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResourceHandler_GetBitmap" "', expected argument " "3"" of type '" "wxArtClient const &""'");
7936 }
7937 if (!argp3) {
7938 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XmlResourceHandler_GetBitmap" "', expected argument " "3"" of type '" "wxArtClient const &""'");
7939 }
7940 arg3 = reinterpret_cast< wxArtClient * >(argp3);
7941 }
7942 if (obj3) {
7943 {
7944 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxSize, 0 | 0);
7945 if (!SWIG_IsOK(res4)) {
7946 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "XmlResourceHandler_GetBitmap" "', expected argument " "4"" of type '" "wxSize""'");
7947 }
7948 if (!argp4) {
7949 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XmlResourceHandler_GetBitmap" "', expected argument " "4"" of type '" "wxSize""'");
7950 } else {
7951 wxSize * temp = reinterpret_cast< wxSize * >(argp4);
7952 arg4 = *temp;
7953 if (SWIG_IsNewObj(res4)) delete temp;
7954 }
7955 }
7956 }
7957 {
7958 PyThreadState* __tstate = wxPyBeginAllowThreads();
7959 result = (arg1)->GetBitmap((wxString const &)*arg2,(wxArtClient const &)*arg3,arg4);
7960 wxPyEndAllowThreads(__tstate);
7961 if (PyErr_Occurred()) SWIG_fail;
7962 }
7963 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
7964 {
7965 if (temp2)
7966 delete arg2;
7967 }
7968 return resultobj;
7969 fail:
7970 {
7971 if (temp2)
7972 delete arg2;
7973 }
7974 return NULL;
7975 }
7976
7977
7978 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7979 PyObject *resultobj = 0;
7980 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7981 wxString const &arg2_defvalue = wxPyIconString ;
7982 wxString *arg2 = (wxString *) &arg2_defvalue ;
7983 wxArtClient const &arg3_defvalue = wxART_OTHER ;
7984 wxArtClient *arg3 = (wxArtClient *) &arg3_defvalue ;
7985 wxSize arg4 = (wxSize) wxDefaultSize ;
7986 wxIcon result;
7987 void *argp1 = 0 ;
7988 int res1 = 0 ;
7989 bool temp2 = false ;
7990 void *argp3 = 0 ;
7991 int res3 = 0 ;
7992 void *argp4 ;
7993 int res4 = 0 ;
7994 PyObject * obj0 = 0 ;
7995 PyObject * obj1 = 0 ;
7996 PyObject * obj2 = 0 ;
7997 PyObject * obj3 = 0 ;
7998 char * kwnames[] = {
7999 (char *) "self",(char *) "param",(char *) "defaultArtClient",(char *) "size", NULL
8000 };
8001
8002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:XmlResourceHandler_GetIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
8004 if (!SWIG_IsOK(res1)) {
8005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetIcon" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
8006 }
8007 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
8008 if (obj1) {
8009 {
8010 arg2 = wxString_in_helper(obj1);
8011 if (arg2 == NULL) SWIG_fail;
8012 temp2 = true;
8013 }
8014 }
8015 if (obj2) {
8016 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxArtClient, 0 | 0);
8017 if (!SWIG_IsOK(res3)) {
8018 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResourceHandler_GetIcon" "', expected argument " "3"" of type '" "wxArtClient const &""'");
8019 }
8020 if (!argp3) {
8021 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XmlResourceHandler_GetIcon" "', expected argument " "3"" of type '" "wxArtClient const &""'");
8022 }
8023 arg3 = reinterpret_cast< wxArtClient * >(argp3);
8024 }
8025 if (obj3) {
8026 {
8027 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxSize, 0 | 0);
8028 if (!SWIG_IsOK(res4)) {
8029 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "XmlResourceHandler_GetIcon" "', expected argument " "4"" of type '" "wxSize""'");
8030 }
8031 if (!argp4) {
8032 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XmlResourceHandler_GetIcon" "', expected argument " "4"" of type '" "wxSize""'");
8033 } else {
8034 wxSize * temp = reinterpret_cast< wxSize * >(argp4);
8035 arg4 = *temp;
8036 if (SWIG_IsNewObj(res4)) delete temp;
8037 }
8038 }
8039 }
8040 {
8041 PyThreadState* __tstate = wxPyBeginAllowThreads();
8042 result = (arg1)->GetIcon((wxString const &)*arg2,(wxArtClient const &)*arg3,arg4);
8043 wxPyEndAllowThreads(__tstate);
8044 if (PyErr_Occurred()) SWIG_fail;
8045 }
8046 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
8047 {
8048 if (temp2)
8049 delete arg2;
8050 }
8051 return resultobj;
8052 fail:
8053 {
8054 if (temp2)
8055 delete arg2;
8056 }
8057 return NULL;
8058 }
8059
8060
8061 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8062 PyObject *resultobj = 0;
8063 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
8064 wxString const &arg2_defvalue = wxPyFontString ;
8065 wxString *arg2 = (wxString *) &arg2_defvalue ;
8066 wxFont result;
8067 void *argp1 = 0 ;
8068 int res1 = 0 ;
8069 bool temp2 = false ;
8070 PyObject * obj0 = 0 ;
8071 PyObject * obj1 = 0 ;
8072 char * kwnames[] = {
8073 (char *) "self",(char *) "param", NULL
8074 };
8075
8076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:XmlResourceHandler_GetFont",kwnames,&obj0,&obj1)) SWIG_fail;
8077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
8078 if (!SWIG_IsOK(res1)) {
8079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetFont" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
8080 }
8081 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
8082 if (obj1) {
8083 {
8084 arg2 = wxString_in_helper(obj1);
8085 if (arg2 == NULL) SWIG_fail;
8086 temp2 = true;
8087 }
8088 }
8089 {
8090 PyThreadState* __tstate = wxPyBeginAllowThreads();
8091 result = (arg1)->GetFont((wxString const &)*arg2);
8092 wxPyEndAllowThreads(__tstate);
8093 if (PyErr_Occurred()) SWIG_fail;
8094 }
8095 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
8096 {
8097 if (temp2)
8098 delete arg2;
8099 }
8100 return resultobj;
8101 fail:
8102 {
8103 if (temp2)
8104 delete arg2;
8105 }
8106 return NULL;
8107 }
8108
8109
8110 SWIGINTERN PyObject *_wrap_XmlResourceHandler_SetupWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8111 PyObject *resultobj = 0;
8112 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
8113 wxWindow *arg2 = (wxWindow *) 0 ;
8114 void *argp1 = 0 ;
8115 int res1 = 0 ;
8116 void *argp2 = 0 ;
8117 int res2 = 0 ;
8118 PyObject * obj0 = 0 ;
8119 PyObject * obj1 = 0 ;
8120 char * kwnames[] = {
8121 (char *) "self",(char *) "wnd", NULL
8122 };
8123
8124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_SetupWindow",kwnames,&obj0,&obj1)) SWIG_fail;
8125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
8126 if (!SWIG_IsOK(res1)) {
8127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_SetupWindow" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
8128 }
8129 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
8130 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
8131 if (!SWIG_IsOK(res2)) {
8132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResourceHandler_SetupWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
8133 }
8134 arg2 = reinterpret_cast< wxWindow * >(argp2);
8135 {
8136 PyThreadState* __tstate = wxPyBeginAllowThreads();
8137 (arg1)->SetupWindow(arg2);
8138 wxPyEndAllowThreads(__tstate);
8139 if (PyErr_Occurred()) SWIG_fail;
8140 }
8141 resultobj = SWIG_Py_Void();
8142 return resultobj;
8143 fail:
8144 return NULL;
8145 }
8146
8147
8148 SWIGINTERN PyObject *_wrap_XmlResourceHandler_CreateChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8149 PyObject *resultobj = 0;
8150 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
8151 wxObject *arg2 = (wxObject *) 0 ;
8152 bool arg3 = (bool) false ;
8153 void *argp1 = 0 ;
8154 int res1 = 0 ;
8155 void *argp2 = 0 ;
8156 int res2 = 0 ;
8157 bool val3 ;
8158 int ecode3 = 0 ;
8159 PyObject * obj0 = 0 ;
8160 PyObject * obj1 = 0 ;
8161 PyObject * obj2 = 0 ;
8162 char * kwnames[] = {
8163 (char *) "self",(char *) "parent",(char *) "this_hnd_only", NULL
8164 };
8165
8166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_CreateChildren",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
8168 if (!SWIG_IsOK(res1)) {
8169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_CreateChildren" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
8170 }
8171 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
8172 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
8173 if (!SWIG_IsOK(res2)) {
8174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResourceHandler_CreateChildren" "', expected argument " "2"" of type '" "wxObject *""'");
8175 }
8176 arg2 = reinterpret_cast< wxObject * >(argp2);
8177 if (obj2) {
8178 ecode3 = SWIG_AsVal_bool(obj2, &val3);
8179 if (!SWIG_IsOK(ecode3)) {
8180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XmlResourceHandler_CreateChildren" "', expected argument " "3"" of type '" "bool""'");
8181 }
8182 arg3 = static_cast< bool >(val3);
8183 }
8184 {
8185 PyThreadState* __tstate = wxPyBeginAllowThreads();
8186 (arg1)->CreateChildren(arg2,arg3);
8187 wxPyEndAllowThreads(__tstate);
8188 if (PyErr_Occurred()) SWIG_fail;
8189 }
8190 resultobj = SWIG_Py_Void();
8191 return resultobj;
8192 fail:
8193 return NULL;
8194 }
8195
8196
8197 SWIGINTERN PyObject *_wrap_XmlResourceHandler_CreateChildrenPrivately(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8198 PyObject *resultobj = 0;
8199 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
8200 wxObject *arg2 = (wxObject *) 0 ;
8201 wxXmlNode *arg3 = (wxXmlNode *) NULL ;
8202 void *argp1 = 0 ;
8203 int res1 = 0 ;
8204 void *argp2 = 0 ;
8205 int res2 = 0 ;
8206 void *argp3 = 0 ;
8207 int res3 = 0 ;
8208 PyObject * obj0 = 0 ;
8209 PyObject * obj1 = 0 ;
8210 PyObject * obj2 = 0 ;
8211 char * kwnames[] = {
8212 (char *) "self",(char *) "parent",(char *) "rootnode", NULL
8213 };
8214
8215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_CreateChildrenPrivately",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
8217 if (!SWIG_IsOK(res1)) {
8218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_CreateChildrenPrivately" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
8219 }
8220 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
8221 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
8222 if (!SWIG_IsOK(res2)) {
8223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResourceHandler_CreateChildrenPrivately" "', expected argument " "2"" of type '" "wxObject *""'");
8224 }
8225 arg2 = reinterpret_cast< wxObject * >(argp2);
8226 if (obj2) {
8227 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxXmlNode, 0 | 0 );
8228 if (!SWIG_IsOK(res3)) {
8229 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResourceHandler_CreateChildrenPrivately" "', expected argument " "3"" of type '" "wxXmlNode *""'");
8230 }
8231 arg3 = reinterpret_cast< wxXmlNode * >(argp3);
8232 }
8233 {
8234 PyThreadState* __tstate = wxPyBeginAllowThreads();
8235 (arg1)->CreateChildrenPrivately(arg2,arg3);
8236 wxPyEndAllowThreads(__tstate);
8237 if (PyErr_Occurred()) SWIG_fail;
8238 }
8239 resultobj = SWIG_Py_Void();
8240 return resultobj;
8241 fail:
8242 return NULL;
8243 }
8244
8245
8246 SWIGINTERN PyObject *_wrap_XmlResourceHandler_CreateResFromNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8247 PyObject *resultobj = 0;
8248 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
8249 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
8250 wxObject *arg3 = (wxObject *) 0 ;
8251 wxObject *arg4 = (wxObject *) NULL ;
8252 wxObject *result = 0 ;
8253 void *argp1 = 0 ;
8254 int res1 = 0 ;
8255 void *argp2 = 0 ;
8256 int res2 = 0 ;
8257 void *argp3 = 0 ;
8258 int res3 = 0 ;
8259 void *argp4 = 0 ;
8260 int res4 = 0 ;
8261 PyObject * obj0 = 0 ;
8262 PyObject * obj1 = 0 ;
8263 PyObject * obj2 = 0 ;
8264 PyObject * obj3 = 0 ;
8265 char * kwnames[] = {
8266 (char *) "self",(char *) "node",(char *) "parent",(char *) "instance", NULL
8267 };
8268
8269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:XmlResourceHandler_CreateResFromNode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
8271 if (!SWIG_IsOK(res1)) {
8272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_CreateResFromNode" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
8273 }
8274 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
8275 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
8276 if (!SWIG_IsOK(res2)) {
8277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResourceHandler_CreateResFromNode" "', expected argument " "2"" of type '" "wxXmlNode *""'");
8278 }
8279 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
8280 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
8281 if (!SWIG_IsOK(res3)) {
8282 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResourceHandler_CreateResFromNode" "', expected argument " "3"" of type '" "wxObject *""'");
8283 }
8284 arg3 = reinterpret_cast< wxObject * >(argp3);
8285 if (obj3) {
8286 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxObject, 0 | 0 );
8287 if (!SWIG_IsOK(res4)) {
8288 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "XmlResourceHandler_CreateResFromNode" "', expected argument " "4"" of type '" "wxObject *""'");
8289 }
8290 arg4 = reinterpret_cast< wxObject * >(argp4);
8291 }
8292 {
8293 PyThreadState* __tstate = wxPyBeginAllowThreads();
8294 result = (wxObject *)(arg1)->CreateResFromNode(arg2,arg3,arg4);
8295 wxPyEndAllowThreads(__tstate);
8296 if (PyErr_Occurred()) SWIG_fail;
8297 }
8298 {
8299 resultobj = wxPyMake_wxObject(result, (bool)0);
8300 }
8301 return resultobj;
8302 fail:
8303 return NULL;
8304 }
8305
8306
8307 SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetCurFileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8308 PyObject *resultobj = 0;
8309 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
8310 wxFileSystem *result = 0 ;
8311 void *argp1 = 0 ;
8312 int res1 = 0 ;
8313 PyObject *swig_obj[1] ;
8314
8315 if (!args) SWIG_fail;
8316 swig_obj[0] = args;
8317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
8318 if (!SWIG_IsOK(res1)) {
8319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetCurFileSystem" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
8320 }
8321 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
8322 {
8323 PyThreadState* __tstate = wxPyBeginAllowThreads();
8324 {
8325 wxFileSystem &_result_ref = (arg1)->GetCurFileSystem();
8326 result = (wxFileSystem *) &_result_ref;
8327 }
8328 wxPyEndAllowThreads(__tstate);
8329 if (PyErr_Occurred()) SWIG_fail;
8330 }
8331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, 0 | 0 );
8332 return resultobj;
8333 fail:
8334 return NULL;
8335 }
8336
8337
8338 SWIGINTERN PyObject *XmlResourceHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8339 PyObject *obj;
8340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8341 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_NewClientData(obj));
8342 return SWIG_Py_Void();
8343 }
8344
8345 SWIGINTERN PyObject *XmlResourceHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8346 return SWIG_Python_InitShadowInstance(args);
8347 }
8348
8349 static PyMethodDef SwigMethods[] = {
8350 { (char *)"new_XmlResource", (PyCFunction) _wrap_new_XmlResource, METH_VARARGS | METH_KEYWORDS, NULL},
8351 { (char *)"new_EmptyXmlResource", (PyCFunction) _wrap_new_EmptyXmlResource, METH_VARARGS | METH_KEYWORDS, NULL},
8352 { (char *)"delete_XmlResource", (PyCFunction)_wrap_delete_XmlResource, METH_O, NULL},
8353 { (char *)"XmlResource_Load", (PyCFunction) _wrap_XmlResource_Load, METH_VARARGS | METH_KEYWORDS, NULL},
8354 { (char *)"XmlResource_LoadFromString", (PyCFunction) _wrap_XmlResource_LoadFromString, METH_VARARGS | METH_KEYWORDS, NULL},
8355 { (char *)"XmlResource_Unload", (PyCFunction) _wrap_XmlResource_Unload, METH_VARARGS | METH_KEYWORDS, NULL},
8356 { (char *)"XmlResource_InitAllHandlers", (PyCFunction)_wrap_XmlResource_InitAllHandlers, METH_O, NULL},
8357 { (char *)"XmlResource_AddHandler", (PyCFunction) _wrap_XmlResource_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
8358 { (char *)"XmlResource_InsertHandler", (PyCFunction) _wrap_XmlResource_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
8359 { (char *)"XmlResource_ClearHandlers", (PyCFunction)_wrap_XmlResource_ClearHandlers, METH_O, NULL},
8360 { (char *)"XmlResource_AddSubclassFactory", (PyCFunction) _wrap_XmlResource_AddSubclassFactory, METH_VARARGS | METH_KEYWORDS, NULL},
8361 { (char *)"XmlResource_LoadMenu", (PyCFunction) _wrap_XmlResource_LoadMenu, METH_VARARGS | METH_KEYWORDS, NULL},
8362 { (char *)"XmlResource_LoadMenuBar", (PyCFunction) _wrap_XmlResource_LoadMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
8363 { (char *)"XmlResource_LoadMenuBarOnFrame", (PyCFunction) _wrap_XmlResource_LoadMenuBarOnFrame, METH_VARARGS | METH_KEYWORDS, NULL},
8364 { (char *)"XmlResource_LoadToolBar", (PyCFunction) _wrap_XmlResource_LoadToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
8365 { (char *)"XmlResource_LoadDialog", (PyCFunction) _wrap_XmlResource_LoadDialog, METH_VARARGS | METH_KEYWORDS, NULL},
8366 { (char *)"XmlResource_LoadOnDialog", (PyCFunction) _wrap_XmlResource_LoadOnDialog, METH_VARARGS | METH_KEYWORDS, NULL},
8367 { (char *)"XmlResource_LoadPanel", (PyCFunction) _wrap_XmlResource_LoadPanel, METH_VARARGS | METH_KEYWORDS, NULL},
8368 { (char *)"XmlResource_LoadOnPanel", (PyCFunction) _wrap_XmlResource_LoadOnPanel, METH_VARARGS | METH_KEYWORDS, NULL},
8369 { (char *)"XmlResource_LoadFrame", (PyCFunction) _wrap_XmlResource_LoadFrame, METH_VARARGS | METH_KEYWORDS, NULL},
8370 { (char *)"XmlResource_LoadOnFrame", (PyCFunction) _wrap_XmlResource_LoadOnFrame, METH_VARARGS | METH_KEYWORDS, NULL},
8371 { (char *)"XmlResource_LoadObject", (PyCFunction) _wrap_XmlResource_LoadObject, METH_VARARGS | METH_KEYWORDS, NULL},
8372 { (char *)"XmlResource_LoadOnObject", (PyCFunction) _wrap_XmlResource_LoadOnObject, METH_VARARGS | METH_KEYWORDS, NULL},
8373 { (char *)"XmlResource_LoadBitmap", (PyCFunction) _wrap_XmlResource_LoadBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
8374 { (char *)"XmlResource_LoadIcon", (PyCFunction) _wrap_XmlResource_LoadIcon, METH_VARARGS | METH_KEYWORDS, NULL},
8375 { (char *)"XmlResource_AttachUnknownControl", (PyCFunction) _wrap_XmlResource_AttachUnknownControl, METH_VARARGS | METH_KEYWORDS, NULL},
8376 { (char *)"XmlResource_GetXRCID", (PyCFunction) _wrap_XmlResource_GetXRCID, METH_VARARGS | METH_KEYWORDS, NULL},
8377 { (char *)"XmlResource_GetVersion", (PyCFunction)_wrap_XmlResource_GetVersion, METH_O, NULL},
8378 { (char *)"XmlResource_CompareVersion", (PyCFunction) _wrap_XmlResource_CompareVersion, METH_VARARGS | METH_KEYWORDS, NULL},
8379 { (char *)"XmlResource_Get", (PyCFunction)_wrap_XmlResource_Get, METH_NOARGS, NULL},
8380 { (char *)"XmlResource_Set", (PyCFunction) _wrap_XmlResource_Set, METH_VARARGS | METH_KEYWORDS, NULL},
8381 { (char *)"XmlResource_GetFlags", (PyCFunction)_wrap_XmlResource_GetFlags, METH_O, NULL},
8382 { (char *)"XmlResource_SetFlags", (PyCFunction) _wrap_XmlResource_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
8383 { (char *)"XmlResource_swigregister", XmlResource_swigregister, METH_VARARGS, NULL},
8384 { (char *)"XmlResource_swiginit", XmlResource_swiginit, METH_VARARGS, NULL},
8385 { (char *)"new_XmlSubclassFactory", (PyCFunction)_wrap_new_XmlSubclassFactory, METH_NOARGS, NULL},
8386 { (char *)"XmlSubclassFactory__setCallbackInfo", (PyCFunction) _wrap_XmlSubclassFactory__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
8387 { (char *)"XmlSubclassFactory_swigregister", XmlSubclassFactory_swigregister, METH_VARARGS, NULL},
8388 { (char *)"XmlSubclassFactory_swiginit", XmlSubclassFactory_swiginit, METH_VARARGS, NULL},
8389 { (char *)"new_XmlProperty", (PyCFunction) _wrap_new_XmlProperty, METH_VARARGS | METH_KEYWORDS, NULL},
8390 { (char *)"XmlProperty_GetName", (PyCFunction)_wrap_XmlProperty_GetName, METH_O, NULL},
8391 { (char *)"XmlProperty_GetValue", (PyCFunction)_wrap_XmlProperty_GetValue, METH_O, NULL},
8392 { (char *)"XmlProperty_GetNext", (PyCFunction)_wrap_XmlProperty_GetNext, METH_O, NULL},
8393 { (char *)"XmlProperty_SetName", (PyCFunction) _wrap_XmlProperty_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
8394 { (char *)"XmlProperty_SetValue", (PyCFunction) _wrap_XmlProperty_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
8395 { (char *)"XmlProperty_SetNext", (PyCFunction) _wrap_XmlProperty_SetNext, METH_VARARGS | METH_KEYWORDS, NULL},
8396 { (char *)"XmlProperty_swigregister", XmlProperty_swigregister, METH_VARARGS, NULL},
8397 { (char *)"XmlProperty_swiginit", XmlProperty_swiginit, METH_VARARGS, NULL},
8398 { (char *)"new_XmlNode", (PyCFunction) _wrap_new_XmlNode, METH_VARARGS | METH_KEYWORDS, NULL},
8399 { (char *)"delete_XmlNode", (PyCFunction)_wrap_delete_XmlNode, METH_O, NULL},
8400 { (char *)"new_XmlNodeEasy", (PyCFunction) _wrap_new_XmlNodeEasy, METH_VARARGS | METH_KEYWORDS, NULL},
8401 { (char *)"XmlNode_AddChild", (PyCFunction) _wrap_XmlNode_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
8402 { (char *)"XmlNode_InsertChild", (PyCFunction) _wrap_XmlNode_InsertChild, METH_VARARGS | METH_KEYWORDS, NULL},
8403 { (char *)"XmlNode_RemoveChild", (PyCFunction) _wrap_XmlNode_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
8404 { (char *)"XmlNode_AddProperty", (PyCFunction) _wrap_XmlNode_AddProperty, METH_VARARGS | METH_KEYWORDS, NULL},
8405 { (char *)"XmlNode_AddPropertyName", (PyCFunction) _wrap_XmlNode_AddPropertyName, METH_VARARGS | METH_KEYWORDS, NULL},
8406 { (char *)"XmlNode_DeleteProperty", (PyCFunction) _wrap_XmlNode_DeleteProperty, METH_VARARGS | METH_KEYWORDS, NULL},
8407 { (char *)"XmlNode_GetType", (PyCFunction)_wrap_XmlNode_GetType, METH_O, NULL},
8408 { (char *)"XmlNode_GetName", (PyCFunction)_wrap_XmlNode_GetName, METH_O, NULL},
8409 { (char *)"XmlNode_GetContent", (PyCFunction)_wrap_XmlNode_GetContent, METH_O, NULL},
8410 { (char *)"XmlNode_GetParent", (PyCFunction)_wrap_XmlNode_GetParent, METH_O, NULL},
8411 { (char *)"XmlNode_GetNext", (PyCFunction)_wrap_XmlNode_GetNext, METH_O, NULL},
8412 { (char *)"XmlNode_GetChildren", (PyCFunction)_wrap_XmlNode_GetChildren, METH_O, NULL},
8413 { (char *)"XmlNode_GetProperties", (PyCFunction)_wrap_XmlNode_GetProperties, METH_O, NULL},
8414 { (char *)"XmlNode_GetPropVal", (PyCFunction) _wrap_XmlNode_GetPropVal, METH_VARARGS | METH_KEYWORDS, NULL},
8415 { (char *)"XmlNode_HasProp", (PyCFunction) _wrap_XmlNode_HasProp, METH_VARARGS | METH_KEYWORDS, NULL},
8416 { (char *)"XmlNode_SetType", (PyCFunction) _wrap_XmlNode_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
8417 { (char *)"XmlNode_SetName", (PyCFunction) _wrap_XmlNode_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
8418 { (char *)"XmlNode_SetContent", (PyCFunction) _wrap_XmlNode_SetContent, METH_VARARGS | METH_KEYWORDS, NULL},
8419 { (char *)"XmlNode_SetParent", (PyCFunction) _wrap_XmlNode_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
8420 { (char *)"XmlNode_SetNext", (PyCFunction) _wrap_XmlNode_SetNext, METH_VARARGS | METH_KEYWORDS, NULL},
8421 { (char *)"XmlNode_SetChildren", (PyCFunction) _wrap_XmlNode_SetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
8422 { (char *)"XmlNode_SetProperties", (PyCFunction) _wrap_XmlNode_SetProperties, METH_VARARGS | METH_KEYWORDS, NULL},
8423 { (char *)"XmlNode_swigregister", XmlNode_swigregister, METH_VARARGS, NULL},
8424 { (char *)"XmlNode_swiginit", XmlNode_swiginit, METH_VARARGS, NULL},
8425 { (char *)"new_XmlDocument", (PyCFunction) _wrap_new_XmlDocument, METH_VARARGS | METH_KEYWORDS, NULL},
8426 { (char *)"new_XmlDocumentFromStream", (PyCFunction) _wrap_new_XmlDocumentFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
8427 { (char *)"new_EmptyXmlDocument", (PyCFunction)_wrap_new_EmptyXmlDocument, METH_NOARGS, NULL},
8428 { (char *)"delete_XmlDocument", (PyCFunction)_wrap_delete_XmlDocument, METH_O, NULL},
8429 { (char *)"XmlDocument_Load", (PyCFunction) _wrap_XmlDocument_Load, METH_VARARGS | METH_KEYWORDS, NULL},
8430 { (char *)"XmlDocument_LoadFromStream", (PyCFunction) _wrap_XmlDocument_LoadFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
8431 { (char *)"XmlDocument_Save", (PyCFunction) _wrap_XmlDocument_Save, METH_VARARGS | METH_KEYWORDS, NULL},
8432 { (char *)"XmlDocument_SaveToStream", (PyCFunction) _wrap_XmlDocument_SaveToStream, METH_VARARGS | METH_KEYWORDS, NULL},
8433 { (char *)"XmlDocument_IsOk", (PyCFunction)_wrap_XmlDocument_IsOk, METH_O, NULL},
8434 { (char *)"XmlDocument_GetRoot", (PyCFunction)_wrap_XmlDocument_GetRoot, METH_O, NULL},
8435 { (char *)"XmlDocument_GetVersion", (PyCFunction)_wrap_XmlDocument_GetVersion, METH_O, NULL},
8436 { (char *)"XmlDocument_GetFileEncoding", (PyCFunction)_wrap_XmlDocument_GetFileEncoding, METH_O, NULL},
8437 { (char *)"XmlDocument_SetRoot", (PyCFunction) _wrap_XmlDocument_SetRoot, METH_VARARGS | METH_KEYWORDS, NULL},
8438 { (char *)"XmlDocument_SetVersion", (PyCFunction) _wrap_XmlDocument_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
8439 { (char *)"XmlDocument_SetFileEncoding", (PyCFunction) _wrap_XmlDocument_SetFileEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
8440 { (char *)"XmlDocument_swigregister", XmlDocument_swigregister, METH_VARARGS, NULL},
8441 { (char *)"XmlDocument_swiginit", XmlDocument_swiginit, METH_VARARGS, NULL},
8442 { (char *)"new_XmlResourceHandler", (PyCFunction)_wrap_new_XmlResourceHandler, METH_NOARGS, NULL},
8443 { (char *)"XmlResourceHandler__setCallbackInfo", (PyCFunction) _wrap_XmlResourceHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
8444 { (char *)"XmlResourceHandler_CreateResource", (PyCFunction) _wrap_XmlResourceHandler_CreateResource, METH_VARARGS | METH_KEYWORDS, NULL},
8445 { (char *)"XmlResourceHandler_SetParentResource", (PyCFunction) _wrap_XmlResourceHandler_SetParentResource, METH_VARARGS | METH_KEYWORDS, NULL},
8446 { (char *)"XmlResourceHandler_GetResource", (PyCFunction)_wrap_XmlResourceHandler_GetResource, METH_O, NULL},
8447 { (char *)"XmlResourceHandler_GetNode", (PyCFunction)_wrap_XmlResourceHandler_GetNode, METH_O, NULL},
8448 { (char *)"XmlResourceHandler_GetClass", (PyCFunction)_wrap_XmlResourceHandler_GetClass, METH_O, NULL},
8449 { (char *)"XmlResourceHandler_GetParent", (PyCFunction)_wrap_XmlResourceHandler_GetParent, METH_O, NULL},
8450 { (char *)"XmlResourceHandler_GetInstance", (PyCFunction)_wrap_XmlResourceHandler_GetInstance, METH_O, NULL},
8451 { (char *)"XmlResourceHandler_GetParentAsWindow", (PyCFunction)_wrap_XmlResourceHandler_GetParentAsWindow, METH_O, NULL},
8452 { (char *)"XmlResourceHandler_IsOfClass", (PyCFunction) _wrap_XmlResourceHandler_IsOfClass, METH_VARARGS | METH_KEYWORDS, NULL},
8453 { (char *)"XmlResourceHandler_GetNodeContent", (PyCFunction) _wrap_XmlResourceHandler_GetNodeContent, METH_VARARGS | METH_KEYWORDS, NULL},
8454 { (char *)"XmlResourceHandler_HasParam", (PyCFunction) _wrap_XmlResourceHandler_HasParam, METH_VARARGS | METH_KEYWORDS, NULL},
8455 { (char *)"XmlResourceHandler_GetParamNode", (PyCFunction) _wrap_XmlResourceHandler_GetParamNode, METH_VARARGS | METH_KEYWORDS, NULL},
8456 { (char *)"XmlResourceHandler_GetParamValue", (PyCFunction) _wrap_XmlResourceHandler_GetParamValue, METH_VARARGS | METH_KEYWORDS, NULL},
8457 { (char *)"XmlResourceHandler_AddStyle", (PyCFunction) _wrap_XmlResourceHandler_AddStyle, METH_VARARGS | METH_KEYWORDS, NULL},
8458 { (char *)"XmlResourceHandler_AddWindowStyles", (PyCFunction)_wrap_XmlResourceHandler_AddWindowStyles, METH_O, NULL},
8459 { (char *)"XmlResourceHandler_GetStyle", (PyCFunction) _wrap_XmlResourceHandler_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
8460 { (char *)"XmlResourceHandler_GetText", (PyCFunction) _wrap_XmlResourceHandler_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
8461 { (char *)"XmlResourceHandler_GetID", (PyCFunction)_wrap_XmlResourceHandler_GetID, METH_O, NULL},
8462 { (char *)"XmlResourceHandler_GetName", (PyCFunction)_wrap_XmlResourceHandler_GetName, METH_O, NULL},
8463 { (char *)"XmlResourceHandler_GetBool", (PyCFunction) _wrap_XmlResourceHandler_GetBool, METH_VARARGS | METH_KEYWORDS, NULL},
8464 { (char *)"XmlResourceHandler_GetLong", (PyCFunction) _wrap_XmlResourceHandler_GetLong, METH_VARARGS | METH_KEYWORDS, NULL},
8465 { (char *)"XmlResourceHandler_GetColour", (PyCFunction) _wrap_XmlResourceHandler_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
8466 { (char *)"XmlResourceHandler_GetSize", (PyCFunction) _wrap_XmlResourceHandler_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
8467 { (char *)"XmlResourceHandler_GetPosition", (PyCFunction) _wrap_XmlResourceHandler_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
8468 { (char *)"XmlResourceHandler_GetDimension", (PyCFunction) _wrap_XmlResourceHandler_GetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
8469 { (char *)"XmlResourceHandler_GetBitmap", (PyCFunction) _wrap_XmlResourceHandler_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
8470 { (char *)"XmlResourceHandler_GetIcon", (PyCFunction) _wrap_XmlResourceHandler_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
8471 { (char *)"XmlResourceHandler_GetFont", (PyCFunction) _wrap_XmlResourceHandler_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
8472 { (char *)"XmlResourceHandler_SetupWindow", (PyCFunction) _wrap_XmlResourceHandler_SetupWindow, METH_VARARGS | METH_KEYWORDS, NULL},
8473 { (char *)"XmlResourceHandler_CreateChildren", (PyCFunction) _wrap_XmlResourceHandler_CreateChildren, METH_VARARGS | METH_KEYWORDS, NULL},
8474 { (char *)"XmlResourceHandler_CreateChildrenPrivately", (PyCFunction) _wrap_XmlResourceHandler_CreateChildrenPrivately, METH_VARARGS | METH_KEYWORDS, NULL},
8475 { (char *)"XmlResourceHandler_CreateResFromNode", (PyCFunction) _wrap_XmlResourceHandler_CreateResFromNode, METH_VARARGS | METH_KEYWORDS, NULL},
8476 { (char *)"XmlResourceHandler_GetCurFileSystem", (PyCFunction)_wrap_XmlResourceHandler_GetCurFileSystem, METH_O, NULL},
8477 { (char *)"XmlResourceHandler_swigregister", XmlResourceHandler_swigregister, METH_VARARGS, NULL},
8478 { (char *)"XmlResourceHandler_swiginit", XmlResourceHandler_swiginit, METH_VARARGS, NULL},
8479 { NULL, NULL, 0, NULL }
8480 };
8481
8482
8483 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
8484
8485 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
8486 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
8487 }
8488 static void *_p_wxXmlDocumentTo_p_wxObject(void *x) {
8489 return (void *)((wxObject *) ((wxXmlDocument *) x));
8490 }
8491 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
8492 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
8493 }
8494 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
8495 return (void *)((wxObject *) ((wxSizerItem *) x));
8496 }
8497 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
8498 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
8499 }
8500 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
8501 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
8502 }
8503 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
8504 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
8505 }
8506 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
8507 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
8508 }
8509 static void *_p_wxSizerTo_p_wxObject(void *x) {
8510 return (void *)((wxObject *) ((wxSizer *) x));
8511 }
8512 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
8513 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
8514 }
8515 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
8516 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
8517 }
8518 static void *_p_wxEventTo_p_wxObject(void *x) {
8519 return (void *)((wxObject *) ((wxEvent *) x));
8520 }
8521 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
8522 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
8523 }
8524 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
8525 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
8526 }
8527 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
8528 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
8529 }
8530 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
8531 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
8532 }
8533 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
8534 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
8535 }
8536 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
8537 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
8538 }
8539 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
8540 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
8541 }
8542 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
8543 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
8544 }
8545 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
8546 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
8547 }
8548 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
8549 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
8550 }
8551 static void *_p_wxControlTo_p_wxObject(void *x) {
8552 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
8553 }
8554 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
8555 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
8556 }
8557 static void *_p_wxFSFileTo_p_wxObject(void *x) {
8558 return (void *)((wxObject *) ((wxFSFile *) x));
8559 }
8560 static void *_p_wxPySizerTo_p_wxObject(void *x) {
8561 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
8562 }
8563 static void *_p_wxPyEventTo_p_wxObject(void *x) {
8564 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
8565 }
8566 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
8567 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
8568 }
8569 static void *_p_wxShowEventTo_p_wxObject(void *x) {
8570 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
8571 }
8572 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
8573 return (void *)((wxObject *) ((wxMenuItem *) x));
8574 }
8575 static void *_p_wxDateEventTo_p_wxObject(void *x) {
8576 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
8577 }
8578 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
8579 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
8580 }
8581 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
8582 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
8583 }
8584 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
8585 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
8586 }
8587 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
8588 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
8589 }
8590 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
8591 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
8592 }
8593 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
8594 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
8595 }
8596 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
8597 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
8598 }
8599 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
8600 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
8601 }
8602 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
8603 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
8604 }
8605 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
8606 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
8607 }
8608 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
8609 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
8610 }
8611 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
8612 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
8613 }
8614 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
8615 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
8616 }
8617 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
8618 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
8619 }
8620 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
8621 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
8622 }
8623 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
8624 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
8625 }
8626 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
8627 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
8628 }
8629 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
8630 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
8631 }
8632 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
8633 return (void *)((wxObject *) ((wxImageHandler *) x));
8634 }
8635 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
8636 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
8637 }
8638 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
8639 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
8640 }
8641 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
8642 return (void *)((wxObject *) ((wxEvtHandler *) x));
8643 }
8644 static void *_p_wxPyXmlResourceHandlerTo_p_wxObject(void *x) {
8645 return (void *)((wxObject *) ((wxPyXmlResourceHandler *) x));
8646 }
8647 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
8648 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
8649 }
8650 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
8651 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
8652 }
8653 static void *_p_wxImageTo_p_wxObject(void *x) {
8654 return (void *)((wxObject *) ((wxImage *) x));
8655 }
8656 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
8657 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
8658 }
8659 static void *_p_wxXmlResourceTo_p_wxObject(void *x) {
8660 return (void *)((wxObject *) ((wxXmlResource *) x));
8661 }
8662 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
8663 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
8664 }
8665 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
8666 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
8667 }
8668 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
8669 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
8670 }
8671 static void *_p_wxWindowTo_p_wxObject(void *x) {
8672 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
8673 }
8674 static void *_p_wxMenuTo_p_wxObject(void *x) {
8675 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
8676 }
8677 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
8678 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
8679 }
8680 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
8681 return (void *)((wxObject *) ((wxFileSystem *) x));
8682 }
8683 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
8684 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
8685 }
8686 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
8687 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
8688 }
8689 static void *_p_wxPyAppTo_p_wxObject(void *x) {
8690 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
8691 }
8692 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
8693 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
8694 }
8695 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
8696 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
8697 }
8698 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
8699 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
8700 }
8701 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
8702 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
8703 }
8704 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
8705 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
8706 }
8707 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
8708 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
8709 }
8710 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
8711 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
8712 }
8713 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
8714 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
8715 }
8716 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
8717 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
8718 }
8719 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
8720 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
8721 }
8722 static void *_p_wxValidatorTo_p_wxObject(void *x) {
8723 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
8724 }
8725 static void *_p_wxControlTo_p_wxWindow(void *x) {
8726 return (void *)((wxWindow *) ((wxControl *) x));
8727 }
8728 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
8729 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
8730 }
8731 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
8732 return (void *)((wxWindow *) ((wxMenuBar *) x));
8733 }
8734 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
8735 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};
8736 static swig_type_info _swigt__p_int = {"_p_int", "int *|wxEventType *", 0, 0, (void*)0, 0};
8737 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
8738 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
8739 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
8740 static swig_type_info _swigt__p_wxArtClient = {"_p_wxArtClient", "wxArtClient *", 0, 0, (void*)0, 0};
8741 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
8742 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
8743 static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", "wxDialog *", 0, 0, (void*)0, 0};
8744 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
8745 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
8746 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
8747 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
8748 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
8749 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
8750 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
8751 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
8752 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
8753 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
8754 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
8755 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
8756 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
8757 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
8758 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
8759 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
8760 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
8761 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
8762 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", 0, 0, 0, 0, 0};
8763 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
8764 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
8765 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
8766 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
8767 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
8768 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
8769 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
8770 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
8771 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
8772 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
8773 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
8774 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
8775 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
8776 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
8777 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
8778 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
8779 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
8780 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
8781 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
8782 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
8783 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
8784 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
8785 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
8786 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
8787 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
8788 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
8789 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
8790 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
8791 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
8792 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
8793 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
8794 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
8795 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
8796 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
8797 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
8798 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
8799 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
8800 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
8801 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
8802 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
8803 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", 0, 0, 0, 0, 0};
8804 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
8805 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
8806 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
8807 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
8808 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
8809 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
8810 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
8811 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
8812 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
8813 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
8814 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
8815 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
8816 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
8817 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
8818 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
8819 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
8820 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
8821 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
8822 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
8823 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
8824 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
8825 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
8826 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
8827 static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
8828 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
8829 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
8830 static swig_type_info _swigt__p_wxPyXmlResourceHandler = {"_p_wxPyXmlResourceHandler", "wxPyXmlResourceHandler *", 0, 0, (void*)0, 0};
8831 static swig_type_info _swigt__p_wxPyXmlSubclassFactory = {"_p_wxPyXmlSubclassFactory", "wxPyXmlSubclassFactory *", 0, 0, (void*)0, 0};
8832 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
8833 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
8834 static swig_type_info _swigt__p_wxXmlDocument = {"_p_wxXmlDocument", "wxXmlDocument *", 0, 0, (void*)0, 0};
8835 static swig_type_info _swigt__p_wxXmlNode = {"_p_wxXmlNode", "wxXmlNode *", 0, 0, (void*)0, 0};
8836 static swig_type_info _swigt__p_wxXmlProperty = {"_p_wxXmlProperty", "wxXmlProperty *", 0, 0, (void*)0, 0};
8837 static swig_type_info _swigt__p_wxXmlResource = {"_p_wxXmlResource", "wxXmlResource *", 0, 0, (void*)0, 0};
8838
8839 static swig_type_info *swig_type_initial[] = {
8840 &_swigt__p_char,
8841 &_swigt__p_form_ops_t,
8842 &_swigt__p_int,
8843 &_swigt__p_unsigned_char,
8844 &_swigt__p_unsigned_int,
8845 &_swigt__p_unsigned_long,
8846 &_swigt__p_wxANIHandler,
8847 &_swigt__p_wxAcceleratorTable,
8848 &_swigt__p_wxActivateEvent,
8849 &_swigt__p_wxArtClient,
8850 &_swigt__p_wxBMPHandler,
8851 &_swigt__p_wxBitmap,
8852 &_swigt__p_wxBoxSizer,
8853 &_swigt__p_wxCURHandler,
8854 &_swigt__p_wxChildFocusEvent,
8855 &_swigt__p_wxClipboardTextEvent,
8856 &_swigt__p_wxCloseEvent,
8857 &_swigt__p_wxColour,
8858 &_swigt__p_wxCommandEvent,
8859 &_swigt__p_wxContextMenuEvent,
8860 &_swigt__p_wxControl,
8861 &_swigt__p_wxControlWithItems,
8862 &_swigt__p_wxDateEvent,
8863 &_swigt__p_wxDialog,
8864 &_swigt__p_wxDisplayChangedEvent,
8865 &_swigt__p_wxDropFilesEvent,
8866 &_swigt__p_wxDuplexMode,
8867 &_swigt__p_wxEraseEvent,
8868 &_swigt__p_wxEvent,
8869 &_swigt__p_wxEvtHandler,
8870 &_swigt__p_wxFSFile,
8871 &_swigt__p_wxFileSystem,
8872 &_swigt__p_wxFlexGridSizer,
8873 &_swigt__p_wxFocusEvent,
8874 &_swigt__p_wxFont,
8875 &_swigt__p_wxFrame,
8876 &_swigt__p_wxGBSizerItem,
8877 &_swigt__p_wxGIFHandler,
8878 &_swigt__p_wxGridBagSizer,
8879 &_swigt__p_wxGridSizer,
8880 &_swigt__p_wxICOHandler,
8881 &_swigt__p_wxIcon,
8882 &_swigt__p_wxIconizeEvent,
8883 &_swigt__p_wxIdleEvent,
8884 &_swigt__p_wxImage,
8885 &_swigt__p_wxImageHandler,
8886 &_swigt__p_wxIndividualLayoutConstraint,
8887 &_swigt__p_wxInitDialogEvent,
8888 &_swigt__p_wxInputStream,
8889 &_swigt__p_wxJPEGHandler,
8890 &_swigt__p_wxKeyEvent,
8891 &_swigt__p_wxLayoutConstraints,
8892 &_swigt__p_wxMaximizeEvent,
8893 &_swigt__p_wxMenu,
8894 &_swigt__p_wxMenuBar,
8895 &_swigt__p_wxMenuEvent,
8896 &_swigt__p_wxMenuItem,
8897 &_swigt__p_wxMouseCaptureChangedEvent,
8898 &_swigt__p_wxMouseEvent,
8899 &_swigt__p_wxMoveEvent,
8900 &_swigt__p_wxNavigationKeyEvent,
8901 &_swigt__p_wxNcPaintEvent,
8902 &_swigt__p_wxNotifyEvent,
8903 &_swigt__p_wxObject,
8904 &_swigt__p_wxOutputStream,
8905 &_swigt__p_wxPCXHandler,
8906 &_swigt__p_wxPNGHandler,
8907 &_swigt__p_wxPNMHandler,
8908 &_swigt__p_wxPaintEvent,
8909 &_swigt__p_wxPaletteChangedEvent,
8910 &_swigt__p_wxPanel,
8911 &_swigt__p_wxPaperSize,
8912 &_swigt__p_wxPoint,
8913 &_swigt__p_wxPyApp,
8914 &_swigt__p_wxPyCommandEvent,
8915 &_swigt__p_wxPyEvent,
8916 &_swigt__p_wxPyImageHandler,
8917 &_swigt__p_wxPySizer,
8918 &_swigt__p_wxPyValidator,
8919 &_swigt__p_wxPyXmlResourceHandler,
8920 &_swigt__p_wxPyXmlSubclassFactory,
8921 &_swigt__p_wxQueryNewPaletteEvent,
8922 &_swigt__p_wxScrollEvent,
8923 &_swigt__p_wxScrollWinEvent,
8924 &_swigt__p_wxSetCursorEvent,
8925 &_swigt__p_wxShowEvent,
8926 &_swigt__p_wxSize,
8927 &_swigt__p_wxSizeEvent,
8928 &_swigt__p_wxSizer,
8929 &_swigt__p_wxSizerItem,
8930 &_swigt__p_wxStaticBoxSizer,
8931 &_swigt__p_wxStdDialogButtonSizer,
8932 &_swigt__p_wxSysColourChangedEvent,
8933 &_swigt__p_wxTIFFHandler,
8934 &_swigt__p_wxUpdateUIEvent,
8935 &_swigt__p_wxValidator,
8936 &_swigt__p_wxWindow,
8937 &_swigt__p_wxWindowCreateEvent,
8938 &_swigt__p_wxWindowDestroyEvent,
8939 &_swigt__p_wxXPMHandler,
8940 &_swigt__p_wxXmlDocument,
8941 &_swigt__p_wxXmlNode,
8942 &_swigt__p_wxXmlProperty,
8943 &_swigt__p_wxXmlResource,
8944 };
8945
8946 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
8947 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
8948 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
8949 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
8950 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
8951 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
8952 static swig_cast_info _swigc__p_wxArtClient[] = { {&_swigt__p_wxArtClient, 0, 0, 0},{0, 0, 0, 0}};
8953 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
8954 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
8955 static swig_cast_info _swigc__p_wxDialog[] = { {&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
8956 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
8957 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
8958 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
8959 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
8960 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
8961 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
8962 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
8963 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
8964 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
8965 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
8966 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
8967 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
8968 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
8969 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
8970 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
8971 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
8972 static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
8973 static swig_cast_info _swigc__p_wxEvent[] = {{&_swigt__p_wxEvent, 0, 0, 0},{0, 0, 0, 0}};
8974 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
8975 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
8976 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
8977 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
8978 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
8979 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
8980 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
8981 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
8982 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
8983 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
8984 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
8985 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
8986 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
8987 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
8988 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
8989 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
8990 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
8991 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
8992 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
8993 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
8994 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
8995 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
8996 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
8997 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
8998 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
8999 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
9000 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
9001 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
9002 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
9003 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
9004 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
9005 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
9006 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
9007 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
9008 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
9009 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
9010 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
9011 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
9012 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
9013 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
9014 static swig_cast_info _swigc__p_wxEvtHandler[] = {{&_swigt__p_wxEvtHandler, 0, 0, 0},{0, 0, 0, 0}};
9015 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
9016 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
9017 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
9018 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
9019 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
9020 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
9021 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
9022 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
9023 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
9024 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
9025 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
9026 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
9027 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
9028 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
9029 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
9030 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
9031 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
9032 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
9033 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
9034 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
9035 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
9036 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
9037 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxXmlDocument, _p_wxXmlDocumentTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_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_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_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_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyXmlResourceHandler, _p_wxPyXmlResourceHandlerTo_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_wxXmlResource, _p_wxXmlResourceTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_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_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}};
9038 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
9039 static swig_cast_info _swigc__p_wxPanel[] = { {&_swigt__p_wxPanel, 0, 0, 0},{0, 0, 0, 0}};
9040 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
9041 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
9042 static swig_cast_info _swigc__p_wxPyXmlResourceHandler[] = { {&_swigt__p_wxPyXmlResourceHandler, 0, 0, 0},{0, 0, 0, 0}};
9043 static swig_cast_info _swigc__p_wxPyXmlSubclassFactory[] = { {&_swigt__p_wxPyXmlSubclassFactory, 0, 0, 0},{0, 0, 0, 0}};
9044 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
9045 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_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
9046 static swig_cast_info _swigc__p_wxXmlDocument[] = { {&_swigt__p_wxXmlDocument, 0, 0, 0},{0, 0, 0, 0}};
9047 static swig_cast_info _swigc__p_wxXmlNode[] = { {&_swigt__p_wxXmlNode, 0, 0, 0},{0, 0, 0, 0}};
9048 static swig_cast_info _swigc__p_wxXmlProperty[] = { {&_swigt__p_wxXmlProperty, 0, 0, 0},{0, 0, 0, 0}};
9049 static swig_cast_info _swigc__p_wxXmlResource[] = { {&_swigt__p_wxXmlResource, 0, 0, 0},{0, 0, 0, 0}};
9050
9051 static swig_cast_info *swig_cast_initial[] = {
9052 _swigc__p_char,
9053 _swigc__p_form_ops_t,
9054 _swigc__p_int,
9055 _swigc__p_unsigned_char,
9056 _swigc__p_unsigned_int,
9057 _swigc__p_unsigned_long,
9058 _swigc__p_wxANIHandler,
9059 _swigc__p_wxAcceleratorTable,
9060 _swigc__p_wxActivateEvent,
9061 _swigc__p_wxArtClient,
9062 _swigc__p_wxBMPHandler,
9063 _swigc__p_wxBitmap,
9064 _swigc__p_wxBoxSizer,
9065 _swigc__p_wxCURHandler,
9066 _swigc__p_wxChildFocusEvent,
9067 _swigc__p_wxClipboardTextEvent,
9068 _swigc__p_wxCloseEvent,
9069 _swigc__p_wxColour,
9070 _swigc__p_wxCommandEvent,
9071 _swigc__p_wxContextMenuEvent,
9072 _swigc__p_wxControl,
9073 _swigc__p_wxControlWithItems,
9074 _swigc__p_wxDateEvent,
9075 _swigc__p_wxDialog,
9076 _swigc__p_wxDisplayChangedEvent,
9077 _swigc__p_wxDropFilesEvent,
9078 _swigc__p_wxDuplexMode,
9079 _swigc__p_wxEraseEvent,
9080 _swigc__p_wxEvent,
9081 _swigc__p_wxEvtHandler,
9082 _swigc__p_wxFSFile,
9083 _swigc__p_wxFileSystem,
9084 _swigc__p_wxFlexGridSizer,
9085 _swigc__p_wxFocusEvent,
9086 _swigc__p_wxFont,
9087 _swigc__p_wxFrame,
9088 _swigc__p_wxGBSizerItem,
9089 _swigc__p_wxGIFHandler,
9090 _swigc__p_wxGridBagSizer,
9091 _swigc__p_wxGridSizer,
9092 _swigc__p_wxICOHandler,
9093 _swigc__p_wxIcon,
9094 _swigc__p_wxIconizeEvent,
9095 _swigc__p_wxIdleEvent,
9096 _swigc__p_wxImage,
9097 _swigc__p_wxImageHandler,
9098 _swigc__p_wxIndividualLayoutConstraint,
9099 _swigc__p_wxInitDialogEvent,
9100 _swigc__p_wxInputStream,
9101 _swigc__p_wxJPEGHandler,
9102 _swigc__p_wxKeyEvent,
9103 _swigc__p_wxLayoutConstraints,
9104 _swigc__p_wxMaximizeEvent,
9105 _swigc__p_wxMenu,
9106 _swigc__p_wxMenuBar,
9107 _swigc__p_wxMenuEvent,
9108 _swigc__p_wxMenuItem,
9109 _swigc__p_wxMouseCaptureChangedEvent,
9110 _swigc__p_wxMouseEvent,
9111 _swigc__p_wxMoveEvent,
9112 _swigc__p_wxNavigationKeyEvent,
9113 _swigc__p_wxNcPaintEvent,
9114 _swigc__p_wxNotifyEvent,
9115 _swigc__p_wxObject,
9116 _swigc__p_wxOutputStream,
9117 _swigc__p_wxPCXHandler,
9118 _swigc__p_wxPNGHandler,
9119 _swigc__p_wxPNMHandler,
9120 _swigc__p_wxPaintEvent,
9121 _swigc__p_wxPaletteChangedEvent,
9122 _swigc__p_wxPanel,
9123 _swigc__p_wxPaperSize,
9124 _swigc__p_wxPoint,
9125 _swigc__p_wxPyApp,
9126 _swigc__p_wxPyCommandEvent,
9127 _swigc__p_wxPyEvent,
9128 _swigc__p_wxPyImageHandler,
9129 _swigc__p_wxPySizer,
9130 _swigc__p_wxPyValidator,
9131 _swigc__p_wxPyXmlResourceHandler,
9132 _swigc__p_wxPyXmlSubclassFactory,
9133 _swigc__p_wxQueryNewPaletteEvent,
9134 _swigc__p_wxScrollEvent,
9135 _swigc__p_wxScrollWinEvent,
9136 _swigc__p_wxSetCursorEvent,
9137 _swigc__p_wxShowEvent,
9138 _swigc__p_wxSize,
9139 _swigc__p_wxSizeEvent,
9140 _swigc__p_wxSizer,
9141 _swigc__p_wxSizerItem,
9142 _swigc__p_wxStaticBoxSizer,
9143 _swigc__p_wxStdDialogButtonSizer,
9144 _swigc__p_wxSysColourChangedEvent,
9145 _swigc__p_wxTIFFHandler,
9146 _swigc__p_wxUpdateUIEvent,
9147 _swigc__p_wxValidator,
9148 _swigc__p_wxWindow,
9149 _swigc__p_wxWindowCreateEvent,
9150 _swigc__p_wxWindowDestroyEvent,
9151 _swigc__p_wxXPMHandler,
9152 _swigc__p_wxXmlDocument,
9153 _swigc__p_wxXmlNode,
9154 _swigc__p_wxXmlProperty,
9155 _swigc__p_wxXmlResource,
9156 };
9157
9158
9159 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
9160
9161 static swig_const_info swig_const_table[] = {
9162 {0, 0, 0, 0.0, 0, 0}};
9163
9164 #ifdef __cplusplus
9165 }
9166 #endif
9167 /* -----------------------------------------------------------------------------
9168 * Type initialization:
9169 * This problem is tough by the requirement that no dynamic
9170 * memory is used. Also, since swig_type_info structures store pointers to
9171 * swig_cast_info structures and swig_cast_info structures store pointers back
9172 * to swig_type_info structures, we need some lookup code at initialization.
9173 * The idea is that swig generates all the structures that are needed.
9174 * The runtime then collects these partially filled structures.
9175 * The SWIG_InitializeModule function takes these initial arrays out of
9176 * swig_module, and does all the lookup, filling in the swig_module.types
9177 * array with the correct data and linking the correct swig_cast_info
9178 * structures together.
9179 *
9180 * The generated swig_type_info structures are assigned staticly to an initial
9181 * array. We just loop though that array, and handle each type individually.
9182 * First we lookup if this type has been already loaded, and if so, use the
9183 * loaded structure instead of the generated one. Then we have to fill in the
9184 * cast linked list. The cast data is initially stored in something like a
9185 * two-dimensional array. Each row corresponds to a type (there are the same
9186 * number of rows as there are in the swig_type_initial array). Each entry in
9187 * a column is one of the swig_cast_info structures for that type.
9188 * The cast_initial array is actually an array of arrays, because each row has
9189 * a variable number of columns. So to actually build the cast linked list,
9190 * we find the array of casts associated with the type, and loop through it
9191 * adding the casts to the list. The one last trick we need to do is making
9192 * sure the type pointer in the swig_cast_info struct is correct.
9193 *
9194 * First off, we lookup the cast->type name to see if it is already loaded.
9195 * There are three cases to handle:
9196 * 1) If the cast->type has already been loaded AND the type we are adding
9197 * casting info to has not been loaded (it is in this module), THEN we
9198 * replace the cast->type pointer with the type pointer that has already
9199 * been loaded.
9200 * 2) If BOTH types (the one we are adding casting info to, and the
9201 * cast->type) are loaded, THEN the cast info has already been loaded by
9202 * the previous module so we just ignore it.
9203 * 3) Finally, if cast->type has not already been loaded, then we add that
9204 * swig_cast_info to the linked list (because the cast->type) pointer will
9205 * be correct.
9206 * ----------------------------------------------------------------------------- */
9207
9208 #ifdef __cplusplus
9209 extern "C" {
9210 #if 0
9211 } /* c-mode */
9212 #endif
9213 #endif
9214
9215 #if 0
9216 #define SWIGRUNTIME_DEBUG
9217 #endif
9218
9219 SWIGRUNTIME void
9220 SWIG_InitializeModule(void *clientdata) {
9221 size_t i;
9222 swig_module_info *module_head;
9223 static int init_run = 0;
9224
9225 clientdata = clientdata;
9226
9227 if (init_run) return;
9228 init_run = 1;
9229
9230 /* Initialize the swig_module */
9231 swig_module.type_initial = swig_type_initial;
9232 swig_module.cast_initial = swig_cast_initial;
9233
9234 /* Try and load any already created modules */
9235 module_head = SWIG_GetModule(clientdata);
9236 if (module_head) {
9237 swig_module.next = module_head->next;
9238 module_head->next = &swig_module;
9239 } else {
9240 /* This is the first module loaded */
9241 swig_module.next = &swig_module;
9242 SWIG_SetModule(clientdata, &swig_module);
9243 }
9244
9245 /* Now work on filling in swig_module.types */
9246 #ifdef SWIGRUNTIME_DEBUG
9247 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
9248 #endif
9249 for (i = 0; i < swig_module.size; ++i) {
9250 swig_type_info *type = 0;
9251 swig_type_info *ret;
9252 swig_cast_info *cast;
9253
9254 #ifdef SWIGRUNTIME_DEBUG
9255 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
9256 #endif
9257
9258 /* if there is another module already loaded */
9259 if (swig_module.next != &swig_module) {
9260 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
9261 }
9262 if (type) {
9263 /* Overwrite clientdata field */
9264 #ifdef SWIGRUNTIME_DEBUG
9265 printf("SWIG_InitializeModule: found type %s\n", type->name);
9266 #endif
9267 if (swig_module.type_initial[i]->clientdata) {
9268 type->clientdata = swig_module.type_initial[i]->clientdata;
9269 #ifdef SWIGRUNTIME_DEBUG
9270 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
9271 #endif
9272 }
9273 } else {
9274 type = swig_module.type_initial[i];
9275 }
9276
9277 /* Insert casting types */
9278 cast = swig_module.cast_initial[i];
9279 while (cast->type) {
9280 /* Don't need to add information already in the list */
9281 ret = 0;
9282 #ifdef SWIGRUNTIME_DEBUG
9283 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
9284 #endif
9285 if (swig_module.next != &swig_module) {
9286 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
9287 #ifdef SWIGRUNTIME_DEBUG
9288 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
9289 #endif
9290 }
9291 if (ret) {
9292 if (type == swig_module.type_initial[i]) {
9293 #ifdef SWIGRUNTIME_DEBUG
9294 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
9295 #endif
9296 cast->type = ret;
9297 ret = 0;
9298 } else {
9299 /* Check for casting already in the list */
9300 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
9301 #ifdef SWIGRUNTIME_DEBUG
9302 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
9303 #endif
9304 if (!ocast) ret = 0;
9305 }
9306 }
9307
9308 if (!ret) {
9309 #ifdef SWIGRUNTIME_DEBUG
9310 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
9311 #endif
9312 if (type->cast) {
9313 type->cast->prev = cast;
9314 cast->next = type->cast;
9315 }
9316 type->cast = cast;
9317 }
9318 cast++;
9319 }
9320 /* Set entry in modules->types array equal to the type */
9321 swig_module.types[i] = type;
9322 }
9323 swig_module.types[i] = 0;
9324
9325 #ifdef SWIGRUNTIME_DEBUG
9326 printf("**** SWIG_InitializeModule: Cast List ******\n");
9327 for (i = 0; i < swig_module.size; ++i) {
9328 int j = 0;
9329 swig_cast_info *cast = swig_module.cast_initial[i];
9330 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
9331 while (cast->type) {
9332 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
9333 cast++;
9334 ++j;
9335 }
9336 printf("---- Total casts: %d\n",j);
9337 }
9338 printf("**** SWIG_InitializeModule: Cast List ******\n");
9339 #endif
9340 }
9341
9342 /* This function will propagate the clientdata field of type to
9343 * any new swig_type_info structures that have been added into the list
9344 * of equivalent types. It is like calling
9345 * SWIG_TypeClientData(type, clientdata) a second time.
9346 */
9347 SWIGRUNTIME void
9348 SWIG_PropagateClientData(void) {
9349 size_t i;
9350 swig_cast_info *equiv;
9351 static int init_run = 0;
9352
9353 if (init_run) return;
9354 init_run = 1;
9355
9356 for (i = 0; i < swig_module.size; i++) {
9357 if (swig_module.types[i]->clientdata) {
9358 equiv = swig_module.types[i]->cast;
9359 while (equiv) {
9360 if (!equiv->converter) {
9361 if (equiv->type && !equiv->type->clientdata)
9362 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
9363 }
9364 equiv = equiv->next;
9365 }
9366 }
9367 }
9368 }
9369
9370 #ifdef __cplusplus
9371 #if 0
9372 {
9373 /* c-mode */
9374 #endif
9375 }
9376 #endif
9377
9378
9379
9380 #ifdef __cplusplus
9381 extern "C" {
9382 #endif
9383
9384 /* Python-specific SWIG API */
9385 #define SWIG_newvarlink() SWIG_Python_newvarlink()
9386 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
9387 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
9388
9389 /* -----------------------------------------------------------------------------
9390 * global variable support code.
9391 * ----------------------------------------------------------------------------- */
9392
9393 typedef struct swig_globalvar {
9394 char *name; /* Name of global variable */
9395 PyObject *(*get_attr)(void); /* Return the current value */
9396 int (*set_attr)(PyObject *); /* Set the value */
9397 struct swig_globalvar *next;
9398 } swig_globalvar;
9399
9400 typedef struct swig_varlinkobject {
9401 PyObject_HEAD
9402 swig_globalvar *vars;
9403 } swig_varlinkobject;
9404
9405 SWIGINTERN PyObject *
9406 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
9407 return PyString_FromString("<Swig global variables>");
9408 }
9409
9410 SWIGINTERN PyObject *
9411 swig_varlink_str(swig_varlinkobject *v) {
9412 PyObject *str = PyString_FromString("(");
9413 swig_globalvar *var;
9414 for (var = v->vars; var; var=var->next) {
9415 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
9416 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
9417 }
9418 PyString_ConcatAndDel(&str,PyString_FromString(")"));
9419 return str;
9420 }
9421
9422 SWIGINTERN int
9423 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
9424 PyObject *str = swig_varlink_str(v);
9425 fprintf(fp,"Swig global variables ");
9426 fprintf(fp,"%s\n", PyString_AsString(str));
9427 Py_DECREF(str);
9428 return 0;
9429 }
9430
9431 SWIGINTERN void
9432 swig_varlink_dealloc(swig_varlinkobject *v) {
9433 swig_globalvar *var = v->vars;
9434 while (var) {
9435 swig_globalvar *n = var->next;
9436 free(var->name);
9437 free(var);
9438 var = n;
9439 }
9440 }
9441
9442 SWIGINTERN PyObject *
9443 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
9444 PyObject *res = NULL;
9445 swig_globalvar *var = v->vars;
9446 while (var) {
9447 if (strcmp(var->name,n) == 0) {
9448 res = (*var->get_attr)();
9449 break;
9450 }
9451 var = var->next;
9452 }
9453 if (res == NULL && !PyErr_Occurred()) {
9454 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
9455 }
9456 return res;
9457 }
9458
9459 SWIGINTERN int
9460 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
9461 int res = 1;
9462 swig_globalvar *var = v->vars;
9463 while (var) {
9464 if (strcmp(var->name,n) == 0) {
9465 res = (*var->set_attr)(p);
9466 break;
9467 }
9468 var = var->next;
9469 }
9470 if (res == 1 && !PyErr_Occurred()) {
9471 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
9472 }
9473 return res;
9474 }
9475
9476 SWIGINTERN PyTypeObject*
9477 swig_varlink_type(void) {
9478 static char varlink__doc__[] = "Swig var link object";
9479 static PyTypeObject varlink_type;
9480 static int type_init = 0;
9481 if (!type_init) {
9482 const PyTypeObject tmp
9483 = {
9484 PyObject_HEAD_INIT(NULL)
9485 0, /* Number of items in variable part (ob_size) */
9486 (char *)"swigvarlink", /* Type name (tp_name) */
9487 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
9488 0, /* Itemsize (tp_itemsize) */
9489 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
9490 (printfunc) swig_varlink_print, /* Print (tp_print) */
9491 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
9492 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
9493 0, /* tp_compare */
9494 (reprfunc) swig_varlink_repr, /* tp_repr */
9495 0, /* tp_as_number */
9496 0, /* tp_as_sequence */
9497 0, /* tp_as_mapping */
9498 0, /* tp_hash */
9499 0, /* tp_call */
9500 (reprfunc)swig_varlink_str, /* tp_str */
9501 0, /* tp_getattro */
9502 0, /* tp_setattro */
9503 0, /* tp_as_buffer */
9504 0, /* tp_flags */
9505 varlink__doc__, /* tp_doc */
9506 0, /* tp_traverse */
9507 0, /* tp_clear */
9508 0, /* tp_richcompare */
9509 0, /* tp_weaklistoffset */
9510 #if PY_VERSION_HEX >= 0x02020000
9511 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
9512 #endif
9513 #if PY_VERSION_HEX >= 0x02030000
9514 0, /* tp_del */
9515 #endif
9516 #ifdef COUNT_ALLOCS
9517 0,0,0,0 /* tp_alloc -> tp_next */
9518 #endif
9519 };
9520 varlink_type = tmp;
9521 varlink_type.ob_type = &PyType_Type;
9522 type_init = 1;
9523 }
9524 return &varlink_type;
9525 }
9526
9527 /* Create a variable linking object for use later */
9528 SWIGINTERN PyObject *
9529 SWIG_Python_newvarlink(void) {
9530 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
9531 if (result) {
9532 result->vars = 0;
9533 }
9534 return ((PyObject*) result);
9535 }
9536
9537 SWIGINTERN void
9538 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
9539 swig_varlinkobject *v = (swig_varlinkobject *) p;
9540 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
9541 if (gv) {
9542 size_t size = strlen(name)+1;
9543 gv->name = (char *)malloc(size);
9544 if (gv->name) {
9545 strncpy(gv->name,name,size);
9546 gv->get_attr = get_attr;
9547 gv->set_attr = set_attr;
9548 gv->next = v->vars;
9549 }
9550 }
9551 v->vars = gv;
9552 }
9553
9554 SWIGINTERN PyObject *
9555 SWIG_globals() {
9556 static PyObject *_SWIG_globals = 0;
9557 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
9558 return _SWIG_globals;
9559 }
9560
9561 /* -----------------------------------------------------------------------------
9562 * constants/methods manipulation
9563 * ----------------------------------------------------------------------------- */
9564
9565 /* Install Constants */
9566 SWIGINTERN void
9567 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
9568 PyObject *obj = 0;
9569 size_t i;
9570 for (i = 0; constants[i].type; ++i) {
9571 switch(constants[i].type) {
9572 case SWIG_PY_POINTER:
9573 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
9574 break;
9575 case SWIG_PY_BINARY:
9576 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
9577 break;
9578 default:
9579 obj = 0;
9580 break;
9581 }
9582 if (obj) {
9583 PyDict_SetItemString(d, constants[i].name, obj);
9584 Py_DECREF(obj);
9585 }
9586 }
9587 }
9588
9589 /* -----------------------------------------------------------------------------*/
9590 /* Fix SwigMethods to carry the callback ptrs when needed */
9591 /* -----------------------------------------------------------------------------*/
9592
9593 SWIGINTERN void
9594 SWIG_Python_FixMethods(PyMethodDef *methods,
9595 swig_const_info *const_table,
9596 swig_type_info **types,
9597 swig_type_info **types_initial) {
9598 size_t i;
9599 for (i = 0; methods[i].ml_name; ++i) {
9600 const char *c = methods[i].ml_doc;
9601 if (c && (c = strstr(c, "swig_ptr: "))) {
9602 int j;
9603 swig_const_info *ci = 0;
9604 const char *name = c + 10;
9605 for (j = 0; const_table[j].type; ++j) {
9606 if (strncmp(const_table[j].name, name,
9607 strlen(const_table[j].name)) == 0) {
9608 ci = &(const_table[j]);
9609 break;
9610 }
9611 }
9612 if (ci) {
9613 size_t shift = (ci->ptype) - types;
9614 swig_type_info *ty = types_initial[shift];
9615 size_t ldoc = (c - methods[i].ml_doc);
9616 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
9617 char *ndoc = (char*)malloc(ldoc + lptr + 10);
9618 if (ndoc) {
9619 char *buff = ndoc;
9620 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
9621 if (ptr) {
9622 strncpy(buff, methods[i].ml_doc, ldoc);
9623 buff += ldoc;
9624 strncpy(buff, "swig_ptr: ", 10);
9625 buff += 10;
9626 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
9627 methods[i].ml_doc = ndoc;
9628 }
9629 }
9630 }
9631 }
9632 }
9633 }
9634
9635 #ifdef __cplusplus
9636 }
9637 #endif
9638
9639 /* -----------------------------------------------------------------------------*
9640 * Partial Init method
9641 * -----------------------------------------------------------------------------*/
9642
9643 #ifdef __cplusplus
9644 extern "C"
9645 #endif
9646 SWIGEXPORT void SWIG_init(void) {
9647 PyObject *m, *d;
9648
9649 /* Fix SwigMethods to carry the callback ptrs when needed */
9650 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
9651
9652 m = Py_InitModule((char *) SWIG_name, SwigMethods);
9653 d = PyModule_GetDict(m);
9654
9655 SWIG_InitializeModule(0);
9656 SWIG_InstallConstants(d,swig_const_table);
9657
9658
9659 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
9660 SWIG_addvarlink(SWIG_globals(),(char*)"UTF8String",UTF8String_get, UTF8String_set);
9661 SWIG_addvarlink(SWIG_globals(),(char*)"StyleString",StyleString_get, StyleString_set);
9662 SWIG_addvarlink(SWIG_globals(),(char*)"SizeString",SizeString_get, SizeString_set);
9663 SWIG_addvarlink(SWIG_globals(),(char*)"PosString",PosString_get, PosString_set);
9664 SWIG_addvarlink(SWIG_globals(),(char*)"BitmapString",BitmapString_get, BitmapString_set);
9665 SWIG_addvarlink(SWIG_globals(),(char*)"IconString",IconString_get, IconString_set);
9666 SWIG_addvarlink(SWIG_globals(),(char*)"FontString",FontString_get, FontString_set);
9667 SWIG_Python_SetConstant(d, "WX_XMLRES_CURRENT_VERSION_MAJOR",SWIG_From_int(static_cast< int >(WX_XMLRES_CURRENT_VERSION_MAJOR)));
9668 SWIG_Python_SetConstant(d, "WX_XMLRES_CURRENT_VERSION_MINOR",SWIG_From_int(static_cast< int >(WX_XMLRES_CURRENT_VERSION_MINOR)));
9669 SWIG_Python_SetConstant(d, "WX_XMLRES_CURRENT_VERSION_RELEASE",SWIG_From_int(static_cast< int >(WX_XMLRES_CURRENT_VERSION_RELEASE)));
9670 SWIG_Python_SetConstant(d, "WX_XMLRES_CURRENT_VERSION_REVISION",SWIG_From_int(static_cast< int >(WX_XMLRES_CURRENT_VERSION_REVISION)));
9671 SWIG_Python_SetConstant(d, "XRC_USE_LOCALE",SWIG_From_int(static_cast< int >(wxXRC_USE_LOCALE)));
9672 SWIG_Python_SetConstant(d, "XRC_NO_SUBCLASSING",SWIG_From_int(static_cast< int >(wxXRC_NO_SUBCLASSING)));
9673 SWIG_Python_SetConstant(d, "XRC_NO_RELOADING",SWIG_From_int(static_cast< int >(wxXRC_NO_RELOADING)));
9674 SWIG_Python_SetConstant(d, "XML_ELEMENT_NODE",SWIG_From_int(static_cast< int >(wxXML_ELEMENT_NODE)));
9675 SWIG_Python_SetConstant(d, "XML_ATTRIBUTE_NODE",SWIG_From_int(static_cast< int >(wxXML_ATTRIBUTE_NODE)));
9676 SWIG_Python_SetConstant(d, "XML_TEXT_NODE",SWIG_From_int(static_cast< int >(wxXML_TEXT_NODE)));
9677 SWIG_Python_SetConstant(d, "XML_CDATA_SECTION_NODE",SWIG_From_int(static_cast< int >(wxXML_CDATA_SECTION_NODE)));
9678 SWIG_Python_SetConstant(d, "XML_ENTITY_REF_NODE",SWIG_From_int(static_cast< int >(wxXML_ENTITY_REF_NODE)));
9679 SWIG_Python_SetConstant(d, "XML_ENTITY_NODE",SWIG_From_int(static_cast< int >(wxXML_ENTITY_NODE)));
9680 SWIG_Python_SetConstant(d, "XML_PI_NODE",SWIG_From_int(static_cast< int >(wxXML_PI_NODE)));
9681 SWIG_Python_SetConstant(d, "XML_COMMENT_NODE",SWIG_From_int(static_cast< int >(wxXML_COMMENT_NODE)));
9682 SWIG_Python_SetConstant(d, "XML_DOCUMENT_NODE",SWIG_From_int(static_cast< int >(wxXML_DOCUMENT_NODE)));
9683 SWIG_Python_SetConstant(d, "XML_DOCUMENT_TYPE_NODE",SWIG_From_int(static_cast< int >(wxXML_DOCUMENT_TYPE_NODE)));
9684 SWIG_Python_SetConstant(d, "XML_DOCUMENT_FRAG_NODE",SWIG_From_int(static_cast< int >(wxXML_DOCUMENT_FRAG_NODE)));
9685 SWIG_Python_SetConstant(d, "XML_NOTATION_NODE",SWIG_From_int(static_cast< int >(wxXML_NOTATION_NODE)));
9686 SWIG_Python_SetConstant(d, "XML_HTML_DOCUMENT_NODE",SWIG_From_int(static_cast< int >(wxXML_HTML_DOCUMENT_NODE)));
9687
9688
9689 wxXmlInitResourceModule();
9690 wxXmlResource::Get()->InitAllHandlers();
9691
9692
9693 }
9694
wxWidgets (Impactor)