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