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