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