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