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