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