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