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


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