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