]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/xrc_wrap.cpp
projects / wxWidgets.git / blob
? search:


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