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