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