]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/xrc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / gtk / xrc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.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 /*@/opt/swig/share/swig/1.3.24/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 /*@/opt/swig/share/swig/1.3.24/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 wxInputStream 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)
4553 delete arg1;
4554 }
4555 {
4556 if (temp2)
4557 delete arg2;
4558 }
4559 return resultobj;
4560 fail:
4561 {
4562 if (created1)
4563 delete arg1;
4564 }
4565 {
4566 if (temp2)
4567 delete arg2;
4568 }
4569 return NULL;
4570 }
4571
4572
4573 static PyObject *_wrap_new_EmptyXmlDocument(PyObject *, PyObject *args, PyObject *kwargs) {
4574 PyObject *resultobj;
4575 wxXmlDocument *result;
4576 char *kwnames[] = {
4577 NULL
4578 };
4579
4580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EmptyXmlDocument",kwnames)) goto fail;
4581 {
4582 PyThreadState* __tstate = wxPyBeginAllowThreads();
4583 result = (wxXmlDocument *)new wxXmlDocument();
4584
4585 wxPyEndAllowThreads(__tstate);
4586 if (PyErr_Occurred()) SWIG_fail;
4587 }
4588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXmlDocument, 1);
4589 return resultobj;
4590 fail:
4591 return NULL;
4592 }
4593
4594
4595 static PyObject *_wrap_delete_XmlDocument(PyObject *, PyObject *args, PyObject *kwargs) {
4596 PyObject *resultobj;
4597 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
4598 PyObject * obj0 = 0 ;
4599 char *kwnames[] = {
4600 (char *) "self", NULL
4601 };
4602
4603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_XmlDocument",kwnames,&obj0)) goto fail;
4604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_EXCEPTION | 0);
4605 if (SWIG_arg_fail(1)) SWIG_fail;
4606 {
4607 PyThreadState* __tstate = wxPyBeginAllowThreads();
4608 delete arg1;
4609
4610 wxPyEndAllowThreads(__tstate);
4611 if (PyErr_Occurred()) SWIG_fail;
4612 }
4613 Py_INCREF(Py_None); resultobj = Py_None;
4614 return resultobj;
4615 fail:
4616 return NULL;
4617 }
4618
4619
4620 static PyObject *_wrap_XmlDocument_Load(PyObject *, PyObject *args, PyObject *kwargs) {
4621 PyObject *resultobj;
4622 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
4623 wxString *arg2 = 0 ;
4624 wxString const &arg3_defvalue = wxPyUTF8String ;
4625 wxString *arg3 = (wxString *) &arg3_defvalue ;
4626 bool result;
4627 bool temp2 = false ;
4628 bool temp3 = false ;
4629 PyObject * obj0 = 0 ;
4630 PyObject * obj1 = 0 ;
4631 PyObject * obj2 = 0 ;
4632 char *kwnames[] = {
4633 (char *) "self",(char *) "filename",(char *) "encoding", NULL
4634 };
4635
4636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlDocument_Load",kwnames,&obj0,&obj1,&obj2)) goto fail;
4637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_EXCEPTION | 0);
4638 if (SWIG_arg_fail(1)) SWIG_fail;
4639 {
4640 arg2 = wxString_in_helper(obj1);
4641 if (arg2 == NULL) SWIG_fail;
4642 temp2 = true;
4643 }
4644 if (obj2) {
4645 {
4646 arg3 = wxString_in_helper(obj2);
4647 if (arg3 == NULL) SWIG_fail;
4648 temp3 = true;
4649 }
4650 }
4651 {
4652 PyThreadState* __tstate = wxPyBeginAllowThreads();
4653 result = (bool)(arg1)->Load((wxString const &)*arg2,(wxString const &)*arg3);
4654
4655 wxPyEndAllowThreads(__tstate);
4656 if (PyErr_Occurred()) SWIG_fail;
4657 }
4658 {
4659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4660 }
4661 {
4662 if (temp2)
4663 delete arg2;
4664 }
4665 {
4666 if (temp3)
4667 delete arg3;
4668 }
4669 return resultobj;
4670 fail:
4671 {
4672 if (temp2)
4673 delete arg2;
4674 }
4675 {
4676 if (temp3)
4677 delete arg3;
4678 }
4679 return NULL;
4680 }
4681
4682
4683 static PyObject *_wrap_XmlDocument_LoadFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
4684 PyObject *resultobj;
4685 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
4686 wxInputStream *arg2 = 0 ;
4687 wxString const &arg3_defvalue = wxPyUTF8String ;
4688 wxString *arg3 = (wxString *) &arg3_defvalue ;
4689 bool result;
4690 wxPyInputStream *temp2 ;
4691 bool created2 ;
4692 bool temp3 = false ;
4693 PyObject * obj0 = 0 ;
4694 PyObject * obj1 = 0 ;
4695 PyObject * obj2 = 0 ;
4696 char *kwnames[] = {
4697 (char *) "self",(char *) "stream",(char *) "encoding", NULL
4698 };
4699
4700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlDocument_LoadFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
4701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_EXCEPTION | 0);
4702 if (SWIG_arg_fail(1)) SWIG_fail;
4703 {
4704 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
4705 arg2 = temp2->m_wxis;
4706 created2 = false;
4707 } else {
4708 PyErr_Clear(); // clear the failure of the wxPyConvert above
4709 arg2 = wxPyCBInputStream_create(obj1, false);
4710 if (arg2 == NULL) {
4711 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
4712 SWIG_fail;
4713 }
4714 created2 = true;
4715 }
4716 }
4717 if (obj2) {
4718 {
4719 arg3 = wxString_in_helper(obj2);
4720 if (arg3 == NULL) SWIG_fail;
4721 temp3 = true;
4722 }
4723 }
4724 {
4725 PyThreadState* __tstate = wxPyBeginAllowThreads();
4726 result = (bool)(arg1)->Load(*arg2,(wxString const &)*arg3);
4727
4728 wxPyEndAllowThreads(__tstate);
4729 if (PyErr_Occurred()) SWIG_fail;
4730 }
4731 {
4732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4733 }
4734 {
4735 if (created2)
4736 delete arg2;
4737 }
4738 {
4739 if (temp3)
4740 delete arg3;
4741 }
4742 return resultobj;
4743 fail:
4744 {
4745 if (created2)
4746 delete arg2;
4747 }
4748 {
4749 if (temp3)
4750 delete arg3;
4751 }
4752 return NULL;
4753 }
4754
4755
4756 static PyObject *_wrap_XmlDocument_Save(PyObject *, PyObject *args, PyObject *kwargs) {
4757 PyObject *resultobj;
4758 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
4759 wxString *arg2 = 0 ;
4760 bool result;
4761 bool temp2 = false ;
4762 PyObject * obj0 = 0 ;
4763 PyObject * obj1 = 0 ;
4764 char *kwnames[] = {
4765 (char *) "self",(char *) "filename", NULL
4766 };
4767
4768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlDocument_Save",kwnames,&obj0,&obj1)) goto fail;
4769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_EXCEPTION | 0);
4770 if (SWIG_arg_fail(1)) SWIG_fail;
4771 {
4772 arg2 = wxString_in_helper(obj1);
4773 if (arg2 == NULL) SWIG_fail;
4774 temp2 = true;
4775 }
4776 {
4777 PyThreadState* __tstate = wxPyBeginAllowThreads();
4778 result = (bool)((wxXmlDocument const *)arg1)->Save((wxString const &)*arg2);
4779
4780 wxPyEndAllowThreads(__tstate);
4781 if (PyErr_Occurred()) SWIG_fail;
4782 }
4783 {
4784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4785 }
4786 {
4787 if (temp2)
4788 delete arg2;
4789 }
4790 return resultobj;
4791 fail:
4792 {
4793 if (temp2)
4794 delete arg2;
4795 }
4796 return NULL;
4797 }
4798
4799
4800 static PyObject *_wrap_XmlDocument_SaveToStream(PyObject *, PyObject *args, PyObject *kwargs) {
4801 PyObject *resultobj;
4802 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
4803 wxOutputStream *arg2 = 0 ;
4804 bool result;
4805 PyObject * obj0 = 0 ;
4806 PyObject * obj1 = 0 ;
4807 char *kwnames[] = {
4808 (char *) "self",(char *) "stream", NULL
4809 };
4810
4811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlDocument_SaveToStream",kwnames,&obj0,&obj1)) goto fail;
4812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_EXCEPTION | 0);
4813 if (SWIG_arg_fail(1)) SWIG_fail;
4814 {
4815 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
4816 if (SWIG_arg_fail(2)) SWIG_fail;
4817 if (arg2 == NULL) {
4818 SWIG_null_ref("wxOutputStream");
4819 }
4820 if (SWIG_arg_fail(2)) SWIG_fail;
4821 }
4822 {
4823 PyThreadState* __tstate = wxPyBeginAllowThreads();
4824 result = (bool)((wxXmlDocument const *)arg1)->Save(*arg2);
4825
4826 wxPyEndAllowThreads(__tstate);
4827 if (PyErr_Occurred()) SWIG_fail;
4828 }
4829 {
4830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4831 }
4832 return resultobj;
4833 fail:
4834 return NULL;
4835 }
4836
4837
4838 static PyObject *_wrap_XmlDocument_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
4839 PyObject *resultobj;
4840 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
4841 bool result;
4842 PyObject * obj0 = 0 ;
4843 char *kwnames[] = {
4844 (char *) "self", NULL
4845 };
4846
4847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlDocument_IsOk",kwnames,&obj0)) goto fail;
4848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_EXCEPTION | 0);
4849 if (SWIG_arg_fail(1)) SWIG_fail;
4850 {
4851 PyThreadState* __tstate = wxPyBeginAllowThreads();
4852 result = (bool)((wxXmlDocument const *)arg1)->IsOk();
4853
4854 wxPyEndAllowThreads(__tstate);
4855 if (PyErr_Occurred()) SWIG_fail;
4856 }
4857 {
4858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4859 }
4860 return resultobj;
4861 fail:
4862 return NULL;
4863 }
4864
4865
4866 static PyObject *_wrap_XmlDocument_GetRoot(PyObject *, PyObject *args, PyObject *kwargs) {
4867 PyObject *resultobj;
4868 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
4869 wxXmlNode *result;
4870 PyObject * obj0 = 0 ;
4871 char *kwnames[] = {
4872 (char *) "self", NULL
4873 };
4874
4875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlDocument_GetRoot",kwnames,&obj0)) goto fail;
4876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_EXCEPTION | 0);
4877 if (SWIG_arg_fail(1)) SWIG_fail;
4878 {
4879 PyThreadState* __tstate = wxPyBeginAllowThreads();
4880 result = (wxXmlNode *)((wxXmlDocument const *)arg1)->GetRoot();
4881
4882 wxPyEndAllowThreads(__tstate);
4883 if (PyErr_Occurred()) SWIG_fail;
4884 }
4885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXmlNode, 0);
4886 return resultobj;
4887 fail:
4888 return NULL;
4889 }
4890
4891
4892 static PyObject *_wrap_XmlDocument_GetVersion(PyObject *, PyObject *args, PyObject *kwargs) {
4893 PyObject *resultobj;
4894 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
4895 wxString result;
4896 PyObject * obj0 = 0 ;
4897 char *kwnames[] = {
4898 (char *) "self", NULL
4899 };
4900
4901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlDocument_GetVersion",kwnames,&obj0)) goto fail;
4902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_EXCEPTION | 0);
4903 if (SWIG_arg_fail(1)) SWIG_fail;
4904 {
4905 PyThreadState* __tstate = wxPyBeginAllowThreads();
4906 result = ((wxXmlDocument const *)arg1)->GetVersion();
4907
4908 wxPyEndAllowThreads(__tstate);
4909 if (PyErr_Occurred()) SWIG_fail;
4910 }
4911 {
4912 #if wxUSE_UNICODE
4913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4914 #else
4915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4916 #endif
4917 }
4918 return resultobj;
4919 fail:
4920 return NULL;
4921 }
4922
4923
4924 static PyObject *_wrap_XmlDocument_GetFileEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
4925 PyObject *resultobj;
4926 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
4927 wxString result;
4928 PyObject * obj0 = 0 ;
4929 char *kwnames[] = {
4930 (char *) "self", NULL
4931 };
4932
4933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlDocument_GetFileEncoding",kwnames,&obj0)) goto fail;
4934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_EXCEPTION | 0);
4935 if (SWIG_arg_fail(1)) SWIG_fail;
4936 {
4937 PyThreadState* __tstate = wxPyBeginAllowThreads();
4938 result = ((wxXmlDocument const *)arg1)->GetFileEncoding();
4939
4940 wxPyEndAllowThreads(__tstate);
4941 if (PyErr_Occurred()) SWIG_fail;
4942 }
4943 {
4944 #if wxUSE_UNICODE
4945 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4946 #else
4947 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4948 #endif
4949 }
4950 return resultobj;
4951 fail:
4952 return NULL;
4953 }
4954
4955
4956 static PyObject *_wrap_XmlDocument_SetRoot(PyObject *, PyObject *args, PyObject *kwargs) {
4957 PyObject *resultobj;
4958 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
4959 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
4960 PyObject * obj0 = 0 ;
4961 PyObject * obj1 = 0 ;
4962 char *kwnames[] = {
4963 (char *) "self",(char *) "node", NULL
4964 };
4965
4966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlDocument_SetRoot",kwnames,&obj0,&obj1)) goto fail;
4967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_EXCEPTION | 0);
4968 if (SWIG_arg_fail(1)) SWIG_fail;
4969 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxXmlNode, SWIG_POINTER_EXCEPTION | 0);
4970 if (SWIG_arg_fail(2)) SWIG_fail;
4971 {
4972 PyThreadState* __tstate = wxPyBeginAllowThreads();
4973 (arg1)->SetRoot(arg2);
4974
4975 wxPyEndAllowThreads(__tstate);
4976 if (PyErr_Occurred()) SWIG_fail;
4977 }
4978 Py_INCREF(Py_None); resultobj = Py_None;
4979 return resultobj;
4980 fail:
4981 return NULL;
4982 }
4983
4984
4985 static PyObject *_wrap_XmlDocument_SetVersion(PyObject *, PyObject *args, PyObject *kwargs) {
4986 PyObject *resultobj;
4987 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
4988 wxString *arg2 = 0 ;
4989 bool temp2 = false ;
4990 PyObject * obj0 = 0 ;
4991 PyObject * obj1 = 0 ;
4992 char *kwnames[] = {
4993 (char *) "self",(char *) "version", NULL
4994 };
4995
4996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlDocument_SetVersion",kwnames,&obj0,&obj1)) goto fail;
4997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_EXCEPTION | 0);
4998 if (SWIG_arg_fail(1)) SWIG_fail;
4999 {
5000 arg2 = wxString_in_helper(obj1);
5001 if (arg2 == NULL) SWIG_fail;
5002 temp2 = true;
5003 }
5004 {
5005 PyThreadState* __tstate = wxPyBeginAllowThreads();
5006 (arg1)->SetVersion((wxString const &)*arg2);
5007
5008 wxPyEndAllowThreads(__tstate);
5009 if (PyErr_Occurred()) SWIG_fail;
5010 }
5011 Py_INCREF(Py_None); resultobj = Py_None;
5012 {
5013 if (temp2)
5014 delete arg2;
5015 }
5016 return resultobj;
5017 fail:
5018 {
5019 if (temp2)
5020 delete arg2;
5021 }
5022 return NULL;
5023 }
5024
5025
5026 static PyObject *_wrap_XmlDocument_SetFileEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
5027 PyObject *resultobj;
5028 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
5029 wxString *arg2 = 0 ;
5030 bool temp2 = false ;
5031 PyObject * obj0 = 0 ;
5032 PyObject * obj1 = 0 ;
5033 char *kwnames[] = {
5034 (char *) "self",(char *) "encoding", NULL
5035 };
5036
5037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlDocument_SetFileEncoding",kwnames,&obj0,&obj1)) goto fail;
5038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_EXCEPTION | 0);
5039 if (SWIG_arg_fail(1)) SWIG_fail;
5040 {
5041 arg2 = wxString_in_helper(obj1);
5042 if (arg2 == NULL) SWIG_fail;
5043 temp2 = true;
5044 }
5045 {
5046 PyThreadState* __tstate = wxPyBeginAllowThreads();
5047 (arg1)->SetFileEncoding((wxString const &)*arg2);
5048
5049 wxPyEndAllowThreads(__tstate);
5050 if (PyErr_Occurred()) SWIG_fail;
5051 }
5052 Py_INCREF(Py_None); resultobj = Py_None;
5053 {
5054 if (temp2)
5055 delete arg2;
5056 }
5057 return resultobj;
5058 fail:
5059 {
5060 if (temp2)
5061 delete arg2;
5062 }
5063 return NULL;
5064 }
5065
5066
5067 static PyObject * XmlDocument_swigregister(PyObject *, PyObject *args) {
5068 PyObject *obj;
5069 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
5070 SWIG_TypeClientData(SWIGTYPE_p_wxXmlDocument, obj);
5071 Py_INCREF(obj);
5072 return Py_BuildValue((char *)"");
5073 }
5074 static PyObject *_wrap_new_XmlResourceHandler(PyObject *, PyObject *args, PyObject *kwargs) {
5075 PyObject *resultobj;
5076 wxPyXmlResourceHandler *result;
5077 char *kwnames[] = {
5078 NULL
5079 };
5080
5081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XmlResourceHandler",kwnames)) goto fail;
5082 {
5083 PyThreadState* __tstate = wxPyBeginAllowThreads();
5084 result = (wxPyXmlResourceHandler *)new wxPyXmlResourceHandler();
5085
5086 wxPyEndAllowThreads(__tstate);
5087 if (PyErr_Occurred()) SWIG_fail;
5088 }
5089 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyXmlResourceHandler, 1);
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 static PyObject *_wrap_XmlResourceHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
5097 PyObject *resultobj;
5098 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5099 PyObject *arg2 = (PyObject *) 0 ;
5100 PyObject *arg3 = (PyObject *) 0 ;
5101 PyObject * obj0 = 0 ;
5102 PyObject * obj1 = 0 ;
5103 PyObject * obj2 = 0 ;
5104 char *kwnames[] = {
5105 (char *) "self",(char *) "self",(char *) "_class", NULL
5106 };
5107
5108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResourceHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
5109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5110 if (SWIG_arg_fail(1)) SWIG_fail;
5111 arg2 = obj1;
5112 arg3 = obj2;
5113 {
5114 PyThreadState* __tstate = wxPyBeginAllowThreads();
5115 (arg1)->_setCallbackInfo(arg2,arg3);
5116
5117 wxPyEndAllowThreads(__tstate);
5118 if (PyErr_Occurred()) SWIG_fail;
5119 }
5120 Py_INCREF(Py_None); resultobj = Py_None;
5121 return resultobj;
5122 fail:
5123 return NULL;
5124 }
5125
5126
5127 static PyObject *_wrap_XmlResourceHandler_CreateResource(PyObject *, PyObject *args, PyObject *kwargs) {
5128 PyObject *resultobj;
5129 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5130 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
5131 wxObject *arg3 = (wxObject *) 0 ;
5132 wxObject *arg4 = (wxObject *) 0 ;
5133 wxObject *result;
5134 PyObject * obj0 = 0 ;
5135 PyObject * obj1 = 0 ;
5136 PyObject * obj2 = 0 ;
5137 PyObject * obj3 = 0 ;
5138 char *kwnames[] = {
5139 (char *) "self",(char *) "node",(char *) "parent",(char *) "instance", NULL
5140 };
5141
5142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:XmlResourceHandler_CreateResource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5144 if (SWIG_arg_fail(1)) SWIG_fail;
5145 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxXmlNode, SWIG_POINTER_EXCEPTION | 0);
5146 if (SWIG_arg_fail(2)) SWIG_fail;
5147 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
5148 if (SWIG_arg_fail(3)) SWIG_fail;
5149 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
5150 if (SWIG_arg_fail(4)) SWIG_fail;
5151 {
5152 PyThreadState* __tstate = wxPyBeginAllowThreads();
5153 result = (wxObject *)(arg1)->CreateResource(arg2,arg3,arg4);
5154
5155 wxPyEndAllowThreads(__tstate);
5156 if (PyErr_Occurred()) SWIG_fail;
5157 }
5158 {
5159 resultobj = wxPyMake_wxObject(result, 0);
5160 }
5161 return resultobj;
5162 fail:
5163 return NULL;
5164 }
5165
5166
5167 static PyObject *_wrap_XmlResourceHandler_SetParentResource(PyObject *, PyObject *args, PyObject *kwargs) {
5168 PyObject *resultobj;
5169 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5170 wxXmlResource *arg2 = (wxXmlResource *) 0 ;
5171 PyObject * obj0 = 0 ;
5172 PyObject * obj1 = 0 ;
5173 char *kwnames[] = {
5174 (char *) "self",(char *) "res", NULL
5175 };
5176
5177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_SetParentResource",kwnames,&obj0,&obj1)) goto fail;
5178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5179 if (SWIG_arg_fail(1)) SWIG_fail;
5180 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxXmlResource, SWIG_POINTER_EXCEPTION | 0);
5181 if (SWIG_arg_fail(2)) SWIG_fail;
5182 {
5183 PyThreadState* __tstate = wxPyBeginAllowThreads();
5184 (arg1)->SetParentResource(arg2);
5185
5186 wxPyEndAllowThreads(__tstate);
5187 if (PyErr_Occurred()) SWIG_fail;
5188 }
5189 Py_INCREF(Py_None); resultobj = Py_None;
5190 return resultobj;
5191 fail:
5192 return NULL;
5193 }
5194
5195
5196 static PyObject *_wrap_XmlResourceHandler_GetResource(PyObject *, PyObject *args, PyObject *kwargs) {
5197 PyObject *resultobj;
5198 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5199 wxXmlResource *result;
5200 PyObject * obj0 = 0 ;
5201 char *kwnames[] = {
5202 (char *) "self", NULL
5203 };
5204
5205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlResourceHandler_GetResource",kwnames,&obj0)) goto fail;
5206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5207 if (SWIG_arg_fail(1)) SWIG_fail;
5208 {
5209 PyThreadState* __tstate = wxPyBeginAllowThreads();
5210 result = (wxXmlResource *)(arg1)->GetResource();
5211
5212 wxPyEndAllowThreads(__tstate);
5213 if (PyErr_Occurred()) SWIG_fail;
5214 }
5215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXmlResource, 0);
5216 return resultobj;
5217 fail:
5218 return NULL;
5219 }
5220
5221
5222 static PyObject *_wrap_XmlResourceHandler_GetNode(PyObject *, PyObject *args, PyObject *kwargs) {
5223 PyObject *resultobj;
5224 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5225 wxXmlNode *result;
5226 PyObject * obj0 = 0 ;
5227 char *kwnames[] = {
5228 (char *) "self", NULL
5229 };
5230
5231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlResourceHandler_GetNode",kwnames,&obj0)) goto fail;
5232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5233 if (SWIG_arg_fail(1)) SWIG_fail;
5234 {
5235 PyThreadState* __tstate = wxPyBeginAllowThreads();
5236 result = (wxXmlNode *)(arg1)->GetNode();
5237
5238 wxPyEndAllowThreads(__tstate);
5239 if (PyErr_Occurred()) SWIG_fail;
5240 }
5241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXmlNode, 0);
5242 return resultobj;
5243 fail:
5244 return NULL;
5245 }
5246
5247
5248 static PyObject *_wrap_XmlResourceHandler_GetClass(PyObject *, PyObject *args, PyObject *kwargs) {
5249 PyObject *resultobj;
5250 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5251 wxString result;
5252 PyObject * obj0 = 0 ;
5253 char *kwnames[] = {
5254 (char *) "self", NULL
5255 };
5256
5257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlResourceHandler_GetClass",kwnames,&obj0)) goto fail;
5258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5259 if (SWIG_arg_fail(1)) SWIG_fail;
5260 {
5261 PyThreadState* __tstate = wxPyBeginAllowThreads();
5262 result = (arg1)->GetClass();
5263
5264 wxPyEndAllowThreads(__tstate);
5265 if (PyErr_Occurred()) SWIG_fail;
5266 }
5267 {
5268 #if wxUSE_UNICODE
5269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5270 #else
5271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5272 #endif
5273 }
5274 return resultobj;
5275 fail:
5276 return NULL;
5277 }
5278
5279
5280 static PyObject *_wrap_XmlResourceHandler_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
5281 PyObject *resultobj;
5282 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5283 wxObject *result;
5284 PyObject * obj0 = 0 ;
5285 char *kwnames[] = {
5286 (char *) "self", NULL
5287 };
5288
5289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlResourceHandler_GetParent",kwnames,&obj0)) goto fail;
5290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5291 if (SWIG_arg_fail(1)) SWIG_fail;
5292 {
5293 PyThreadState* __tstate = wxPyBeginAllowThreads();
5294 result = (wxObject *)(arg1)->GetParent();
5295
5296 wxPyEndAllowThreads(__tstate);
5297 if (PyErr_Occurred()) SWIG_fail;
5298 }
5299 {
5300 resultobj = wxPyMake_wxObject(result, 0);
5301 }
5302 return resultobj;
5303 fail:
5304 return NULL;
5305 }
5306
5307
5308 static PyObject *_wrap_XmlResourceHandler_GetInstance(PyObject *, PyObject *args, PyObject *kwargs) {
5309 PyObject *resultobj;
5310 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5311 wxObject *result;
5312 PyObject * obj0 = 0 ;
5313 char *kwnames[] = {
5314 (char *) "self", NULL
5315 };
5316
5317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlResourceHandler_GetInstance",kwnames,&obj0)) goto fail;
5318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5319 if (SWIG_arg_fail(1)) SWIG_fail;
5320 {
5321 PyThreadState* __tstate = wxPyBeginAllowThreads();
5322 result = (wxObject *)(arg1)->GetInstance();
5323
5324 wxPyEndAllowThreads(__tstate);
5325 if (PyErr_Occurred()) SWIG_fail;
5326 }
5327 {
5328 resultobj = wxPyMake_wxObject(result, 0);
5329 }
5330 return resultobj;
5331 fail:
5332 return NULL;
5333 }
5334
5335
5336 static PyObject *_wrap_XmlResourceHandler_GetParentAsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5337 PyObject *resultobj;
5338 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5339 wxWindow *result;
5340 PyObject * obj0 = 0 ;
5341 char *kwnames[] = {
5342 (char *) "self", NULL
5343 };
5344
5345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlResourceHandler_GetParentAsWindow",kwnames,&obj0)) goto fail;
5346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5347 if (SWIG_arg_fail(1)) SWIG_fail;
5348 {
5349 PyThreadState* __tstate = wxPyBeginAllowThreads();
5350 result = (wxWindow *)(arg1)->GetParentAsWindow();
5351
5352 wxPyEndAllowThreads(__tstate);
5353 if (PyErr_Occurred()) SWIG_fail;
5354 }
5355 {
5356 resultobj = wxPyMake_wxObject(result, 0);
5357 }
5358 return resultobj;
5359 fail:
5360 return NULL;
5361 }
5362
5363
5364 static PyObject *_wrap_XmlResourceHandler_IsOfClass(PyObject *, PyObject *args, PyObject *kwargs) {
5365 PyObject *resultobj;
5366 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5367 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
5368 wxString *arg3 = 0 ;
5369 bool result;
5370 bool temp3 = false ;
5371 PyObject * obj0 = 0 ;
5372 PyObject * obj1 = 0 ;
5373 PyObject * obj2 = 0 ;
5374 char *kwnames[] = {
5375 (char *) "self",(char *) "node",(char *) "classname", NULL
5376 };
5377
5378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResourceHandler_IsOfClass",kwnames,&obj0,&obj1,&obj2)) goto fail;
5379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5380 if (SWIG_arg_fail(1)) SWIG_fail;
5381 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxXmlNode, SWIG_POINTER_EXCEPTION | 0);
5382 if (SWIG_arg_fail(2)) SWIG_fail;
5383 {
5384 arg3 = wxString_in_helper(obj2);
5385 if (arg3 == NULL) SWIG_fail;
5386 temp3 = true;
5387 }
5388 {
5389 PyThreadState* __tstate = wxPyBeginAllowThreads();
5390 result = (bool)(arg1)->IsOfClass(arg2,(wxString const &)*arg3);
5391
5392 wxPyEndAllowThreads(__tstate);
5393 if (PyErr_Occurred()) SWIG_fail;
5394 }
5395 {
5396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5397 }
5398 {
5399 if (temp3)
5400 delete arg3;
5401 }
5402 return resultobj;
5403 fail:
5404 {
5405 if (temp3)
5406 delete arg3;
5407 }
5408 return NULL;
5409 }
5410
5411
5412 static PyObject *_wrap_XmlResourceHandler_GetNodeContent(PyObject *, PyObject *args, PyObject *kwargs) {
5413 PyObject *resultobj;
5414 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5415 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
5416 wxString result;
5417 PyObject * obj0 = 0 ;
5418 PyObject * obj1 = 0 ;
5419 char *kwnames[] = {
5420 (char *) "self",(char *) "node", NULL
5421 };
5422
5423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_GetNodeContent",kwnames,&obj0,&obj1)) goto fail;
5424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5425 if (SWIG_arg_fail(1)) SWIG_fail;
5426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxXmlNode, SWIG_POINTER_EXCEPTION | 0);
5427 if (SWIG_arg_fail(2)) SWIG_fail;
5428 {
5429 PyThreadState* __tstate = wxPyBeginAllowThreads();
5430 result = (arg1)->GetNodeContent(arg2);
5431
5432 wxPyEndAllowThreads(__tstate);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 {
5436 #if wxUSE_UNICODE
5437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5438 #else
5439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5440 #endif
5441 }
5442 return resultobj;
5443 fail:
5444 return NULL;
5445 }
5446
5447
5448 static PyObject *_wrap_XmlResourceHandler_HasParam(PyObject *, PyObject *args, PyObject *kwargs) {
5449 PyObject *resultobj;
5450 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5451 wxString *arg2 = 0 ;
5452 bool result;
5453 bool temp2 = false ;
5454 PyObject * obj0 = 0 ;
5455 PyObject * obj1 = 0 ;
5456 char *kwnames[] = {
5457 (char *) "self",(char *) "param", NULL
5458 };
5459
5460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_HasParam",kwnames,&obj0,&obj1)) goto fail;
5461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5462 if (SWIG_arg_fail(1)) SWIG_fail;
5463 {
5464 arg2 = wxString_in_helper(obj1);
5465 if (arg2 == NULL) SWIG_fail;
5466 temp2 = true;
5467 }
5468 {
5469 PyThreadState* __tstate = wxPyBeginAllowThreads();
5470 result = (bool)(arg1)->HasParam((wxString const &)*arg2);
5471
5472 wxPyEndAllowThreads(__tstate);
5473 if (PyErr_Occurred()) SWIG_fail;
5474 }
5475 {
5476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5477 }
5478 {
5479 if (temp2)
5480 delete arg2;
5481 }
5482 return resultobj;
5483 fail:
5484 {
5485 if (temp2)
5486 delete arg2;
5487 }
5488 return NULL;
5489 }
5490
5491
5492 static PyObject *_wrap_XmlResourceHandler_GetParamNode(PyObject *, PyObject *args, PyObject *kwargs) {
5493 PyObject *resultobj;
5494 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5495 wxString *arg2 = 0 ;
5496 wxXmlNode *result;
5497 bool temp2 = false ;
5498 PyObject * obj0 = 0 ;
5499 PyObject * obj1 = 0 ;
5500 char *kwnames[] = {
5501 (char *) "self",(char *) "param", NULL
5502 };
5503
5504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_GetParamNode",kwnames,&obj0,&obj1)) goto fail;
5505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5506 if (SWIG_arg_fail(1)) SWIG_fail;
5507 {
5508 arg2 = wxString_in_helper(obj1);
5509 if (arg2 == NULL) SWIG_fail;
5510 temp2 = true;
5511 }
5512 {
5513 PyThreadState* __tstate = wxPyBeginAllowThreads();
5514 result = (wxXmlNode *)(arg1)->GetParamNode((wxString const &)*arg2);
5515
5516 wxPyEndAllowThreads(__tstate);
5517 if (PyErr_Occurred()) SWIG_fail;
5518 }
5519 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXmlNode, 0);
5520 {
5521 if (temp2)
5522 delete arg2;
5523 }
5524 return resultobj;
5525 fail:
5526 {
5527 if (temp2)
5528 delete arg2;
5529 }
5530 return NULL;
5531 }
5532
5533
5534 static PyObject *_wrap_XmlResourceHandler_GetParamValue(PyObject *, PyObject *args, PyObject *kwargs) {
5535 PyObject *resultobj;
5536 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5537 wxString *arg2 = 0 ;
5538 wxString result;
5539 bool temp2 = false ;
5540 PyObject * obj0 = 0 ;
5541 PyObject * obj1 = 0 ;
5542 char *kwnames[] = {
5543 (char *) "self",(char *) "param", NULL
5544 };
5545
5546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_GetParamValue",kwnames,&obj0,&obj1)) goto fail;
5547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5548 if (SWIG_arg_fail(1)) SWIG_fail;
5549 {
5550 arg2 = wxString_in_helper(obj1);
5551 if (arg2 == NULL) SWIG_fail;
5552 temp2 = true;
5553 }
5554 {
5555 PyThreadState* __tstate = wxPyBeginAllowThreads();
5556 result = (arg1)->GetParamValue((wxString const &)*arg2);
5557
5558 wxPyEndAllowThreads(__tstate);
5559 if (PyErr_Occurred()) SWIG_fail;
5560 }
5561 {
5562 #if wxUSE_UNICODE
5563 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5564 #else
5565 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5566 #endif
5567 }
5568 {
5569 if (temp2)
5570 delete arg2;
5571 }
5572 return resultobj;
5573 fail:
5574 {
5575 if (temp2)
5576 delete arg2;
5577 }
5578 return NULL;
5579 }
5580
5581
5582 static PyObject *_wrap_XmlResourceHandler_AddStyle(PyObject *, PyObject *args, PyObject *kwargs) {
5583 PyObject *resultobj;
5584 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5585 wxString *arg2 = 0 ;
5586 int arg3 ;
5587 bool temp2 = false ;
5588 PyObject * obj0 = 0 ;
5589 PyObject * obj1 = 0 ;
5590 PyObject * obj2 = 0 ;
5591 char *kwnames[] = {
5592 (char *) "self",(char *) "name",(char *) "value", NULL
5593 };
5594
5595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResourceHandler_AddStyle",kwnames,&obj0,&obj1,&obj2)) goto fail;
5596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5597 if (SWIG_arg_fail(1)) SWIG_fail;
5598 {
5599 arg2 = wxString_in_helper(obj1);
5600 if (arg2 == NULL) SWIG_fail;
5601 temp2 = true;
5602 }
5603 {
5604 arg3 = (int)(SWIG_As_int(obj2));
5605 if (SWIG_arg_fail(3)) SWIG_fail;
5606 }
5607 {
5608 PyThreadState* __tstate = wxPyBeginAllowThreads();
5609 (arg1)->AddStyle((wxString const &)*arg2,arg3);
5610
5611 wxPyEndAllowThreads(__tstate);
5612 if (PyErr_Occurred()) SWIG_fail;
5613 }
5614 Py_INCREF(Py_None); resultobj = Py_None;
5615 {
5616 if (temp2)
5617 delete arg2;
5618 }
5619 return resultobj;
5620 fail:
5621 {
5622 if (temp2)
5623 delete arg2;
5624 }
5625 return NULL;
5626 }
5627
5628
5629 static PyObject *_wrap_XmlResourceHandler_AddWindowStyles(PyObject *, PyObject *args, PyObject *kwargs) {
5630 PyObject *resultobj;
5631 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5632 PyObject * obj0 = 0 ;
5633 char *kwnames[] = {
5634 (char *) "self", NULL
5635 };
5636
5637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlResourceHandler_AddWindowStyles",kwnames,&obj0)) goto fail;
5638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5639 if (SWIG_arg_fail(1)) SWIG_fail;
5640 {
5641 PyThreadState* __tstate = wxPyBeginAllowThreads();
5642 (arg1)->AddWindowStyles();
5643
5644 wxPyEndAllowThreads(__tstate);
5645 if (PyErr_Occurred()) SWIG_fail;
5646 }
5647 Py_INCREF(Py_None); resultobj = Py_None;
5648 return resultobj;
5649 fail:
5650 return NULL;
5651 }
5652
5653
5654 static PyObject *_wrap_XmlResourceHandler_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
5655 PyObject *resultobj;
5656 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5657 wxString const &arg2_defvalue = wxPyStyleString ;
5658 wxString *arg2 = (wxString *) &arg2_defvalue ;
5659 int arg3 = (int) 0 ;
5660 int result;
5661 bool temp2 = false ;
5662 PyObject * obj0 = 0 ;
5663 PyObject * obj1 = 0 ;
5664 PyObject * obj2 = 0 ;
5665 char *kwnames[] = {
5666 (char *) "self",(char *) "param",(char *) "defaults", NULL
5667 };
5668
5669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:XmlResourceHandler_GetStyle",kwnames,&obj0,&obj1,&obj2)) goto fail;
5670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5671 if (SWIG_arg_fail(1)) SWIG_fail;
5672 if (obj1) {
5673 {
5674 arg2 = wxString_in_helper(obj1);
5675 if (arg2 == NULL) SWIG_fail;
5676 temp2 = true;
5677 }
5678 }
5679 if (obj2) {
5680 {
5681 arg3 = (int)(SWIG_As_int(obj2));
5682 if (SWIG_arg_fail(3)) SWIG_fail;
5683 }
5684 }
5685 {
5686 PyThreadState* __tstate = wxPyBeginAllowThreads();
5687 result = (int)(arg1)->GetStyle((wxString const &)*arg2,arg3);
5688
5689 wxPyEndAllowThreads(__tstate);
5690 if (PyErr_Occurred()) SWIG_fail;
5691 }
5692 {
5693 resultobj = SWIG_From_int((int)(result));
5694 }
5695 {
5696 if (temp2)
5697 delete arg2;
5698 }
5699 return resultobj;
5700 fail:
5701 {
5702 if (temp2)
5703 delete arg2;
5704 }
5705 return NULL;
5706 }
5707
5708
5709 static PyObject *_wrap_XmlResourceHandler_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
5710 PyObject *resultobj;
5711 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5712 wxString *arg2 = 0 ;
5713 bool arg3 = (bool) true ;
5714 wxString result;
5715 bool temp2 = false ;
5716 PyObject * obj0 = 0 ;
5717 PyObject * obj1 = 0 ;
5718 PyObject * obj2 = 0 ;
5719 char *kwnames[] = {
5720 (char *) "self",(char *) "param",(char *) "translate", NULL
5721 };
5722
5723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_GetText",kwnames,&obj0,&obj1,&obj2)) goto fail;
5724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5725 if (SWIG_arg_fail(1)) SWIG_fail;
5726 {
5727 arg2 = wxString_in_helper(obj1);
5728 if (arg2 == NULL) SWIG_fail;
5729 temp2 = true;
5730 }
5731 if (obj2) {
5732 {
5733 arg3 = (bool)(SWIG_As_bool(obj2));
5734 if (SWIG_arg_fail(3)) SWIG_fail;
5735 }
5736 }
5737 {
5738 PyThreadState* __tstate = wxPyBeginAllowThreads();
5739 result = (arg1)->GetText((wxString const &)*arg2,arg3);
5740
5741 wxPyEndAllowThreads(__tstate);
5742 if (PyErr_Occurred()) SWIG_fail;
5743 }
5744 {
5745 #if wxUSE_UNICODE
5746 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5747 #else
5748 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5749 #endif
5750 }
5751 {
5752 if (temp2)
5753 delete arg2;
5754 }
5755 return resultobj;
5756 fail:
5757 {
5758 if (temp2)
5759 delete arg2;
5760 }
5761 return NULL;
5762 }
5763
5764
5765 static PyObject *_wrap_XmlResourceHandler_GetID(PyObject *, PyObject *args, PyObject *kwargs) {
5766 PyObject *resultobj;
5767 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5768 int result;
5769 PyObject * obj0 = 0 ;
5770 char *kwnames[] = {
5771 (char *) "self", NULL
5772 };
5773
5774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlResourceHandler_GetID",kwnames,&obj0)) goto fail;
5775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5776 if (SWIG_arg_fail(1)) SWIG_fail;
5777 {
5778 PyThreadState* __tstate = wxPyBeginAllowThreads();
5779 result = (int)(arg1)->GetID();
5780
5781 wxPyEndAllowThreads(__tstate);
5782 if (PyErr_Occurred()) SWIG_fail;
5783 }
5784 {
5785 resultobj = SWIG_From_int((int)(result));
5786 }
5787 return resultobj;
5788 fail:
5789 return NULL;
5790 }
5791
5792
5793 static PyObject *_wrap_XmlResourceHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
5794 PyObject *resultobj;
5795 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5796 wxString result;
5797 PyObject * obj0 = 0 ;
5798 char *kwnames[] = {
5799 (char *) "self", NULL
5800 };
5801
5802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlResourceHandler_GetName",kwnames,&obj0)) goto fail;
5803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5804 if (SWIG_arg_fail(1)) SWIG_fail;
5805 {
5806 PyThreadState* __tstate = wxPyBeginAllowThreads();
5807 result = (arg1)->GetName();
5808
5809 wxPyEndAllowThreads(__tstate);
5810 if (PyErr_Occurred()) SWIG_fail;
5811 }
5812 {
5813 #if wxUSE_UNICODE
5814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5815 #else
5816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5817 #endif
5818 }
5819 return resultobj;
5820 fail:
5821 return NULL;
5822 }
5823
5824
5825 static PyObject *_wrap_XmlResourceHandler_GetBool(PyObject *, PyObject *args, PyObject *kwargs) {
5826 PyObject *resultobj;
5827 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5828 wxString *arg2 = 0 ;
5829 bool arg3 = (bool) false ;
5830 bool result;
5831 bool temp2 = false ;
5832 PyObject * obj0 = 0 ;
5833 PyObject * obj1 = 0 ;
5834 PyObject * obj2 = 0 ;
5835 char *kwnames[] = {
5836 (char *) "self",(char *) "param",(char *) "defaultv", NULL
5837 };
5838
5839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_GetBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
5840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5841 if (SWIG_arg_fail(1)) SWIG_fail;
5842 {
5843 arg2 = wxString_in_helper(obj1);
5844 if (arg2 == NULL) SWIG_fail;
5845 temp2 = true;
5846 }
5847 if (obj2) {
5848 {
5849 arg3 = (bool)(SWIG_As_bool(obj2));
5850 if (SWIG_arg_fail(3)) SWIG_fail;
5851 }
5852 }
5853 {
5854 PyThreadState* __tstate = wxPyBeginAllowThreads();
5855 result = (bool)(arg1)->GetBool((wxString const &)*arg2,arg3);
5856
5857 wxPyEndAllowThreads(__tstate);
5858 if (PyErr_Occurred()) SWIG_fail;
5859 }
5860 {
5861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5862 }
5863 {
5864 if (temp2)
5865 delete arg2;
5866 }
5867 return resultobj;
5868 fail:
5869 {
5870 if (temp2)
5871 delete arg2;
5872 }
5873 return NULL;
5874 }
5875
5876
5877 static PyObject *_wrap_XmlResourceHandler_GetLong(PyObject *, PyObject *args, PyObject *kwargs) {
5878 PyObject *resultobj;
5879 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5880 wxString *arg2 = 0 ;
5881 long arg3 = (long) 0 ;
5882 long result;
5883 bool temp2 = false ;
5884 PyObject * obj0 = 0 ;
5885 PyObject * obj1 = 0 ;
5886 PyObject * obj2 = 0 ;
5887 char *kwnames[] = {
5888 (char *) "self",(char *) "param",(char *) "defaultv", NULL
5889 };
5890
5891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_GetLong",kwnames,&obj0,&obj1,&obj2)) goto fail;
5892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5893 if (SWIG_arg_fail(1)) SWIG_fail;
5894 {
5895 arg2 = wxString_in_helper(obj1);
5896 if (arg2 == NULL) SWIG_fail;
5897 temp2 = true;
5898 }
5899 if (obj2) {
5900 {
5901 arg3 = (long)(SWIG_As_long(obj2));
5902 if (SWIG_arg_fail(3)) SWIG_fail;
5903 }
5904 }
5905 {
5906 PyThreadState* __tstate = wxPyBeginAllowThreads();
5907 result = (long)(arg1)->GetLong((wxString const &)*arg2,arg3);
5908
5909 wxPyEndAllowThreads(__tstate);
5910 if (PyErr_Occurred()) SWIG_fail;
5911 }
5912 {
5913 resultobj = SWIG_From_long((long)(result));
5914 }
5915 {
5916 if (temp2)
5917 delete arg2;
5918 }
5919 return resultobj;
5920 fail:
5921 {
5922 if (temp2)
5923 delete arg2;
5924 }
5925 return NULL;
5926 }
5927
5928
5929 static PyObject *_wrap_XmlResourceHandler_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
5930 PyObject *resultobj;
5931 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5932 wxString *arg2 = 0 ;
5933 wxColour result;
5934 bool temp2 = false ;
5935 PyObject * obj0 = 0 ;
5936 PyObject * obj1 = 0 ;
5937 char *kwnames[] = {
5938 (char *) "self",(char *) "param", NULL
5939 };
5940
5941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_GetColour",kwnames,&obj0,&obj1)) goto fail;
5942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5943 if (SWIG_arg_fail(1)) SWIG_fail;
5944 {
5945 arg2 = wxString_in_helper(obj1);
5946 if (arg2 == NULL) SWIG_fail;
5947 temp2 = true;
5948 }
5949 {
5950 PyThreadState* __tstate = wxPyBeginAllowThreads();
5951 result = (arg1)->GetColour((wxString const &)*arg2);
5952
5953 wxPyEndAllowThreads(__tstate);
5954 if (PyErr_Occurred()) SWIG_fail;
5955 }
5956 {
5957 wxColour * resultptr;
5958 resultptr = new wxColour((wxColour &)(result));
5959 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
5960 }
5961 {
5962 if (temp2)
5963 delete arg2;
5964 }
5965 return resultobj;
5966 fail:
5967 {
5968 if (temp2)
5969 delete arg2;
5970 }
5971 return NULL;
5972 }
5973
5974
5975 static PyObject *_wrap_XmlResourceHandler_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5976 PyObject *resultobj;
5977 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
5978 wxString const &arg2_defvalue = wxPySizeString ;
5979 wxString *arg2 = (wxString *) &arg2_defvalue ;
5980 wxSize result;
5981 bool temp2 = false ;
5982 PyObject * obj0 = 0 ;
5983 PyObject * obj1 = 0 ;
5984 char *kwnames[] = {
5985 (char *) "self",(char *) "param", NULL
5986 };
5987
5988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:XmlResourceHandler_GetSize",kwnames,&obj0,&obj1)) goto fail;
5989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
5990 if (SWIG_arg_fail(1)) SWIG_fail;
5991 if (obj1) {
5992 {
5993 arg2 = wxString_in_helper(obj1);
5994 if (arg2 == NULL) SWIG_fail;
5995 temp2 = true;
5996 }
5997 }
5998 {
5999 PyThreadState* __tstate = wxPyBeginAllowThreads();
6000 result = (arg1)->GetSize((wxString const &)*arg2);
6001
6002 wxPyEndAllowThreads(__tstate);
6003 if (PyErr_Occurred()) SWIG_fail;
6004 }
6005 {
6006 wxSize * resultptr;
6007 resultptr = new wxSize((wxSize &)(result));
6008 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6009 }
6010 {
6011 if (temp2)
6012 delete arg2;
6013 }
6014 return resultobj;
6015 fail:
6016 {
6017 if (temp2)
6018 delete arg2;
6019 }
6020 return NULL;
6021 }
6022
6023
6024 static PyObject *_wrap_XmlResourceHandler_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6025 PyObject *resultobj;
6026 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6027 wxString const &arg2_defvalue = wxPyPosString ;
6028 wxString *arg2 = (wxString *) &arg2_defvalue ;
6029 wxPoint result;
6030 bool temp2 = false ;
6031 PyObject * obj0 = 0 ;
6032 PyObject * obj1 = 0 ;
6033 char *kwnames[] = {
6034 (char *) "self",(char *) "param", NULL
6035 };
6036
6037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:XmlResourceHandler_GetPosition",kwnames,&obj0,&obj1)) goto fail;
6038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
6039 if (SWIG_arg_fail(1)) SWIG_fail;
6040 if (obj1) {
6041 {
6042 arg2 = wxString_in_helper(obj1);
6043 if (arg2 == NULL) SWIG_fail;
6044 temp2 = true;
6045 }
6046 }
6047 {
6048 PyThreadState* __tstate = wxPyBeginAllowThreads();
6049 result = (arg1)->GetPosition((wxString const &)*arg2);
6050
6051 wxPyEndAllowThreads(__tstate);
6052 if (PyErr_Occurred()) SWIG_fail;
6053 }
6054 {
6055 wxPoint * resultptr;
6056 resultptr = new wxPoint((wxPoint &)(result));
6057 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6058 }
6059 {
6060 if (temp2)
6061 delete arg2;
6062 }
6063 return resultobj;
6064 fail:
6065 {
6066 if (temp2)
6067 delete arg2;
6068 }
6069 return NULL;
6070 }
6071
6072
6073 static PyObject *_wrap_XmlResourceHandler_GetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
6074 PyObject *resultobj;
6075 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6076 wxString *arg2 = 0 ;
6077 int arg3 = (int) 0 ;
6078 int result;
6079 bool temp2 = false ;
6080 PyObject * obj0 = 0 ;
6081 PyObject * obj1 = 0 ;
6082 PyObject * obj2 = 0 ;
6083 char *kwnames[] = {
6084 (char *) "self",(char *) "param",(char *) "defaultv", NULL
6085 };
6086
6087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_GetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
6088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
6089 if (SWIG_arg_fail(1)) SWIG_fail;
6090 {
6091 arg2 = wxString_in_helper(obj1);
6092 if (arg2 == NULL) SWIG_fail;
6093 temp2 = true;
6094 }
6095 if (obj2) {
6096 {
6097 arg3 = (int)(SWIG_As_int(obj2));
6098 if (SWIG_arg_fail(3)) SWIG_fail;
6099 }
6100 }
6101 {
6102 PyThreadState* __tstate = wxPyBeginAllowThreads();
6103 result = (int)(arg1)->GetDimension((wxString const &)*arg2,arg3);
6104
6105 wxPyEndAllowThreads(__tstate);
6106 if (PyErr_Occurred()) SWIG_fail;
6107 }
6108 {
6109 resultobj = SWIG_From_int((int)(result));
6110 }
6111 {
6112 if (temp2)
6113 delete arg2;
6114 }
6115 return resultobj;
6116 fail:
6117 {
6118 if (temp2)
6119 delete arg2;
6120 }
6121 return NULL;
6122 }
6123
6124
6125 static PyObject *_wrap_XmlResourceHandler_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
6126 PyObject *resultobj;
6127 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6128 wxString const &arg2_defvalue = wxPyBitmapString ;
6129 wxString *arg2 = (wxString *) &arg2_defvalue ;
6130 wxArtClient const &arg3_defvalue = wxART_OTHER ;
6131 wxArtClient *arg3 = (wxArtClient *) &arg3_defvalue ;
6132 wxSize arg4 = (wxSize) wxDefaultSize ;
6133 wxBitmap result;
6134 bool temp2 = false ;
6135 PyObject * obj0 = 0 ;
6136 PyObject * obj1 = 0 ;
6137 PyObject * obj2 = 0 ;
6138 PyObject * obj3 = 0 ;
6139 char *kwnames[] = {
6140 (char *) "self",(char *) "param",(char *) "defaultArtClient",(char *) "size", NULL
6141 };
6142
6143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:XmlResourceHandler_GetBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
6145 if (SWIG_arg_fail(1)) SWIG_fail;
6146 if (obj1) {
6147 {
6148 arg2 = wxString_in_helper(obj1);
6149 if (arg2 == NULL) SWIG_fail;
6150 temp2 = true;
6151 }
6152 }
6153 if (obj2) {
6154 {
6155 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxArtClient, SWIG_POINTER_EXCEPTION | 0);
6156 if (SWIG_arg_fail(3)) SWIG_fail;
6157 if (arg3 == NULL) {
6158 SWIG_null_ref("wxArtClient");
6159 }
6160 if (SWIG_arg_fail(3)) SWIG_fail;
6161 }
6162 }
6163 if (obj3) {
6164 {
6165 wxSize * argp;
6166 SWIG_Python_ConvertPtr(obj3, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
6167 if (SWIG_arg_fail(4)) SWIG_fail;
6168 if (argp == NULL) {
6169 SWIG_null_ref("wxSize");
6170 }
6171 if (SWIG_arg_fail(4)) SWIG_fail;
6172 arg4 = *argp;
6173 }
6174 }
6175 {
6176 PyThreadState* __tstate = wxPyBeginAllowThreads();
6177 result = (arg1)->GetBitmap((wxString const &)*arg2,(wxArtClient const &)*arg3,arg4);
6178
6179 wxPyEndAllowThreads(__tstate);
6180 if (PyErr_Occurred()) SWIG_fail;
6181 }
6182 {
6183 wxBitmap * resultptr;
6184 resultptr = new wxBitmap((wxBitmap &)(result));
6185 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
6186 }
6187 {
6188 if (temp2)
6189 delete arg2;
6190 }
6191 return resultobj;
6192 fail:
6193 {
6194 if (temp2)
6195 delete arg2;
6196 }
6197 return NULL;
6198 }
6199
6200
6201 static PyObject *_wrap_XmlResourceHandler_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
6202 PyObject *resultobj;
6203 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6204 wxString const &arg2_defvalue = wxPyIconString ;
6205 wxString *arg2 = (wxString *) &arg2_defvalue ;
6206 wxArtClient const &arg3_defvalue = wxART_OTHER ;
6207 wxArtClient *arg3 = (wxArtClient *) &arg3_defvalue ;
6208 wxSize arg4 = (wxSize) wxDefaultSize ;
6209 wxIcon result;
6210 bool temp2 = false ;
6211 PyObject * obj0 = 0 ;
6212 PyObject * obj1 = 0 ;
6213 PyObject * obj2 = 0 ;
6214 PyObject * obj3 = 0 ;
6215 char *kwnames[] = {
6216 (char *) "self",(char *) "param",(char *) "defaultArtClient",(char *) "size", NULL
6217 };
6218
6219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:XmlResourceHandler_GetIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
6221 if (SWIG_arg_fail(1)) SWIG_fail;
6222 if (obj1) {
6223 {
6224 arg2 = wxString_in_helper(obj1);
6225 if (arg2 == NULL) SWIG_fail;
6226 temp2 = true;
6227 }
6228 }
6229 if (obj2) {
6230 {
6231 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxArtClient, SWIG_POINTER_EXCEPTION | 0);
6232 if (SWIG_arg_fail(3)) SWIG_fail;
6233 if (arg3 == NULL) {
6234 SWIG_null_ref("wxArtClient");
6235 }
6236 if (SWIG_arg_fail(3)) SWIG_fail;
6237 }
6238 }
6239 if (obj3) {
6240 {
6241 wxSize * argp;
6242 SWIG_Python_ConvertPtr(obj3, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
6243 if (SWIG_arg_fail(4)) SWIG_fail;
6244 if (argp == NULL) {
6245 SWIG_null_ref("wxSize");
6246 }
6247 if (SWIG_arg_fail(4)) SWIG_fail;
6248 arg4 = *argp;
6249 }
6250 }
6251 {
6252 PyThreadState* __tstate = wxPyBeginAllowThreads();
6253 result = (arg1)->GetIcon((wxString const &)*arg2,(wxArtClient const &)*arg3,arg4);
6254
6255 wxPyEndAllowThreads(__tstate);
6256 if (PyErr_Occurred()) SWIG_fail;
6257 }
6258 {
6259 wxIcon * resultptr;
6260 resultptr = new wxIcon((wxIcon &)(result));
6261 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
6262 }
6263 {
6264 if (temp2)
6265 delete arg2;
6266 }
6267 return resultobj;
6268 fail:
6269 {
6270 if (temp2)
6271 delete arg2;
6272 }
6273 return NULL;
6274 }
6275
6276
6277 static PyObject *_wrap_XmlResourceHandler_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
6278 PyObject *resultobj;
6279 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6280 wxString const &arg2_defvalue = wxPyFontString ;
6281 wxString *arg2 = (wxString *) &arg2_defvalue ;
6282 wxFont result;
6283 bool temp2 = false ;
6284 PyObject * obj0 = 0 ;
6285 PyObject * obj1 = 0 ;
6286 char *kwnames[] = {
6287 (char *) "self",(char *) "param", NULL
6288 };
6289
6290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:XmlResourceHandler_GetFont",kwnames,&obj0,&obj1)) goto fail;
6291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
6292 if (SWIG_arg_fail(1)) SWIG_fail;
6293 if (obj1) {
6294 {
6295 arg2 = wxString_in_helper(obj1);
6296 if (arg2 == NULL) SWIG_fail;
6297 temp2 = true;
6298 }
6299 }
6300 {
6301 PyThreadState* __tstate = wxPyBeginAllowThreads();
6302 result = (arg1)->GetFont((wxString const &)*arg2);
6303
6304 wxPyEndAllowThreads(__tstate);
6305 if (PyErr_Occurred()) SWIG_fail;
6306 }
6307 {
6308 wxFont * resultptr;
6309 resultptr = new wxFont((wxFont &)(result));
6310 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
6311 }
6312 {
6313 if (temp2)
6314 delete arg2;
6315 }
6316 return resultobj;
6317 fail:
6318 {
6319 if (temp2)
6320 delete arg2;
6321 }
6322 return NULL;
6323 }
6324
6325
6326 static PyObject *_wrap_XmlResourceHandler_SetupWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6327 PyObject *resultobj;
6328 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6329 wxWindow *arg2 = (wxWindow *) 0 ;
6330 PyObject * obj0 = 0 ;
6331 PyObject * obj1 = 0 ;
6332 char *kwnames[] = {
6333 (char *) "self",(char *) "wnd", NULL
6334 };
6335
6336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_SetupWindow",kwnames,&obj0,&obj1)) goto fail;
6337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
6338 if (SWIG_arg_fail(1)) SWIG_fail;
6339 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6340 if (SWIG_arg_fail(2)) SWIG_fail;
6341 {
6342 PyThreadState* __tstate = wxPyBeginAllowThreads();
6343 (arg1)->SetupWindow(arg2);
6344
6345 wxPyEndAllowThreads(__tstate);
6346 if (PyErr_Occurred()) SWIG_fail;
6347 }
6348 Py_INCREF(Py_None); resultobj = Py_None;
6349 return resultobj;
6350 fail:
6351 return NULL;
6352 }
6353
6354
6355 static PyObject *_wrap_XmlResourceHandler_CreateChildren(PyObject *, PyObject *args, PyObject *kwargs) {
6356 PyObject *resultobj;
6357 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6358 wxObject *arg2 = (wxObject *) 0 ;
6359 bool arg3 = (bool) false ;
6360 PyObject * obj0 = 0 ;
6361 PyObject * obj1 = 0 ;
6362 PyObject * obj2 = 0 ;
6363 char *kwnames[] = {
6364 (char *) "self",(char *) "parent",(char *) "this_hnd_only", NULL
6365 };
6366
6367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_CreateChildren",kwnames,&obj0,&obj1,&obj2)) goto fail;
6368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
6369 if (SWIG_arg_fail(1)) SWIG_fail;
6370 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
6371 if (SWIG_arg_fail(2)) SWIG_fail;
6372 if (obj2) {
6373 {
6374 arg3 = (bool)(SWIG_As_bool(obj2));
6375 if (SWIG_arg_fail(3)) SWIG_fail;
6376 }
6377 }
6378 {
6379 PyThreadState* __tstate = wxPyBeginAllowThreads();
6380 (arg1)->CreateChildren(arg2,arg3);
6381
6382 wxPyEndAllowThreads(__tstate);
6383 if (PyErr_Occurred()) SWIG_fail;
6384 }
6385 Py_INCREF(Py_None); resultobj = Py_None;
6386 return resultobj;
6387 fail:
6388 return NULL;
6389 }
6390
6391
6392 static PyObject *_wrap_XmlResourceHandler_CreateChildrenPrivately(PyObject *, PyObject *args, PyObject *kwargs) {
6393 PyObject *resultobj;
6394 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6395 wxObject *arg2 = (wxObject *) 0 ;
6396 wxXmlNode *arg3 = (wxXmlNode *) NULL ;
6397 PyObject * obj0 = 0 ;
6398 PyObject * obj1 = 0 ;
6399 PyObject * obj2 = 0 ;
6400 char *kwnames[] = {
6401 (char *) "self",(char *) "parent",(char *) "rootnode", NULL
6402 };
6403
6404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_CreateChildrenPrivately",kwnames,&obj0,&obj1,&obj2)) goto fail;
6405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
6406 if (SWIG_arg_fail(1)) SWIG_fail;
6407 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
6408 if (SWIG_arg_fail(2)) SWIG_fail;
6409 if (obj2) {
6410 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxXmlNode, SWIG_POINTER_EXCEPTION | 0);
6411 if (SWIG_arg_fail(3)) SWIG_fail;
6412 }
6413 {
6414 PyThreadState* __tstate = wxPyBeginAllowThreads();
6415 (arg1)->CreateChildrenPrivately(arg2,arg3);
6416
6417 wxPyEndAllowThreads(__tstate);
6418 if (PyErr_Occurred()) SWIG_fail;
6419 }
6420 Py_INCREF(Py_None); resultobj = Py_None;
6421 return resultobj;
6422 fail:
6423 return NULL;
6424 }
6425
6426
6427 static PyObject *_wrap_XmlResourceHandler_CreateResFromNode(PyObject *, PyObject *args, PyObject *kwargs) {
6428 PyObject *resultobj;
6429 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6430 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
6431 wxObject *arg3 = (wxObject *) 0 ;
6432 wxObject *arg4 = (wxObject *) NULL ;
6433 wxObject *result;
6434 PyObject * obj0 = 0 ;
6435 PyObject * obj1 = 0 ;
6436 PyObject * obj2 = 0 ;
6437 PyObject * obj3 = 0 ;
6438 char *kwnames[] = {
6439 (char *) "self",(char *) "node",(char *) "parent",(char *) "instance", NULL
6440 };
6441
6442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:XmlResourceHandler_CreateResFromNode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
6443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
6444 if (SWIG_arg_fail(1)) SWIG_fail;
6445 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxXmlNode, SWIG_POINTER_EXCEPTION | 0);
6446 if (SWIG_arg_fail(2)) SWIG_fail;
6447 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
6448 if (SWIG_arg_fail(3)) SWIG_fail;
6449 if (obj3) {
6450 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
6451 if (SWIG_arg_fail(4)) SWIG_fail;
6452 }
6453 {
6454 PyThreadState* __tstate = wxPyBeginAllowThreads();
6455 result = (wxObject *)(arg1)->CreateResFromNode(arg2,arg3,arg4);
6456
6457 wxPyEndAllowThreads(__tstate);
6458 if (PyErr_Occurred()) SWIG_fail;
6459 }
6460 {
6461 resultobj = wxPyMake_wxObject(result, 0);
6462 }
6463 return resultobj;
6464 fail:
6465 return NULL;
6466 }
6467
6468
6469 static PyObject *_wrap_XmlResourceHandler_GetCurFileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
6470 PyObject *resultobj;
6471 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6472 wxFileSystem *result;
6473 PyObject * obj0 = 0 ;
6474 char *kwnames[] = {
6475 (char *) "self", NULL
6476 };
6477
6478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlResourceHandler_GetCurFileSystem",kwnames,&obj0)) goto fail;
6479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_EXCEPTION | 0);
6480 if (SWIG_arg_fail(1)) SWIG_fail;
6481 {
6482 PyThreadState* __tstate = wxPyBeginAllowThreads();
6483 {
6484 wxFileSystem &_result_ref = (arg1)->GetCurFileSystem();
6485 result = (wxFileSystem *) &_result_ref;
6486 }
6487
6488 wxPyEndAllowThreads(__tstate);
6489 if (PyErr_Occurred()) SWIG_fail;
6490 }
6491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileSystem, 0);
6492 return resultobj;
6493 fail:
6494 return NULL;
6495 }
6496
6497
6498 static PyObject * XmlResourceHandler_swigregister(PyObject *, PyObject *args) {
6499 PyObject *obj;
6500 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6501 SWIG_TypeClientData(SWIGTYPE_p_wxPyXmlResourceHandler, obj);
6502 Py_INCREF(obj);
6503 return Py_BuildValue((char *)"");
6504 }
6505 static PyMethodDef SwigMethods[] = {
6506 { (char *)"new_XmlResource", (PyCFunction) _wrap_new_XmlResource, METH_VARARGS | METH_KEYWORDS, NULL},
6507 { (char *)"new_EmptyXmlResource", (PyCFunction) _wrap_new_EmptyXmlResource, METH_VARARGS | METH_KEYWORDS, NULL},
6508 { (char *)"delete_XmlResource", (PyCFunction) _wrap_delete_XmlResource, METH_VARARGS | METH_KEYWORDS, NULL},
6509 { (char *)"XmlResource_Load", (PyCFunction) _wrap_XmlResource_Load, METH_VARARGS | METH_KEYWORDS, NULL},
6510 { (char *)"XmlResource_LoadFromString", (PyCFunction) _wrap_XmlResource_LoadFromString, METH_VARARGS | METH_KEYWORDS, NULL},
6511 { (char *)"XmlResource_InitAllHandlers", (PyCFunction) _wrap_XmlResource_InitAllHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
6512 { (char *)"XmlResource_AddHandler", (PyCFunction) _wrap_XmlResource_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
6513 { (char *)"XmlResource_InsertHandler", (PyCFunction) _wrap_XmlResource_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
6514 { (char *)"XmlResource_ClearHandlers", (PyCFunction) _wrap_XmlResource_ClearHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
6515 { (char *)"XmlResource_AddSubclassFactory", (PyCFunction) _wrap_XmlResource_AddSubclassFactory, METH_VARARGS | METH_KEYWORDS, NULL},
6516 { (char *)"XmlResource_LoadMenu", (PyCFunction) _wrap_XmlResource_LoadMenu, METH_VARARGS | METH_KEYWORDS, NULL},
6517 { (char *)"XmlResource_LoadMenuBar", (PyCFunction) _wrap_XmlResource_LoadMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
6518 { (char *)"XmlResource_LoadMenuBarOnFrame", (PyCFunction) _wrap_XmlResource_LoadMenuBarOnFrame, METH_VARARGS | METH_KEYWORDS, NULL},
6519 { (char *)"XmlResource_LoadToolBar", (PyCFunction) _wrap_XmlResource_LoadToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
6520 { (char *)"XmlResource_LoadDialog", (PyCFunction) _wrap_XmlResource_LoadDialog, METH_VARARGS | METH_KEYWORDS, NULL},
6521 { (char *)"XmlResource_LoadOnDialog", (PyCFunction) _wrap_XmlResource_LoadOnDialog, METH_VARARGS | METH_KEYWORDS, NULL},
6522 { (char *)"XmlResource_LoadPanel", (PyCFunction) _wrap_XmlResource_LoadPanel, METH_VARARGS | METH_KEYWORDS, NULL},
6523 { (char *)"XmlResource_LoadOnPanel", (PyCFunction) _wrap_XmlResource_LoadOnPanel, METH_VARARGS | METH_KEYWORDS, NULL},
6524 { (char *)"XmlResource_LoadFrame", (PyCFunction) _wrap_XmlResource_LoadFrame, METH_VARARGS | METH_KEYWORDS, NULL},
6525 { (char *)"XmlResource_LoadOnFrame", (PyCFunction) _wrap_XmlResource_LoadOnFrame, METH_VARARGS | METH_KEYWORDS, NULL},
6526 { (char *)"XmlResource_LoadObject", (PyCFunction) _wrap_XmlResource_LoadObject, METH_VARARGS | METH_KEYWORDS, NULL},
6527 { (char *)"XmlResource_LoadOnObject", (PyCFunction) _wrap_XmlResource_LoadOnObject, METH_VARARGS | METH_KEYWORDS, NULL},
6528 { (char *)"XmlResource_LoadBitmap", (PyCFunction) _wrap_XmlResource_LoadBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
6529 { (char *)"XmlResource_LoadIcon", (PyCFunction) _wrap_XmlResource_LoadIcon, METH_VARARGS | METH_KEYWORDS, NULL},
6530 { (char *)"XmlResource_AttachUnknownControl", (PyCFunction) _wrap_XmlResource_AttachUnknownControl, METH_VARARGS | METH_KEYWORDS, NULL},
6531 { (char *)"XmlResource_GetXRCID", (PyCFunction) _wrap_XmlResource_GetXRCID, METH_VARARGS | METH_KEYWORDS, NULL},
6532 { (char *)"XmlResource_GetVersion", (PyCFunction) _wrap_XmlResource_GetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
6533 { (char *)"XmlResource_CompareVersion", (PyCFunction) _wrap_XmlResource_CompareVersion, METH_VARARGS | METH_KEYWORDS, NULL},
6534 { (char *)"XmlResource_Get", (PyCFunction) _wrap_XmlResource_Get, METH_VARARGS | METH_KEYWORDS, NULL},
6535 { (char *)"XmlResource_Set", (PyCFunction) _wrap_XmlResource_Set, METH_VARARGS | METH_KEYWORDS, NULL},
6536 { (char *)"XmlResource_GetFlags", (PyCFunction) _wrap_XmlResource_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
6537 { (char *)"XmlResource_SetFlags", (PyCFunction) _wrap_XmlResource_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
6538 { (char *)"XmlResource_swigregister", XmlResource_swigregister, METH_VARARGS, NULL},
6539 { (char *)"new_XmlSubclassFactory", (PyCFunction) _wrap_new_XmlSubclassFactory, METH_VARARGS | METH_KEYWORDS, NULL},
6540 { (char *)"XmlSubclassFactory__setCallbackInfo", (PyCFunction) _wrap_XmlSubclassFactory__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
6541 { (char *)"XmlSubclassFactory_swigregister", XmlSubclassFactory_swigregister, METH_VARARGS, NULL},
6542 { (char *)"new_XmlProperty", (PyCFunction) _wrap_new_XmlProperty, METH_VARARGS | METH_KEYWORDS, NULL},
6543 { (char *)"XmlProperty_GetName", (PyCFunction) _wrap_XmlProperty_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
6544 { (char *)"XmlProperty_GetValue", (PyCFunction) _wrap_XmlProperty_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
6545 { (char *)"XmlProperty_GetNext", (PyCFunction) _wrap_XmlProperty_GetNext, METH_VARARGS | METH_KEYWORDS, NULL},
6546 { (char *)"XmlProperty_SetName", (PyCFunction) _wrap_XmlProperty_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
6547 { (char *)"XmlProperty_SetValue", (PyCFunction) _wrap_XmlProperty_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
6548 { (char *)"XmlProperty_SetNext", (PyCFunction) _wrap_XmlProperty_SetNext, METH_VARARGS | METH_KEYWORDS, NULL},
6549 { (char *)"XmlProperty_swigregister", XmlProperty_swigregister, METH_VARARGS, NULL},
6550 { (char *)"new_XmlNode", (PyCFunction) _wrap_new_XmlNode, METH_VARARGS | METH_KEYWORDS, NULL},
6551 { (char *)"delete_XmlNode", (PyCFunction) _wrap_delete_XmlNode, METH_VARARGS | METH_KEYWORDS, NULL},
6552 { (char *)"new_XmlNodeEasy", (PyCFunction) _wrap_new_XmlNodeEasy, METH_VARARGS | METH_KEYWORDS, NULL},
6553 { (char *)"XmlNode_AddChild", (PyCFunction) _wrap_XmlNode_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
6554 { (char *)"XmlNode_InsertChild", (PyCFunction) _wrap_XmlNode_InsertChild, METH_VARARGS | METH_KEYWORDS, NULL},
6555 { (char *)"XmlNode_RemoveChild", (PyCFunction) _wrap_XmlNode_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
6556 { (char *)"XmlNode_AddProperty", (PyCFunction) _wrap_XmlNode_AddProperty, METH_VARARGS | METH_KEYWORDS, NULL},
6557 { (char *)"XmlNode_AddPropertyName", (PyCFunction) _wrap_XmlNode_AddPropertyName, METH_VARARGS | METH_KEYWORDS, NULL},
6558 { (char *)"XmlNode_DeleteProperty", (PyCFunction) _wrap_XmlNode_DeleteProperty, METH_VARARGS | METH_KEYWORDS, NULL},
6559 { (char *)"XmlNode_GetType", (PyCFunction) _wrap_XmlNode_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
6560 { (char *)"XmlNode_GetName", (PyCFunction) _wrap_XmlNode_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
6561 { (char *)"XmlNode_GetContent", (PyCFunction) _wrap_XmlNode_GetContent, METH_VARARGS | METH_KEYWORDS, NULL},
6562 { (char *)"XmlNode_GetParent", (PyCFunction) _wrap_XmlNode_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
6563 { (char *)"XmlNode_GetNext", (PyCFunction) _wrap_XmlNode_GetNext, METH_VARARGS | METH_KEYWORDS, NULL},
6564 { (char *)"XmlNode_GetChildren", (PyCFunction) _wrap_XmlNode_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
6565 { (char *)"XmlNode_GetProperties", (PyCFunction) _wrap_XmlNode_GetProperties, METH_VARARGS | METH_KEYWORDS, NULL},
6566 { (char *)"XmlNode_GetPropVal", (PyCFunction) _wrap_XmlNode_GetPropVal, METH_VARARGS | METH_KEYWORDS, NULL},
6567 { (char *)"XmlNode_HasProp", (PyCFunction) _wrap_XmlNode_HasProp, METH_VARARGS | METH_KEYWORDS, NULL},
6568 { (char *)"XmlNode_SetType", (PyCFunction) _wrap_XmlNode_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
6569 { (char *)"XmlNode_SetName", (PyCFunction) _wrap_XmlNode_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
6570 { (char *)"XmlNode_SetContent", (PyCFunction) _wrap_XmlNode_SetContent, METH_VARARGS | METH_KEYWORDS, NULL},
6571 { (char *)"XmlNode_SetParent", (PyCFunction) _wrap_XmlNode_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
6572 { (char *)"XmlNode_SetNext", (PyCFunction) _wrap_XmlNode_SetNext, METH_VARARGS | METH_KEYWORDS, NULL},
6573 { (char *)"XmlNode_SetChildren", (PyCFunction) _wrap_XmlNode_SetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
6574 { (char *)"XmlNode_SetProperties", (PyCFunction) _wrap_XmlNode_SetProperties, METH_VARARGS | METH_KEYWORDS, NULL},
6575 { (char *)"XmlNode_swigregister", XmlNode_swigregister, METH_VARARGS, NULL},
6576 { (char *)"new_XmlDocument", (PyCFunction) _wrap_new_XmlDocument, METH_VARARGS | METH_KEYWORDS, NULL},
6577 { (char *)"new_XmlDocumentFromStream", (PyCFunction) _wrap_new_XmlDocumentFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
6578 { (char *)"new_EmptyXmlDocument", (PyCFunction) _wrap_new_EmptyXmlDocument, METH_VARARGS | METH_KEYWORDS, NULL},
6579 { (char *)"delete_XmlDocument", (PyCFunction) _wrap_delete_XmlDocument, METH_VARARGS | METH_KEYWORDS, NULL},
6580 { (char *)"XmlDocument_Load", (PyCFunction) _wrap_XmlDocument_Load, METH_VARARGS | METH_KEYWORDS, NULL},
6581 { (char *)"XmlDocument_LoadFromStream", (PyCFunction) _wrap_XmlDocument_LoadFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
6582 { (char *)"XmlDocument_Save", (PyCFunction) _wrap_XmlDocument_Save, METH_VARARGS | METH_KEYWORDS, NULL},
6583 { (char *)"XmlDocument_SaveToStream", (PyCFunction) _wrap_XmlDocument_SaveToStream, METH_VARARGS | METH_KEYWORDS, NULL},
6584 { (char *)"XmlDocument_IsOk", (PyCFunction) _wrap_XmlDocument_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
6585 { (char *)"XmlDocument_GetRoot", (PyCFunction) _wrap_XmlDocument_GetRoot, METH_VARARGS | METH_KEYWORDS, NULL},
6586 { (char *)"XmlDocument_GetVersion", (PyCFunction) _wrap_XmlDocument_GetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
6587 { (char *)"XmlDocument_GetFileEncoding", (PyCFunction) _wrap_XmlDocument_GetFileEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
6588 { (char *)"XmlDocument_SetRoot", (PyCFunction) _wrap_XmlDocument_SetRoot, METH_VARARGS | METH_KEYWORDS, NULL},
6589 { (char *)"XmlDocument_SetVersion", (PyCFunction) _wrap_XmlDocument_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
6590 { (char *)"XmlDocument_SetFileEncoding", (PyCFunction) _wrap_XmlDocument_SetFileEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
6591 { (char *)"XmlDocument_swigregister", XmlDocument_swigregister, METH_VARARGS, NULL},
6592 { (char *)"new_XmlResourceHandler", (PyCFunction) _wrap_new_XmlResourceHandler, METH_VARARGS | METH_KEYWORDS, NULL},
6593 { (char *)"XmlResourceHandler__setCallbackInfo", (PyCFunction) _wrap_XmlResourceHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
6594 { (char *)"XmlResourceHandler_CreateResource", (PyCFunction) _wrap_XmlResourceHandler_CreateResource, METH_VARARGS | METH_KEYWORDS, NULL},
6595 { (char *)"XmlResourceHandler_SetParentResource", (PyCFunction) _wrap_XmlResourceHandler_SetParentResource, METH_VARARGS | METH_KEYWORDS, NULL},
6596 { (char *)"XmlResourceHandler_GetResource", (PyCFunction) _wrap_XmlResourceHandler_GetResource, METH_VARARGS | METH_KEYWORDS, NULL},
6597 { (char *)"XmlResourceHandler_GetNode", (PyCFunction) _wrap_XmlResourceHandler_GetNode, METH_VARARGS | METH_KEYWORDS, NULL},
6598 { (char *)"XmlResourceHandler_GetClass", (PyCFunction) _wrap_XmlResourceHandler_GetClass, METH_VARARGS | METH_KEYWORDS, NULL},
6599 { (char *)"XmlResourceHandler_GetParent", (PyCFunction) _wrap_XmlResourceHandler_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
6600 { (char *)"XmlResourceHandler_GetInstance", (PyCFunction) _wrap_XmlResourceHandler_GetInstance, METH_VARARGS | METH_KEYWORDS, NULL},
6601 { (char *)"XmlResourceHandler_GetParentAsWindow", (PyCFunction) _wrap_XmlResourceHandler_GetParentAsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
6602 { (char *)"XmlResourceHandler_IsOfClass", (PyCFunction) _wrap_XmlResourceHandler_IsOfClass, METH_VARARGS | METH_KEYWORDS, NULL},
6603 { (char *)"XmlResourceHandler_GetNodeContent", (PyCFunction) _wrap_XmlResourceHandler_GetNodeContent, METH_VARARGS | METH_KEYWORDS, NULL},
6604 { (char *)"XmlResourceHandler_HasParam", (PyCFunction) _wrap_XmlResourceHandler_HasParam, METH_VARARGS | METH_KEYWORDS, NULL},
6605 { (char *)"XmlResourceHandler_GetParamNode", (PyCFunction) _wrap_XmlResourceHandler_GetParamNode, METH_VARARGS | METH_KEYWORDS, NULL},
6606 { (char *)"XmlResourceHandler_GetParamValue", (PyCFunction) _wrap_XmlResourceHandler_GetParamValue, METH_VARARGS | METH_KEYWORDS, NULL},
6607 { (char *)"XmlResourceHandler_AddStyle", (PyCFunction) _wrap_XmlResourceHandler_AddStyle, METH_VARARGS | METH_KEYWORDS, NULL},
6608 { (char *)"XmlResourceHandler_AddWindowStyles", (PyCFunction) _wrap_XmlResourceHandler_AddWindowStyles, METH_VARARGS | METH_KEYWORDS, NULL},
6609 { (char *)"XmlResourceHandler_GetStyle", (PyCFunction) _wrap_XmlResourceHandler_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
6610 { (char *)"XmlResourceHandler_GetText", (PyCFunction) _wrap_XmlResourceHandler_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
6611 { (char *)"XmlResourceHandler_GetID", (PyCFunction) _wrap_XmlResourceHandler_GetID, METH_VARARGS | METH_KEYWORDS, NULL},
6612 { (char *)"XmlResourceHandler_GetName", (PyCFunction) _wrap_XmlResourceHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
6613 { (char *)"XmlResourceHandler_GetBool", (PyCFunction) _wrap_XmlResourceHandler_GetBool, METH_VARARGS | METH_KEYWORDS, NULL},
6614 { (char *)"XmlResourceHandler_GetLong", (PyCFunction) _wrap_XmlResourceHandler_GetLong, METH_VARARGS | METH_KEYWORDS, NULL},
6615 { (char *)"XmlResourceHandler_GetColour", (PyCFunction) _wrap_XmlResourceHandler_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
6616 { (char *)"XmlResourceHandler_GetSize", (PyCFunction) _wrap_XmlResourceHandler_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
6617 { (char *)"XmlResourceHandler_GetPosition", (PyCFunction) _wrap_XmlResourceHandler_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
6618 { (char *)"XmlResourceHandler_GetDimension", (PyCFunction) _wrap_XmlResourceHandler_GetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
6619 { (char *)"XmlResourceHandler_GetBitmap", (PyCFunction) _wrap_XmlResourceHandler_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
6620 { (char *)"XmlResourceHandler_GetIcon", (PyCFunction) _wrap_XmlResourceHandler_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
6621 { (char *)"XmlResourceHandler_GetFont", (PyCFunction) _wrap_XmlResourceHandler_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
6622 { (char *)"XmlResourceHandler_SetupWindow", (PyCFunction) _wrap_XmlResourceHandler_SetupWindow, METH_VARARGS | METH_KEYWORDS, NULL},
6623 { (char *)"XmlResourceHandler_CreateChildren", (PyCFunction) _wrap_XmlResourceHandler_CreateChildren, METH_VARARGS | METH_KEYWORDS, NULL},
6624 { (char *)"XmlResourceHandler_CreateChildrenPrivately", (PyCFunction) _wrap_XmlResourceHandler_CreateChildrenPrivately, METH_VARARGS | METH_KEYWORDS, NULL},
6625 { (char *)"XmlResourceHandler_CreateResFromNode", (PyCFunction) _wrap_XmlResourceHandler_CreateResFromNode, METH_VARARGS | METH_KEYWORDS, NULL},
6626 { (char *)"XmlResourceHandler_GetCurFileSystem", (PyCFunction) _wrap_XmlResourceHandler_GetCurFileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
6627 { (char *)"XmlResourceHandler_swigregister", XmlResourceHandler_swigregister, METH_VARARGS, NULL},
6628 { NULL, NULL, 0, NULL }
6629 };
6630
6631
6632 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6633
6634 static void *_p_wxControlTo_p_wxWindow(void *x) {
6635 return (void *)((wxWindow *) ((wxControl *) x));
6636 }
6637 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
6638 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
6639 }
6640 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
6641 return (void *)((wxWindow *) ((wxMenuBar *) x));
6642 }
6643 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
6644 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
6645 }
6646 static void *_p_wxXmlDocumentTo_p_wxObject(void *x) {
6647 return (void *)((wxObject *) ((wxXmlDocument *) x));
6648 }
6649 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
6650 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
6651 }
6652 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
6653 return (void *)((wxObject *) ((wxSizerItem *) x));
6654 }
6655 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
6656 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
6657 }
6658 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
6659 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
6660 }
6661 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
6662 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
6663 }
6664 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
6665 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
6666 }
6667 static void *_p_wxSizerTo_p_wxObject(void *x) {
6668 return (void *)((wxObject *) ((wxSizer *) x));
6669 }
6670 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
6671 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
6672 }
6673 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
6674 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
6675 }
6676 static void *_p_wxEventTo_p_wxObject(void *x) {
6677 return (void *)((wxObject *) ((wxEvent *) x));
6678 }
6679 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
6680 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
6681 }
6682 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
6683 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
6684 }
6685 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
6686 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
6687 }
6688 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
6689 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
6690 }
6691 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
6692 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
6693 }
6694 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
6695 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
6696 }
6697 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
6698 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
6699 }
6700 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
6701 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
6702 }
6703 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
6704 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
6705 }
6706 static void *_p_wxControlTo_p_wxObject(void *x) {
6707 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
6708 }
6709 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
6710 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
6711 }
6712 static void *_p_wxFSFileTo_p_wxObject(void *x) {
6713 return (void *)((wxObject *) ((wxFSFile *) x));
6714 }
6715 static void *_p_wxPySizerTo_p_wxObject(void *x) {
6716 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
6717 }
6718 static void *_p_wxPyEventTo_p_wxObject(void *x) {
6719 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
6720 }
6721 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
6722 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
6723 }
6724 static void *_p_wxShowEventTo_p_wxObject(void *x) {
6725 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
6726 }
6727 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
6728 return (void *)((wxObject *) ((wxMenuItem *) x));
6729 }
6730 static void *_p_wxDateEventTo_p_wxObject(void *x) {
6731 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
6732 }
6733 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
6734 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
6735 }
6736 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
6737 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
6738 }
6739 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
6740 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
6741 }
6742 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
6743 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
6744 }
6745 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
6746 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
6747 }
6748 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
6749 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
6750 }
6751 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
6752 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
6753 }
6754 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
6755 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
6756 }
6757 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
6758 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
6759 }
6760 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
6761 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
6762 }
6763 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
6764 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
6765 }
6766 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
6767 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
6768 }
6769 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
6770 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
6771 }
6772 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
6773 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
6774 }
6775 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
6776 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
6777 }
6778 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
6779 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
6780 }
6781 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
6782 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
6783 }
6784 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
6785 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
6786 }
6787 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
6788 return (void *)((wxObject *) ((wxImageHandler *) x));
6789 }
6790 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
6791 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
6792 }
6793 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
6794 return (void *)((wxObject *) ((wxEvtHandler *) x));
6795 }
6796 static void *_p_wxPyXmlResourceHandlerTo_p_wxObject(void *x) {
6797 return (void *)((wxObject *) ((wxPyXmlResourceHandler *) x));
6798 }
6799 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
6800 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
6801 }
6802 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
6803 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
6804 }
6805 static void *_p_wxImageTo_p_wxObject(void *x) {
6806 return (void *)((wxObject *) ((wxImage *) x));
6807 }
6808 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
6809 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
6810 }
6811 static void *_p_wxXmlResourceTo_p_wxObject(void *x) {
6812 return (void *)((wxObject *) ((wxXmlResource *) x));
6813 }
6814 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
6815 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
6816 }
6817 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
6818 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
6819 }
6820 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
6821 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
6822 }
6823 static void *_p_wxWindowTo_p_wxObject(void *x) {
6824 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
6825 }
6826 static void *_p_wxMenuTo_p_wxObject(void *x) {
6827 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
6828 }
6829 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
6830 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
6831 }
6832 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
6833 return (void *)((wxObject *) ((wxFileSystem *) x));
6834 }
6835 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
6836 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
6837 }
6838 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
6839 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
6840 }
6841 static void *_p_wxPyAppTo_p_wxObject(void *x) {
6842 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
6843 }
6844 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
6845 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
6846 }
6847 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
6848 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
6849 }
6850 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
6851 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
6852 }
6853 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
6854 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
6855 }
6856 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
6857 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
6858 }
6859 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
6860 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
6861 }
6862 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
6863 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
6864 }
6865 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
6866 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
6867 }
6868 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
6869 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
6870 }
6871 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
6872 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
6873 }
6874 static void *_p_wxValidatorTo_p_wxObject(void *x) {
6875 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
6876 }
6877 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}};
6878 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}};
6879 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}};
6880 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}};
6881 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}};
6882 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}};
6883 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}};
6884 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}};
6885 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}};
6886 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}};
6887 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}};
6888 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}};
6889 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}};
6890 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}};
6891 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}};
6892 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}};
6893 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}};
6894 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}};
6895 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}};
6896 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}};
6897 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}};
6898 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}};
6899 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}};
6900 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}};
6901 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}};
6902 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}};
6903 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}};
6904 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}};
6905 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}};
6906 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}};
6907 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}};
6908 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}};
6909
6910 static swig_type_info *swig_types_initial[] = {
6911 _swigt__p_wxFrame,
6912 _swigt__p_wxIcon,
6913 _swigt__p_wxObject,
6914 _swigt__p_unsigned_char,
6915 _swigt__p_wxDialog,
6916 _swigt__p_wxColour,
6917 _swigt__p_wxWindow,
6918 _swigt__p_wxArtClient,
6919 _swigt__p_unsigned_long,
6920 _swigt__p_wxPyXmlSubclassFactory,
6921 _swigt__p_wxBitmap,
6922 _swigt__p_form_ops_t,
6923 _swigt__p_unsigned_int,
6924 _swigt__unsigned_int,
6925 _swigt__p_wxDuplexMode,
6926 _swigt__p_char,
6927 _swigt__p_wxPoint,
6928 _swigt__p_wxXmlNode,
6929 _swigt__p_wxInputStream,
6930 _swigt__p_wxOutputStream,
6931 _swigt__p_wxPyXmlResourceHandler,
6932 _swigt__p_wxFileSystem,
6933 _swigt__std__ptrdiff_t,
6934 _swigt__ptrdiff_t,
6935 _swigt__p_wxXmlProperty,
6936 _swigt__p_wxFont,
6937 _swigt__p_wxXmlResource,
6938 _swigt__p_wxPanel,
6939 _swigt__p_wxXmlDocument,
6940 _swigt__p_wxPaperSize,
6941 _swigt__p_wxSize,
6942 _swigt__p_int,
6943 0
6944 };
6945
6946
6947 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
6948
6949 static swig_const_info swig_const_table[] = {
6950 {0, 0, 0, 0.0, 0, 0}};
6951
6952 #ifdef __cplusplus
6953 }
6954 #endif
6955
6956
6957 #ifdef __cplusplus
6958 extern "C" {
6959 #endif
6960
6961 /* Python-specific SWIG API */
6962 #define SWIG_newvarlink() SWIG_Python_newvarlink()
6963 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
6964 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
6965
6966 /* -----------------------------------------------------------------------------
6967 * global variable support code.
6968 * ----------------------------------------------------------------------------- */
6969
6970 typedef struct swig_globalvar {
6971 char *name; /* Name of global variable */
6972 PyObject *(*get_attr)(); /* Return the current value */
6973 int (*set_attr)(PyObject *); /* Set the value */
6974 struct swig_globalvar *next;
6975 } swig_globalvar;
6976
6977 typedef struct swig_varlinkobject {
6978 PyObject_HEAD
6979 swig_globalvar *vars;
6980 } swig_varlinkobject;
6981
6982 static PyObject *
6983 swig_varlink_repr(swig_varlinkobject *v) {
6984 v = v;
6985 return PyString_FromString("<Swig global variables>");
6986 }
6987
6988 static int
6989 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
6990 swig_globalvar *var;
6991 flags = flags;
6992 fprintf(fp,"Swig global variables { ");
6993 for (var = v->vars; var; var=var->next) {
6994 fprintf(fp,"%s", var->name);
6995 if (var->next) fprintf(fp,", ");
6996 }
6997 fprintf(fp," }\n");
6998 return 0;
6999 }
7000
7001 static PyObject *
7002 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
7003 swig_globalvar *var = v->vars;
7004 while (var) {
7005 if (strcmp(var->name,n) == 0) {
7006 return (*var->get_attr)();
7007 }
7008 var = var->next;
7009 }
7010 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
7011 return NULL;
7012 }
7013
7014 static int
7015 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
7016 swig_globalvar *var = v->vars;
7017 while (var) {
7018 if (strcmp(var->name,n) == 0) {
7019 return (*var->set_attr)(p);
7020 }
7021 var = var->next;
7022 }
7023 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
7024 return 1;
7025 }
7026
7027 static PyTypeObject varlinktype = {
7028 PyObject_HEAD_INIT(0)
7029 0, /* Number of items in variable part (ob_size) */
7030 (char *)"swigvarlink", /* Type name (tp_name) */
7031 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
7032 0, /* Itemsize (tp_itemsize) */
7033 0, /* Deallocator (tp_dealloc) */
7034 (printfunc) swig_varlink_print, /* Print (tp_print) */
7035 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
7036 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
7037 0, /* tp_compare */
7038 (reprfunc) swig_varlink_repr, /* tp_repr */
7039 0, /* tp_as_number */
7040 0, /* tp_as_sequence */
7041 0, /* tp_as_mapping */
7042 0, /* tp_hash */
7043 0, /* tp_call */
7044 0, /* tp_str */
7045 0, /* tp_getattro */
7046 0, /* tp_setattro */
7047 0, /* tp_as_buffer */
7048 0, /* tp_flags */
7049 0, /* tp_doc */
7050 #if PY_VERSION_HEX >= 0x02000000
7051 0, /* tp_traverse */
7052 0, /* tp_clear */
7053 #endif
7054 #if PY_VERSION_HEX >= 0x02010000
7055 0, /* tp_richcompare */
7056 0, /* tp_weaklistoffset */
7057 #endif
7058 #if PY_VERSION_HEX >= 0x02020000
7059 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
7060 #endif
7061 #if PY_VERSION_HEX >= 0x02030000
7062 0, /* tp_del */
7063 #endif
7064 #ifdef COUNT_ALLOCS
7065 0,0,0,0 /* tp_alloc -> tp_next */
7066 #endif
7067 };
7068
7069 /* Create a variable linking object for use later */
7070 static PyObject *
7071 SWIG_Python_newvarlink(void) {
7072 swig_varlinkobject *result = 0;
7073 result = PyMem_NEW(swig_varlinkobject,1);
7074 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
7075 result->ob_type = &varlinktype;
7076 result->vars = 0;
7077 result->ob_refcnt = 0;
7078 Py_XINCREF((PyObject *) result);
7079 return ((PyObject*) result);
7080 }
7081
7082 static void
7083 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
7084 swig_varlinkobject *v;
7085 swig_globalvar *gv;
7086 v= (swig_varlinkobject *) p;
7087 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
7088 gv->name = (char *) malloc(strlen(name)+1);
7089 strcpy(gv->name,name);
7090 gv->get_attr = get_attr;
7091 gv->set_attr = set_attr;
7092 gv->next = v->vars;
7093 v->vars = gv;
7094 }
7095
7096 /* -----------------------------------------------------------------------------
7097 * constants/methods manipulation
7098 * ----------------------------------------------------------------------------- */
7099
7100 /* Install Constants */
7101 static void
7102 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
7103 PyObject *obj = 0;
7104 size_t i;
7105 for (i = 0; constants[i].type; i++) {
7106 switch(constants[i].type) {
7107 case SWIG_PY_INT:
7108 obj = PyInt_FromLong(constants[i].lvalue);
7109 break;
7110 case SWIG_PY_FLOAT:
7111 obj = PyFloat_FromDouble(constants[i].dvalue);
7112 break;
7113 case SWIG_PY_STRING:
7114 if (constants[i].pvalue) {
7115 obj = PyString_FromString((char *) constants[i].pvalue);
7116 } else {
7117 Py_INCREF(Py_None);
7118 obj = Py_None;
7119 }
7120 break;
7121 case SWIG_PY_POINTER:
7122 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
7123 break;
7124 case SWIG_PY_BINARY:
7125 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
7126 break;
7127 default:
7128 obj = 0;
7129 break;
7130 }
7131 if (obj) {
7132 PyDict_SetItemString(d,constants[i].name,obj);
7133 Py_DECREF(obj);
7134 }
7135 }
7136 }
7137
7138 /* -----------------------------------------------------------------------------*/
7139 /* Fix SwigMethods to carry the callback ptrs when needed */
7140 /* -----------------------------------------------------------------------------*/
7141
7142 static void
7143 SWIG_Python_FixMethods(PyMethodDef *methods,
7144 swig_const_info *const_table,
7145 swig_type_info **types,
7146 swig_type_info **types_initial) {
7147 size_t i;
7148 for (i = 0; methods[i].ml_name; ++i) {
7149 char *c = methods[i].ml_doc;
7150 if (c && (c = strstr(c, "swig_ptr: "))) {
7151 int j;
7152 swig_const_info *ci = 0;
7153 char *name = c + 10;
7154 for (j = 0; const_table[j].type; j++) {
7155 if (strncmp(const_table[j].name, name,
7156 strlen(const_table[j].name)) == 0) {
7157 ci = &(const_table[j]);
7158 break;
7159 }
7160 }
7161 if (ci) {
7162 size_t shift = (ci->ptype) - types;
7163 swig_type_info *ty = types_initial[shift];
7164 size_t ldoc = (c - methods[i].ml_doc);
7165 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
7166 char *ndoc = (char*)malloc(ldoc + lptr + 10);
7167 char *buff = ndoc;
7168 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
7169 strncpy(buff, methods[i].ml_doc, ldoc);
7170 buff += ldoc;
7171 strncpy(buff, "swig_ptr: ", 10);
7172 buff += 10;
7173 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
7174 methods[i].ml_doc = ndoc;
7175 }
7176 }
7177 }
7178 }
7179
7180 /* -----------------------------------------------------------------------------*
7181 * Initialize type list
7182 * -----------------------------------------------------------------------------*/
7183
7184 #if PY_MAJOR_VERSION < 2
7185 /* PyModule_AddObject function was introduced in Python 2.0. The following function
7186 is copied out of Python/modsupport.c in python version 2.3.4 */
7187 static int
7188 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
7189 {
7190 PyObject *dict;
7191 if (!PyModule_Check(m)) {
7192 PyErr_SetString(PyExc_TypeError,
7193 "PyModule_AddObject() needs module as first arg");
7194 return -1;
7195 }
7196 if (!o) {
7197 PyErr_SetString(PyExc_TypeError,
7198 "PyModule_AddObject() needs non-NULL value");
7199 return -1;
7200 }
7201
7202 dict = PyModule_GetDict(m);
7203 if (dict == NULL) {
7204 /* Internal error -- modules must have a dict! */
7205 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
7206 PyModule_GetName(m));
7207 return -1;
7208 }
7209 if (PyDict_SetItemString(dict, name, o))
7210 return -1;
7211 Py_DECREF(o);
7212 return 0;
7213 }
7214 #endif
7215
7216 static swig_type_info **
7217 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
7218 static PyMethodDef swig_empty_runtime_method_table[] = {
7219 {
7220 NULL, NULL, 0, NULL
7221 }
7222 };/* Sentinel */
7223
7224 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
7225 swig_empty_runtime_method_table);
7226 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
7227 if (pointer && module) {
7228 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
7229 }
7230 return type_list_handle;
7231 }
7232
7233 static swig_type_info **
7234 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
7235 swig_type_info **type_pointer;
7236
7237 /* first check if module already created */
7238 type_pointer = SWIG_Python_GetTypeListHandle();
7239 if (type_pointer) {
7240 return type_pointer;
7241 } else {
7242 /* create a new module and variable */
7243 return SWIG_Python_SetTypeListHandle(type_list_handle);
7244 }
7245 }
7246
7247 #ifdef __cplusplus
7248 }
7249 #endif
7250
7251 /* -----------------------------------------------------------------------------*
7252 * Partial Init method
7253 * -----------------------------------------------------------------------------*/
7254
7255 #ifdef SWIG_LINK_RUNTIME
7256 #ifdef __cplusplus
7257 extern "C"
7258 #endif
7259 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
7260 #endif
7261
7262 #ifdef __cplusplus
7263 extern "C"
7264 #endif
7265 SWIGEXPORT(void) SWIG_init(void) {
7266 static PyObject *SWIG_globals = 0;
7267 static int typeinit = 0;
7268 PyObject *m, *d;
7269 int i;
7270 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
7271
7272 /* Fix SwigMethods to carry the callback ptrs when needed */
7273 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
7274
7275 m = Py_InitModule((char *) SWIG_name, SwigMethods);
7276 d = PyModule_GetDict(m);
7277
7278 if (!typeinit) {
7279 #ifdef SWIG_LINK_RUNTIME
7280 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
7281 #else
7282 # ifndef SWIG_STATIC_RUNTIME
7283 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
7284 # endif
7285 #endif
7286 for (i = 0; swig_types_initial[i]; i++) {
7287 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
7288 }
7289 typeinit = 1;
7290 }
7291 SWIG_InstallConstants(d,swig_const_table);
7292
7293 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
7294 SWIG_addvarlink(SWIG_globals,(char*)"UTF8String",_wrap_UTF8String_get, _wrap_UTF8String_set);
7295 SWIG_addvarlink(SWIG_globals,(char*)"StyleString",_wrap_StyleString_get, _wrap_StyleString_set);
7296 SWIG_addvarlink(SWIG_globals,(char*)"SizeString",_wrap_SizeString_get, _wrap_SizeString_set);
7297 SWIG_addvarlink(SWIG_globals,(char*)"PosString",_wrap_PosString_get, _wrap_PosString_set);
7298 SWIG_addvarlink(SWIG_globals,(char*)"BitmapString",_wrap_BitmapString_get, _wrap_BitmapString_set);
7299 SWIG_addvarlink(SWIG_globals,(char*)"IconString",_wrap_IconString_get, _wrap_IconString_set);
7300 SWIG_addvarlink(SWIG_globals,(char*)"FontString",_wrap_FontString_get, _wrap_FontString_set);
7301 {
7302 PyDict_SetItemString(d,"WX_XMLRES_CURRENT_VERSION_MAJOR", SWIG_From_int((int)(WX_XMLRES_CURRENT_VERSION_MAJOR)));
7303 }
7304 {
7305 PyDict_SetItemString(d,"WX_XMLRES_CURRENT_VERSION_MINOR", SWIG_From_int((int)(WX_XMLRES_CURRENT_VERSION_MINOR)));
7306 }
7307 {
7308 PyDict_SetItemString(d,"WX_XMLRES_CURRENT_VERSION_RELEASE", SWIG_From_int((int)(WX_XMLRES_CURRENT_VERSION_RELEASE)));
7309 }
7310 {
7311 PyDict_SetItemString(d,"WX_XMLRES_CURRENT_VERSION_REVISION", SWIG_From_int((int)(WX_XMLRES_CURRENT_VERSION_REVISION)));
7312 }
7313 {
7314 PyDict_SetItemString(d,"XRC_USE_LOCALE", SWIG_From_int((int)(wxXRC_USE_LOCALE)));
7315 }
7316 {
7317 PyDict_SetItemString(d,"XRC_NO_SUBCLASSING", SWIG_From_int((int)(wxXRC_NO_SUBCLASSING)));
7318 }
7319 {
7320 PyDict_SetItemString(d,"XRC_NO_RELOADING", SWIG_From_int((int)(wxXRC_NO_RELOADING)));
7321 }
7322 {
7323 PyDict_SetItemString(d,"XML_ELEMENT_NODE", SWIG_From_int((int)(wxXML_ELEMENT_NODE)));
7324 }
7325 {
7326 PyDict_SetItemString(d,"XML_ATTRIBUTE_NODE", SWIG_From_int((int)(wxXML_ATTRIBUTE_NODE)));
7327 }
7328 {
7329 PyDict_SetItemString(d,"XML_TEXT_NODE", SWIG_From_int((int)(wxXML_TEXT_NODE)));
7330 }
7331 {
7332 PyDict_SetItemString(d,"XML_CDATA_SECTION_NODE", SWIG_From_int((int)(wxXML_CDATA_SECTION_NODE)));
7333 }
7334 {
7335 PyDict_SetItemString(d,"XML_ENTITY_REF_NODE", SWIG_From_int((int)(wxXML_ENTITY_REF_NODE)));
7336 }
7337 {
7338 PyDict_SetItemString(d,"XML_ENTITY_NODE", SWIG_From_int((int)(wxXML_ENTITY_NODE)));
7339 }
7340 {
7341 PyDict_SetItemString(d,"XML_PI_NODE", SWIG_From_int((int)(wxXML_PI_NODE)));
7342 }
7343 {
7344 PyDict_SetItemString(d,"XML_COMMENT_NODE", SWIG_From_int((int)(wxXML_COMMENT_NODE)));
7345 }
7346 {
7347 PyDict_SetItemString(d,"XML_DOCUMENT_NODE", SWIG_From_int((int)(wxXML_DOCUMENT_NODE)));
7348 }
7349 {
7350 PyDict_SetItemString(d,"XML_DOCUMENT_TYPE_NODE", SWIG_From_int((int)(wxXML_DOCUMENT_TYPE_NODE)));
7351 }
7352 {
7353 PyDict_SetItemString(d,"XML_DOCUMENT_FRAG_NODE", SWIG_From_int((int)(wxXML_DOCUMENT_FRAG_NODE)));
7354 }
7355 {
7356 PyDict_SetItemString(d,"XML_NOTATION_NODE", SWIG_From_int((int)(wxXML_NOTATION_NODE)));
7357 }
7358 {
7359 PyDict_SetItemString(d,"XML_HTML_DOCUMENT_NODE", SWIG_From_int((int)(wxXML_HTML_DOCUMENT_NODE)));
7360 }
7361
7362
7363 wxXmlInitResourceModule();
7364 wxXmlResource::Get()->InitAllHandlers();
7365
7366
7367 }
7368
wxWidgets (Impactor)