]> 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
Various updates
[wxWidgets.git] / wxPython / src / gtk / xrc_wrap.cpp
CommitLineData
2ef75293
RD		 1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
0085ce49 3 * Version 1.3.29
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
0085ce49 12#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
2ef75293
RD		 13
14#ifdef __cplusplus
15template<class T> class SwigValueWrapper {
16 T *tt;
17public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
093d3ff1 27};
2ef75293
RD		 28#endif
29
0085ce49 30/* -----------------------------------------------------------------------------
32fe5131
RD		 31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
0085ce49 33 * ----------------------------------------------------------------------------- */
2ef75293 34
32fe5131
RD		 35/* template workaround for compilers that cannot correctly implement the C++ standard */
36#ifndef SWIGTEMPLATEDISAMBIGUATOR
0085ce49
RD		 37# if defined(__SUNPRO_CC)
38# if (__SUNPRO_CC <= 0x560)
39# define SWIGTEMPLATEDISAMBIGUATOR template
40# else
41# define SWIGTEMPLATEDISAMBIGUATOR
42# endif
43# else
44# define SWIGTEMPLATEDISAMBIGUATOR
45# endif
093d3ff1 46#endif
2ef75293 47
32fe5131
RD		 48/* inline attribute */
49#ifndef SWIGINLINE
50# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51# define SWIGINLINE inline
52# else
53# define SWIGINLINE
54# endif
55#endif
56
57/* attribute recognised by some compilers to avoid 'unused' warnings */
58#ifndef SWIGUNUSED
0085ce49
RD		 59# if defined(__GNUC__)
60# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61# define SWIGUNUSED __attribute__ ((__unused__))
62# else
63# define SWIGUNUSED
64# endif
65# elif defined(__ICC)
66# define SWIGUNUSED __attribute__ ((__unused__))
32fe5131
RD		 67# else
68# define SWIGUNUSED
69# endif
70#endif
71
0085ce49
RD		 72#ifndef SWIGUNUSEDPARM
73# ifdef __cplusplus
74# define SWIGUNUSEDPARM(p)
75# else
76# define SWIGUNUSEDPARM(p) p SWIGUNUSED
77# endif
78#endif
79
32fe5131
RD		 80/* internal SWIG method */
81#ifndef SWIGINTERN
82# define SWIGINTERN static SWIGUNUSED
83#endif
84
85/* internal inline SWIG method */
86#ifndef SWIGINTERNINLINE
87# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88#endif
89
0085ce49
RD		 90/* exporting methods */
91#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92# ifndef GCC_HASCLASSVISIBILITY
93# define GCC_HASCLASSVISIBILITY
94# endif
95#endif
96
32fe5131
RD		 97#ifndef SWIGEXPORT
98# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99# if defined(STATIC_LINKED)
100# define SWIGEXPORT
101# else
102# define SWIGEXPORT __declspec(dllexport)
103# endif
104# else
0085ce49
RD		 105# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106# define SWIGEXPORT __attribute__ ((visibility("default")))
107# else
108# define SWIGEXPORT
109# endif
32fe5131
RD		 110# endif
111#endif
112
113/* calling conventions for Windows */
114#ifndef SWIGSTDCALL
115# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116# define SWIGSTDCALL __stdcall
117# else
118# define SWIGSTDCALL
119# endif
120#endif
121
0085ce49
RD		 122/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124# define _CRT_SECURE_NO_DEPRECATE
125#endif
32fe5131 126
2ef75293 127
0085ce49 128/* Python.h has to appear first */
093d3ff1 129#include <Python.h>
2ef75293 130
0085ce49 131/* -----------------------------------------------------------------------------
093d3ff1 132 * swigrun.swg
2ef75293 133 *
0085ce49
RD		 134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
2ef75293 137
093d3ff1
RD		 138/* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
32fe5131 140#define SWIG_RUNTIME_VERSION "2"
2ef75293 141
093d3ff1
RD		 142/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143#ifdef SWIG_TYPE_TABLE
32fe5131
RD		 144# define SWIG_QUOTE_STRING(x) #x
145# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
2ef75293 147#else
32fe5131 148# define SWIG_TYPE_TABLE_NAME
093d3ff1
RD		 149#endif
150
151/*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158*/
32fe5131 159
093d3ff1 160#ifndef SWIGRUNTIME
32fe5131 161# define SWIGRUNTIME SWIGINTERN
093d3ff1 162#endif
32fe5131 163
093d3ff1 164#ifndef SWIGRUNTIMEINLINE
32fe5131 165# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
2ef75293
RD		 166#endif
167
0085ce49
RD		 168/* Generic buffer size */
169#ifndef SWIG_BUFFER_SIZE
170# define SWIG_BUFFER_SIZE 1024
171#endif
172
173/* Flags for pointer conversions */
174#define SWIG_POINTER_DISOWN 0x1
175
176/* Flags for new pointer objects */
177#define SWIG_POINTER_OWN 0x1
178
179
180/*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260#define SWIG_OK (0)
261#define SWIG_ERROR (-1)
262#define SWIG_IsOK(r) (r >= 0)
263#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265/* The CastRankLimit says how many bits are used for the cast rank */
266#define SWIG_CASTRANKLIMIT (1 << 8)
267/* The NewMask denotes the object was created (using new/malloc) */
268#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269/* The TmpMask is for in/out typemaps that use temporal objects */
270#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271/* Simple returning values */
272#define SWIG_BADOBJ (SWIG_ERROR)
273#define SWIG_OLDOBJ (SWIG_OK)
274#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276/* Check, add and del mask methods */
277#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285/* Cast-Rank Mode */
286#if defined(SWIG_CASTRANK_MODE)
287# ifndef SWIG_TypeRank
288# define SWIG_TypeRank unsigned long
289# endif
290# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291# define SWIG_MAXCASTRANK (2)
292# endif
293# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297}
298SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300}
301#else /* no cast-rank mode */
302# define SWIG_AddCast
303# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304#endif
305
306
307
308
32fe5131
RD		 309#include <string.h>
310
2ef75293
RD		 311#ifdef __cplusplus
312extern "C" {
313#endif
314
315typedef void *(*swig_converter_func)(void *);
316typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
32fe5131 318/* Structure to store inforomation on one type */
2ef75293 319typedef struct swig_type_info {
32fe5131
RD		 320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
0085ce49 325 int owndata; /* flag if the structure owns the clientdata */
2ef75293
RD		 326} swig_type_info;
327
32fe5131
RD		 328/* Structure to store a type and conversion function used for casting */
329typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334} swig_cast_info;
335
336/* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346} swig_module_info;
347
093d3ff1
RD		 348/*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354*/
355SWIGRUNTIME int
356SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
0085ce49 361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
093d3ff1
RD		 362 }
363 return (l1 - f1) - (l2 - f2);
364}
365
366/*
367 Check type equivalence in a name list like <name1>|<name2>|...
32fe5131 368 Return 0 if not equal, 1 if equal
093d3ff1
RD		 369*/
370SWIGRUNTIME int
371SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
32fe5131 379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
093d3ff1
RD		 380 if (*ne) ++ne;
381 }
382 return equiv;
383}
384
385/*
32fe5131
RD		 386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
093d3ff1 388*/
32fe5131
RD		 389SWIGRUNTIME int
390SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
093d3ff1 397 }
32fe5131
RD		 398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
093d3ff1 400 }
32fe5131 401 return equiv;
093d3ff1
RD		 402}
403
32fe5131
RD		 404
405/* think of this as a c++ template<> or a scheme macro */
406#define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
093d3ff1
RD		 427/*
428 Check the typename
429*/
32fe5131 430SWIGRUNTIME swig_cast_info *
093d3ff1 431SWIG_TypeCheck(const char *c, swig_type_info *ty) {
32fe5131
RD		 432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433}
434
435/* Same as previous function, except strcmp is replaced with a pointer comparison */
436SWIGRUNTIME swig_cast_info *
437SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
093d3ff1
RD		 439}
440
441/*
442 Cast a pointer up an inheritance hierarchy
443*/
444SWIGRUNTIMEINLINE void *
32fe5131 445SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
093d3ff1
RD		 446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447}
448
449/*
450 Dynamic pointer casting. Down an inheritance hierarchy
451*/
452SWIGRUNTIME swig_type_info *
453SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461}
462
463/*
464 Return the name associated with this type
465*/
466SWIGRUNTIMEINLINE const char *
467SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469}
470
471/*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474*/
475SWIGRUNTIME const char *
476SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
0085ce49 481 if (!type) return NULL;
093d3ff1
RD		 482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491}
492
093d3ff1
RD		 493/*
494 Set the clientdata field for a type
495*/
496SWIGRUNTIME void
32fe5131
RD		 497SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
093d3ff1
RD		 499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
32fe5131
RD		 501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
093d3ff1 507 }
32fe5131
RD		 508 }
509 cast = cast->next;
510 }
511}
0085ce49
RD		 512SWIGRUNTIME void
513SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516}
517
32fe5131
RD		 518/*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525*/
526SWIGRUNTIME swig_type_info *
527SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
093d3ff1 556 }
32fe5131
RD		 557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560}
561
562/*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570*/
571SWIGRUNTIME swig_type_info *
572SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
093d3ff1 591 }
32fe5131
RD		 592
593 /* neither found a match */
594 return 0;
093d3ff1 595}
2ef75293 596
093d3ff1
RD		 597/*
598 Pack binary data into a string
599*/
600SWIGRUNTIME char *
601SWIG_PackData(char *c, void *ptr, size_t sz) {
32fe5131
RD		 602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
093d3ff1 605 for (; u != eu; ++u) {
32fe5131 606 register unsigned char uu = *u;
093d3ff1
RD		 607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611}
612
613/*
614 Unpack binary data from a string
615*/
616SWIGRUNTIME const char *
617SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
32fe5131 619 register const unsigned char *eu = u + sz;
093d3ff1 620 for (; u != eu; ++u) {
32fe5131 621 register char d = *(c++);
0085ce49 622 register unsigned char uu;
093d3ff1
RD		 623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639}
640
093d3ff1
RD		 641/*
642 Pack 'void *' into a string buffer.
643*/
644SWIGRUNTIME char *
645SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653}
654
655SWIGRUNTIME const char *
656SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666}
667
668SWIGRUNTIME char *
669SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681}
682
683SWIGRUNTIME const char *
684SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694}
2ef75293
RD		 695
696#ifdef __cplusplus
697}
698#endif
699
0085ce49
RD		 700/* Errors in SWIG */
701#define SWIG_UnknownError -1
702#define SWIG_IOError -2
703#define SWIG_RuntimeError -3
704#define SWIG_IndexError -4
705#define SWIG_TypeError -5
706#define SWIG_DivisionByZero -6
707#define SWIG_OverflowError -7
708#define SWIG_SyntaxError -8
709#define SWIG_ValueError -9
710#define SWIG_SystemError -10
711#define SWIG_AttributeError -11
712#define SWIG_MemoryError -12
713#define SWIG_NullReferenceError -13
093d3ff1 714
0085ce49
RD		 715
716
717/* Python.h has to appear first */
718#include <Python.h>
719
720/* Add PyOS_snprintf for old Pythons */
721#if PY_VERSION_HEX < 0x02020000
722# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723# define PyOS_snprintf _snprintf
724# else
725# define PyOS_snprintf snprintf
726# endif
727#endif
728
729/* A crude PyString_FromFormat implementation for old Pythons */
730#if PY_VERSION_HEX < 0x02020000
731
732#ifndef SWIG_PYBUFFER_SIZE
733# define SWIG_PYBUFFER_SIZE 1024
734#endif
735
736static PyObject *
737PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745}
746#endif
747
748/* Add PyObject_Del for old Pythons */
749#if PY_VERSION_HEX < 0x01060000
750# define PyObject_Del(op) PyMem_DEL((op))
751#endif
752#ifndef PyObject_DEL
753# define PyObject_DEL PyObject_Del
754#endif
755
756/* A crude PyExc_StopIteration exception for old Pythons */
757#if PY_VERSION_HEX < 0x02020000
758# ifndef PyExc_StopIteration
759# define PyExc_StopIteration PyExc_RuntimeError
760# endif
761# ifndef PyObject_GenericGetAttr
762# define PyObject_GenericGetAttr 0
763# endif
093d3ff1 764#endif
0085ce49
RD		 765/* Py_NotImplemented is defined in 2.1 and up. */
766#if PY_VERSION_HEX < 0x02010000
767# ifndef Py_NotImplemented
768# define Py_NotImplemented PyExc_RuntimeError
769# endif
770#endif
771
772
773/* A crude PyString_AsStringAndSize implementation for old Pythons */
774#if PY_VERSION_HEX < 0x02010000
775# ifndef PyString_AsStringAndSize
776# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777# endif
778#endif
779
780/* PySequence_Size for old Pythons */
781#if PY_VERSION_HEX < 0x02000000
782# ifndef PySequence_Size
783# define PySequence_Size PySequence_Length
784# endif
785#endif
786
787
788/* PyBool_FromLong for old Pythons */
789#if PY_VERSION_HEX < 0x02030000
790static
791PyObject *PyBool_FromLong(long ok)
792{
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796}
797#endif
798
093d3ff1
RD		 799
800/* -----------------------------------------------------------------------------
0085ce49 801 * error manipulation
093d3ff1
RD		 802 * ----------------------------------------------------------------------------- */
803
0085ce49
RD		 804SWIGRUNTIME PyObject*
805SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845}
093d3ff1 846
0085ce49
RD		 847
848SWIGRUNTIME void
849SWIG_Python_AddErrorMsg(const char* mesg)
850{
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866}
867
868
869
870#if defined(SWIG_PYTHON_NO_THREADS)
871# if defined(SWIG_PYTHON_THREADS)
872# undef SWIG_PYTHON_THREADS
873# endif
874#endif
875#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878# define SWIG_PYTHON_USE_GIL
879# endif
880# endif
881# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882# ifndef SWIG_PYTHON_INITIALIZE_THREADS
883# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884# endif
885# ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906# else /* C code */
907# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911# endif
912# else /* Old thread way, not implemented, user must provide it */
913# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914# define SWIG_PYTHON_INITIALIZE_THREADS
915# endif
916# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918# endif
919# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920# define SWIG_PYTHON_THREAD_END_BLOCK
921# endif
922# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924# endif
925# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926# define SWIG_PYTHON_THREAD_END_ALLOW
927# endif
928# endif
929#else /* No thread support */
930# define SWIG_PYTHON_INITIALIZE_THREADS
931# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932# define SWIG_PYTHON_THREAD_END_BLOCK
933# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934# define SWIG_PYTHON_THREAD_END_ALLOW
093d3ff1
RD		 935#endif
936
0085ce49
RD		 937/* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
093d3ff1 940
0085ce49
RD		 941#ifdef __cplusplus
942extern "C" {
943#if 0
944} /* cc-mode */
945#endif
946#endif
093d3ff1
RD		 947
948/* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952/* Constant Types */
2ef75293
RD		 953#define SWIG_PY_POINTER 4
954#define SWIG_PY_BINARY 5
955
2ef75293
RD		 956/* Constant information structure */
957typedef struct swig_const_info {
0085ce49
RD		 958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
2ef75293
RD		 964} swig_const_info;
965
093d3ff1 966#ifdef __cplusplus
0085ce49
RD		 967#if 0
968{ /* cc-mode */
969#endif
093d3ff1
RD		 970}
971#endif
972
973
0085ce49
RD		 974/* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
093d3ff1
RD		 978 * pyrun.swg
979 *
0085ce49
RD		 980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
093d3ff1 983 *
0085ce49 984 * ----------------------------------------------------------------------------- */
093d3ff1
RD		 985
986/* Common SWIG API */
093d3ff1 987
d1a49b78
RD		 988#if PY_VERSION_HEX < 0x02050000
989typedef int Py_ssize_t;
990#endif
991
0085ce49
RD		 992/* for raw pointers */
993#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999#define swig_owntype int
093d3ff1 1000
0085ce49
RD		 1001/* for raw packed data */
1002#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
093d3ff1 1004
0085ce49
RD		 1005/* for class or struct pointers */
1006#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
093d3ff1 1008
0085ce49
RD		 1009/* for C or C++ function pointers */
1010#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
093d3ff1 1012
0085ce49
RD		 1013/* for C++ member pointers, ie, member methods */
1014#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
32fe5131 1016
093d3ff1 1017
0085ce49 1018/* Runtime API */
093d3ff1 1019
0085ce49
RD		 1020#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022#define SWIG_NewClientData(obj) PySwigClientData_New(obj)
32fe5131 1023
0085ce49
RD		 1024#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028#define SWIG_fail goto fail
32fe5131 1029
093d3ff1 1030
0085ce49 1031/* Runtime API implementation */
093d3ff1 1032
0085ce49 1033/* Error manipulation */
093d3ff1 1034
0085ce49
RD		 1035SWIGINTERN void
1036SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
093d3ff1
RD		 1041}
1042
0085ce49
RD		 1043SWIGINTERN void
1044SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
093d3ff1
RD		 1048}
1049
0085ce49 1050#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
32fe5131 1051
0085ce49 1052/* Set a constant value */
093d3ff1 1053
0085ce49
RD		 1054SWIGINTERN void
1055SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
093d3ff1
RD		 1058}
1059
0085ce49 1060/* Append a value to the result obj */
093d3ff1 1061
0085ce49
RD		 1062SWIGINTERN PyObject*
1063SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080#else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
093d3ff1 1088 } else {
0085ce49
RD		 1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
093d3ff1 1100 }
0085ce49
RD		 1101 return result;
1102#endif
093d3ff1
RD		 1103}
1104
0085ce49 1105/* Unpack the argument tuple */
093d3ff1 1106
0085ce49
RD		 1107SWIGINTERN int
1108SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109{
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143}
1144
1145/* A functor is a function object with one single object argument */
1146#if PY_VERSION_HEX >= 0x02020000
1147#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148#else
1149#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150#endif
1151
1152/*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155*/
1156#ifdef __cplusplus
1157#define SWIG_STATIC_POINTER(var) var
1158#else
1159#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160#endif
1161
1162/* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166/* Flags for new pointer objects */
1167#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172#ifdef __cplusplus
1173extern "C" {
1174#if 0
1175} /* cc-mode */
1176#endif
1177#endif
1178
1179/* How to access Py_None */
1180#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181# ifndef SWIG_PYTHON_NO_BUILD_NONE
1182# ifndef SWIG_PYTHON_BUILD_NONE
1183# define SWIG_PYTHON_BUILD_NONE
1184# endif
1185# endif
1186#endif
1187
1188#ifdef SWIG_PYTHON_BUILD_NONE
1189# ifdef Py_None
1190# undef Py_None
1191# define Py_None SWIG_Py_None()
1192# endif
1193SWIGRUNTIMEINLINE PyObject *
1194_SWIG_Py_None(void)
1195{
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199}
1200SWIGRUNTIME PyObject *
1201SWIG_Py_None(void)
1202{
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205}
1206#endif
1207
1208/* The python void return value */
1209
1210SWIGRUNTIMEINLINE PyObject *
1211SWIG_Py_Void(void)
1212{
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216}
1217
1218/* PySwigClientData */
1219
1220typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227} PySwigClientData;
1228
1229SWIGRUNTIMEINLINE int
1230SWIG_Python_CheckImplicit(swig_type_info *ty)
1231{
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234}
1235
1236SWIGRUNTIMEINLINE PyObject *
1237SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241}
1242
1243
1244SWIGRUNTIME PySwigClientData *
1245PySwigClientData_New(PyObject* obj)
1246{
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260#if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262#else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264#endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284#ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286#else
1287 data->delargs = 0;
1288#endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295}
1296
1297SWIGRUNTIME void
1298PySwigClientData_Del(PySwigClientData* data)
1299{
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303}
1304
1305/* =============== PySwigObject =====================*/
1306
1307typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313} PySwigObject;
1314
1315SWIGRUNTIME PyObject *
1316PySwigObject_long(PySwigObject *v)
1317{
1318 return PyLong_FromVoidPtr(v->ptr);
1319}
1320
1321SWIGRUNTIME PyObject *
1322PySwigObject_format(const char* fmt, PySwigObject *v)
1323{
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337}
1338
1339SWIGRUNTIME PyObject *
1340PySwigObject_oct(PySwigObject *v)
1341{
1342 return PySwigObject_format("%o",v);
1343}
1344
1345SWIGRUNTIME PyObject *
1346PySwigObject_hex(PySwigObject *v)
1347{
1348 return PySwigObject_format("%x",v);
1349}
1350
1351SWIGRUNTIME PyObject *
1352#ifdef METH_NOARGS
1353PySwigObject_repr(PySwigObject *v)
1354#else
1355PySwigObject_repr(PySwigObject *v, PyObject *args)
1356#endif
1357{
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363#ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365#else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367#endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371}
1372
1373SWIGRUNTIME int
1374PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375{
1376#ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378#else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380#endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388}
1389
1390SWIGRUNTIME PyObject *
1391PySwigObject_str(PySwigObject *v)
1392{
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396}
1397
1398SWIGRUNTIME int
1399PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400{
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404}
1405
1406SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408SWIGRUNTIME PyTypeObject*
1409PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412}
1413
1414SWIGRUNTIMEINLINE int
1415PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418}
1419
1420SWIGRUNTIME PyObject *
1421PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423SWIGRUNTIME void
1424PySwigObject_dealloc(PyObject *v)
1425{
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450#endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455}
1456
1457SWIGRUNTIME PyObject*
1458PySwigObject_append(PyObject* v, PyObject* next)
1459{
1460 PySwigObject *sobj = (PySwigObject *) v;
1461#ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465#endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472}
1473
1474SWIGRUNTIME PyObject*
1475#ifdef METH_NOARGS
1476PySwigObject_next(PyObject* v)
1477#else
1478PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479#endif
1480{
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488}
1489
1490SWIGINTERN PyObject*
1491#ifdef METH_NOARGS
1492PySwigObject_disown(PyObject *v)
1493#else
1494PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495#endif
1496{
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500}
1501
1502SWIGINTERN PyObject*
1503#ifdef METH_NOARGS
1504PySwigObject_acquire(PyObject *v)
1505#else
1506PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507#endif
1508{
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512}
1513
1514SWIGINTERN PyObject*
1515PySwigObject_own(PyObject *v, PyObject *args)
1516{
1517 PyObject *val = 0;
1518#if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520#else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522#endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531#ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537#else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543#endif
1544 }
1545 return obj;
1546 }
1547}
1548
1549#ifdef METH_O
1550static PyMethodDef
1551swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559};
1560#else
1561static PyMethodDef
1562swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570};
1571#endif
1572
1573#if PY_VERSION_HEX < 0x02020000
1574SWIGINTERN PyObject *
1575PySwigObject_getattr(PySwigObject *sobj,char *name)
1576{
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578}
1579#endif
1580
1581SWIGRUNTIME PyTypeObject*
1582_PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
093d3ff1
RD		 1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
32fe5131 1609#if PY_VERSION_HEX >= 0x02020000
093d3ff1 1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
32fe5131
RD		 1611#elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
093d3ff1
RD		 1613#endif
1614 };
1615
0085ce49 1616 static PyTypeObject pyswigobject_type;
32fe5131 1617 static int type_init = 0;
093d3ff1 1618 if (!type_init) {
0085ce49
RD		 1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628#if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630#else
1631 (getattrfunc)0, /* tp_getattr */
093d3ff1 1632#endif
0085ce49
RD		 1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
093d3ff1 1651#if PY_VERSION_HEX >= 0x02020000
0085ce49
RD		 1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
093d3ff1
RD		 1672#endif
1673#if PY_VERSION_HEX >= 0x02030000
0085ce49 1674 0, /* tp_del */
093d3ff1
RD		 1675#endif
1676#ifdef COUNT_ALLOCS
0085ce49 1677 0,0,0,0 /* tp_alloc -> tp_next */
093d3ff1 1678#endif
0085ce49 1679 };
32fe5131 1680 pyswigobject_type = tmp;
0085ce49 1681 pyswigobject_type.ob_type = &PyType_Type;
093d3ff1
RD		 1682 type_init = 1;
1683 }
32fe5131 1684 return &pyswigobject_type;
093d3ff1
RD		 1685}
1686
1687SWIGRUNTIME PyObject *
0085ce49 1688PySwigObject_New(void *ptr, swig_type_info *ty, int own)
093d3ff1 1689{
0085ce49
RD		 1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
32fe5131 1696 }
0085ce49 1697 return (PyObject *)sobj;
093d3ff1
RD		 1698}
1699
1700/* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704typedef struct {
1705 PyObject_HEAD
1706 void *pack;
0085ce49 1707 swig_type_info *ty;
093d3ff1
RD		 1708 size_t size;
1709} PySwigPacked;
1710
1711SWIGRUNTIME int
0085ce49 1712PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
093d3ff1
RD		 1713{
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
0085ce49 1720 fputs(v->ty->name,fp);
093d3ff1
RD		 1721 fputs(">", fp);
1722 return 0;
1723}
1724
1725SWIGRUNTIME PyObject *
1726PySwigPacked_repr(PySwigPacked *v)
1727{
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
0085ce49 1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
093d3ff1 1731 } else {
0085ce49 1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
093d3ff1
RD		 1733 }
1734}
1735
1736SWIGRUNTIME PyObject *
1737PySwigPacked_str(PySwigPacked *v)
1738{
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
0085ce49 1741 return PyString_FromFormat("%s%s", result, v->ty->name);
093d3ff1 1742 } else {
0085ce49 1743 return PyString_FromString(v->ty->name);
093d3ff1
RD		 1744 }
1745}
1746
1747SWIGRUNTIME int
1748PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749{
0085ce49
RD		 1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
093d3ff1
RD		 1754}
1755
0085ce49 1756SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
093d3ff1
RD		 1757
1758SWIGRUNTIME PyTypeObject*
32fe5131 1759PySwigPacked_type(void) {
0085ce49
RD		 1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762}
1763
1764SWIGRUNTIMEINLINE int
1765PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768}
1769
1770SWIGRUNTIME void
1771PySwigPacked_dealloc(PyObject *v)
1772{
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778}
1779
1780SWIGRUNTIME PyTypeObject*
1781_PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814#if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
093d3ff1
RD		 1835#endif
1836#if PY_VERSION_HEX >= 0x02030000
0085ce49 1837 0, /* tp_del */
093d3ff1
RD		 1838#endif
1839#ifdef COUNT_ALLOCS
0085ce49 1840 0,0,0,0 /* tp_alloc -> tp_next */
093d3ff1 1841#endif
0085ce49 1842 };
32fe5131 1843 pyswigpacked_type = tmp;
0085ce49 1844 pyswigpacked_type.ob_type = &PyType_Type;
093d3ff1
RD		 1845 type_init = 1;
1846 }
32fe5131 1847 return &pyswigpacked_type;
093d3ff1
RD		 1848}
1849
1850SWIGRUNTIME PyObject *
0085ce49 1851PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
093d3ff1 1852{
0085ce49
RD		 1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
093d3ff1 1855 void *pack = malloc(size);
32fe5131
RD		 1856 if (pack) {
1857 memcpy(pack, ptr, size);
0085ce49
RD		 1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
32fe5131 1864 }
093d3ff1 1865 }
0085ce49 1866 return (PyObject *) sobj;
093d3ff1
RD		 1867}
1868
0085ce49 1869SWIGRUNTIME swig_type_info *
093d3ff1
RD		 1870PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871{
0085ce49
RD		 1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
093d3ff1
RD		 1880}
1881
093d3ff1 1882/* -----------------------------------------------------------------------------
0085ce49 1883 * pointers/data manipulation
093d3ff1
RD		 1884 * ----------------------------------------------------------------------------- */
1885
0085ce49
RD		 1886SWIGRUNTIMEINLINE PyObject *
1887_SWIG_This(void)
1888{
1889 return PyString_FromString("this");
1890}
093d3ff1 1891
0085ce49
RD		 1892SWIGRUNTIME PyObject *
1893SWIG_This(void)
1894{
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897}
093d3ff1 1898
0085ce49 1899/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
093d3ff1 1900
0085ce49
RD		 1901SWIGRUNTIME PySwigObject *
1902SWIG_Python_GetSwigThis(PyObject *pyobj)
093d3ff1 1903{
0085ce49
RD		 1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917#ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922#endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
093d3ff1 1926 } else {
0085ce49
RD		 1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
093d3ff1 1929 }
093d3ff1 1930 }
0085ce49
RD		 1931 }
1932#else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940#endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
093d3ff1
RD		 1947 }
1948}
1949
0085ce49
RD		 1950/* Acquire a pointer value */
1951
1952SWIGRUNTIME int
1953SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
093d3ff1 1961 }
0085ce49 1962 return 0;
093d3ff1
RD		 1963}
1964
0085ce49
RD		 1965/* Convert a pointer value */
1966
093d3ff1 1967SWIGRUNTIME int
0085ce49
RD		 1968SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
093d3ff1 1992 } else {
0085ce49
RD		 1993 if (ptr) *ptr = vptr;
1994 break;
093d3ff1 1995 }
093d3ff1 1996 }
0085ce49
RD		 1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
093d3ff1
RD		 2042 }
2043}
2044
0085ce49
RD		 2045/* Convert a function ptr value */
2046
093d3ff1 2047SWIGRUNTIME int
0085ce49
RD		 2048SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
093d3ff1 2051 } else {
0085ce49
RD		 2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
d1a49b78 2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
0085ce49
RD		 2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
093d3ff1
RD		 2069 }
2070}
2071
0085ce49 2072/* Convert a packed value value */
093d3ff1 2073
093d3ff1 2074SWIGRUNTIME int
0085ce49
RD		 2075SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
093d3ff1 2084 }
0085ce49
RD		 2085 return SWIG_OK;
2086}
093d3ff1 2087
0085ce49
RD		 2088/* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
093d3ff1 2091
0085ce49
RD		 2092/*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095*/
093d3ff1 2096
0085ce49
RD		 2097SWIGRUNTIME PyObject*
2098SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099{
2100#if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
093d3ff1 2115 }
0085ce49
RD		 2116#else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119#endif
093d3ff1 2120 }
0085ce49
RD		 2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
093d3ff1 2126 }
0085ce49
RD		 2127 return inst;
2128#else
2129#if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136#else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
093d3ff1 2140 }
0085ce49
RD		 2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
093d3ff1 2147 }
0085ce49
RD		 2148#ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150#endif
2151#ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153#endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156#endif
2157#endif
093d3ff1
RD		 2158}
2159
0085ce49
RD		 2160SWIGRUNTIME void
2161SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162{
2163 PyObject *dict;
2164#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
093d3ff1 2175#endif
0085ce49
RD		 2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179}
093d3ff1 2180
0085ce49
RD		 2181
2182SWIGINTERN PyObject *
2183SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
093d3ff1 2191 } else {
0085ce49 2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
093d3ff1 2193 }
0085ce49 2194 return SWIG_Py_Void();
093d3ff1 2195 }
0085ce49
RD		 2196}
2197
2198/* Create a new pointer object */
093d3ff1 2199
093d3ff1 2200SWIGRUNTIME PyObject *
0085ce49 2201SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
093d3ff1 2202 if (!ptr) {
0085ce49
RD		 2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
093d3ff1 2213 }
093d3ff1 2214 }
0085ce49 2215 return robj;
093d3ff1 2216 }
093d3ff1
RD		 2217}
2218
0085ce49
RD		 2219/* Create a new packed object */
2220
2221SWIGRUNTIMEINLINE PyObject *
093d3ff1 2222SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
0085ce49 2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
093d3ff1
RD		 2224}
2225
2226/* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2ef75293 2229
093d3ff1
RD		 2230#ifdef SWIG_LINK_RUNTIME
2231void *SWIG_ReturnGlobalTypeList(void *);
2232#endif
2ef75293 2233
32fe5131
RD		 2234SWIGRUNTIME swig_module_info *
2235SWIG_Python_GetModule(void) {
093d3ff1
RD		 2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239#ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241#else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
093d3ff1 2248#endif
32fe5131
RD		 2249 }
2250 return (swig_module_info *) type_pointer;
093d3ff1 2251}
2ef75293 2252
32fe5131
RD		 2253#if PY_MAJOR_VERSION < 2
2254/* PyModule_AddObject function was introduced in Python 2.0. The following function
0085ce49 2255 is copied out of Python/modsupport.c in python version 2.3.4 */
32fe5131
RD		 2256SWIGINTERN int
2257PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258{
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
0085ce49 2263 return SWIG_ERROR;
32fe5131
RD		 2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
0085ce49 2268 return SWIG_ERROR;
32fe5131
RD		 2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
0085ce49 2276 return SWIG_ERROR;
32fe5131
RD		 2277 }
2278 if (PyDict_SetItemString(dict, name, o))
0085ce49 2279 return SWIG_ERROR;
32fe5131 2280 Py_DECREF(o);
0085ce49 2281 return SWIG_OK;
093d3ff1 2282}
32fe5131 2283#endif
2ef75293 2284
0085ce49
RD		 2285SWIGRUNTIME void
2286SWIG_Python_DestroyModule(void *vptr)
2287{
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299}
2300
32fe5131
RD		 2301SWIGRUNTIME void
2302SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
0085ce49 2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
32fe5131
RD		 2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
0085ce49
RD		 2310 } else {
2311 Py_XDECREF(pointer);
32fe5131
RD		 2312 }
2313}
2ef75293 2314
0085ce49
RD		 2315/* The python cached type query */
2316SWIGRUNTIME PyObject *
2317SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2ef75293 2320}
2ef75293 2321
0085ce49
RD		 2322SWIGRUNTIME swig_type_info *
2323SWIG_Python_TypeQuery(const char *type)
2324{
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342}
2343
2344/*
2345 For backward compatibility only
2346*/
2347#define SWIG_POINTER_EXCEPTION 0
2348#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351SWIGRUNTIME int
2352SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353{
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374}
2375
2376SWIGRUNTIME int
2377SWIG_Python_ArgFail(int argnum)
2378{
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387}
2388
2389SWIGRUNTIMEINLINE const char *
2390PySwigObject_GetDesc(PyObject *self)
2391{
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395}
2396
2397SWIGRUNTIME void
2398SWIG_Python_TypeError(const char *type, PyObject *obj)
2399{
2400 if (type) {
2401#if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410#endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431}
2432
2433
2434/* Convert a pointer value, signal an exception on a type mismatch */
2435SWIGRUNTIME void *
2436SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446}
2447
2448
2449#ifdef __cplusplus
2450#if 0
2451{ /* cc-mode */
2452#endif
2453}
2454#endif
2455
2456
2457
2458#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464/* -------- TYPES TABLE (BEGIN) -------- */
2465
2466#define SWIGTYPE_p_char swig_types[0]
2467#define SWIGTYPE_p_form_ops_t swig_types[1]
2468#define SWIGTYPE_p_int swig_types[2]
32fe5131
RD		 2469#define SWIGTYPE_p_unsigned_char swig_types[3]
2470#define SWIGTYPE_p_unsigned_int swig_types[4]
2471#define SWIGTYPE_p_unsigned_long swig_types[5]
2472#define SWIGTYPE_p_wxANIHandler swig_types[6]
2473#define SWIGTYPE_p_wxAcceleratorTable swig_types[7]
2474#define SWIGTYPE_p_wxActivateEvent swig_types[8]
2475#define SWIGTYPE_p_wxArtClient swig_types[9]
2476#define SWIGTYPE_p_wxBMPHandler swig_types[10]
2477#define SWIGTYPE_p_wxBitmap swig_types[11]
2478#define SWIGTYPE_p_wxBoxSizer swig_types[12]
2479#define SWIGTYPE_p_wxCURHandler swig_types[13]
2131d850
RD		 2480#define SWIGTYPE_p_wxChildFocusEvent swig_types[14]
2481#define SWIGTYPE_p_wxClipboardTextEvent swig_types[15]
01f6b6d3
RD		 2482#define SWIGTYPE_p_wxCloseEvent swig_types[16]
2483#define SWIGTYPE_p_wxColour swig_types[17]
2484#define SWIGTYPE_p_wxCommandEvent swig_types[18]
2485#define SWIGTYPE_p_wxContextMenuEvent swig_types[19]
2486#define SWIGTYPE_p_wxControl swig_types[20]
2487#define SWIGTYPE_p_wxControlWithItems swig_types[21]
2488#define SWIGTYPE_p_wxDateEvent swig_types[22]
2489#define SWIGTYPE_p_wxDialog swig_types[23]
2490#define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
2491#define SWIGTYPE_p_wxDropFilesEvent swig_types[25]
2492#define SWIGTYPE_p_wxDuplexMode swig_types[26]
2493#define SWIGTYPE_p_wxEraseEvent swig_types[27]
2494#define SWIGTYPE_p_wxEvent swig_types[28]
2495#define SWIGTYPE_p_wxEvtHandler swig_types[29]
2496#define SWIGTYPE_p_wxFSFile swig_types[30]
2497#define SWIGTYPE_p_wxFileSystem swig_types[31]
2498#define SWIGTYPE_p_wxFlexGridSizer swig_types[32]
2499#define SWIGTYPE_p_wxFocusEvent swig_types[33]
2500#define SWIGTYPE_p_wxFont swig_types[34]
2501#define SWIGTYPE_p_wxFrame swig_types[35]
2502#define SWIGTYPE_p_wxGBSizerItem swig_types[36]
2503#define SWIGTYPE_p_wxGIFHandler swig_types[37]
2504#define SWIGTYPE_p_wxGridBagSizer swig_types[38]
2505#define SWIGTYPE_p_wxGridSizer swig_types[39]
2506#define SWIGTYPE_p_wxICOHandler swig_types[40]
2507#define SWIGTYPE_p_wxIcon swig_types[41]
2508#define SWIGTYPE_p_wxIconizeEvent swig_types[42]
2509#define SWIGTYPE_p_wxIdleEvent swig_types[43]
2510#define SWIGTYPE_p_wxImage swig_types[44]
2511#define SWIGTYPE_p_wxImageHandler swig_types[45]
2512#define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[46]
2513#define SWIGTYPE_p_wxInitDialogEvent swig_types[47]
2514#define SWIGTYPE_p_wxInputStream swig_types[48]
2515#define SWIGTYPE_p_wxJPEGHandler swig_types[49]
2516#define SWIGTYPE_p_wxKeyEvent swig_types[50]
2517#define SWIGTYPE_p_wxLayoutConstraints swig_types[51]
2518#define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
2519#define SWIGTYPE_p_wxMenu swig_types[53]
2520#define SWIGTYPE_p_wxMenuBar swig_types[54]
2521#define SWIGTYPE_p_wxMenuEvent swig_types[55]
2522#define SWIGTYPE_p_wxMenuItem swig_types[56]
2523#define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[57]
34e0a3bb
RD		 2524#define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[58]
2525#define SWIGTYPE_p_wxMouseEvent swig_types[59]
2526#define SWIGTYPE_p_wxMoveEvent swig_types[60]
2527#define SWIGTYPE_p_wxNavigationKeyEvent swig_types[61]
2528#define SWIGTYPE_p_wxNcPaintEvent swig_types[62]
2529#define SWIGTYPE_p_wxNotifyEvent swig_types[63]
2530#define SWIGTYPE_p_wxObject swig_types[64]
2531#define SWIGTYPE_p_wxOutputStream swig_types[65]
2532#define SWIGTYPE_p_wxPCXHandler swig_types[66]
2533#define SWIGTYPE_p_wxPNGHandler swig_types[67]
2534#define SWIGTYPE_p_wxPNMHandler swig_types[68]
2535#define SWIGTYPE_p_wxPaintEvent swig_types[69]
2536#define SWIGTYPE_p_wxPaletteChangedEvent swig_types[70]
2537#define SWIGTYPE_p_wxPanel swig_types[71]
2538#define SWIGTYPE_p_wxPaperSize swig_types[72]
2539#define SWIGTYPE_p_wxPoint swig_types[73]
2540#define SWIGTYPE_p_wxPyApp swig_types[74]
2541#define SWIGTYPE_p_wxPyCommandEvent swig_types[75]
2542#define SWIGTYPE_p_wxPyEvent swig_types[76]
2543#define SWIGTYPE_p_wxPyImageHandler swig_types[77]
2544#define SWIGTYPE_p_wxPySizer swig_types[78]
2545#define SWIGTYPE_p_wxPyValidator swig_types[79]
2546#define SWIGTYPE_p_wxPyXmlResourceHandler swig_types[80]
2547#define SWIGTYPE_p_wxPyXmlSubclassFactory swig_types[81]
2548#define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[82]
2549#define SWIGTYPE_p_wxScrollEvent swig_types[83]
2550#define SWIGTYPE_p_wxScrollWinEvent swig_types[84]
2551#define SWIGTYPE_p_wxSetCursorEvent swig_types[85]
2552#define SWIGTYPE_p_wxShowEvent swig_types[86]
2553#define SWIGTYPE_p_wxSize swig_types[87]
2554#define SWIGTYPE_p_wxSizeEvent swig_types[88]
2555#define SWIGTYPE_p_wxSizer swig_types[89]
2556#define SWIGTYPE_p_wxSizerItem swig_types[90]
2557#define SWIGTYPE_p_wxStaticBoxSizer swig_types[91]
2558#define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[92]
2559#define SWIGTYPE_p_wxSysColourChangedEvent swig_types[93]
2560#define SWIGTYPE_p_wxTIFFHandler swig_types[94]
2561#define SWIGTYPE_p_wxUpdateUIEvent swig_types[95]
2562#define SWIGTYPE_p_wxValidator swig_types[96]
2563#define SWIGTYPE_p_wxWindow swig_types[97]
2564#define SWIGTYPE_p_wxWindowCreateEvent swig_types[98]
2565#define SWIGTYPE_p_wxWindowDestroyEvent swig_types[99]
2566#define SWIGTYPE_p_wxXPMHandler swig_types[100]
2567#define SWIGTYPE_p_wxXmlDocument swig_types[101]
2568#define SWIGTYPE_p_wxXmlNode swig_types[102]
2569#define SWIGTYPE_p_wxXmlProperty swig_types[103]
2570#define SWIGTYPE_p_wxXmlResource swig_types[104]
2571static swig_type_info *swig_types[106];
2572static swig_module_info swig_module = {swig_types, 105, 0, 0, 0, 0};
32fe5131
RD		 2573#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2574#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2ef75293
RD		 2575
2576/* -------- TYPES TABLE (END) -------- */
2577
0085ce49
RD		 2578#if (PY_VERSION_HEX <= 0x02000000)
2579# if !defined(SWIG_PYTHON_CLASSIC)
2580# error "This python version requires to use swig with the '-classic' option"
2581# endif
2582#endif
2583#if (PY_VERSION_HEX <= 0x02020000)
2584# error "This python version requires to use swig with the '-nomodern' option"
2585#endif
2586#if (PY_VERSION_HEX <= 0x02020000)
2587# error "This python version requires to use swig with the '-nomodernargs' option"
2588#endif
2589#ifndef METH_O
2590# error "This python version requires to use swig with the '-nofastunpack' option"
2591#endif
2ef75293
RD		 2592
2593/*-----------------------------------------------
2594 @(target):= _xrc.so
2595 ------------------------------------------------*/
2596#define SWIG_init init_xrc
2597
2598#define SWIG_name "_xrc"
2599
0085ce49
RD		 2600#define SWIGVERSION 0x010329
2601
2602
2603#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2604#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2605
2606
2607#include <stdexcept>
2608
2609
2610namespace swig {
2611 class PyObject_ptr {
2612 protected:
2613 PyObject *_obj;
2614
2615 public:
2616 PyObject_ptr() :_obj(0)
2617 {
2618 }
2619
2620 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2621 {
2622 Py_XINCREF(_obj);
2623 }
2624
2625 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2626 {
2627 if (initial_ref) Py_XINCREF(_obj);
2628 }
2629
2630 PyObject_ptr & operator=(const PyObject_ptr& item)
2631 {
2632 Py_XINCREF(item._obj);
2633 Py_XDECREF(_obj);
2634 _obj = item._obj;
2635 return *this;
2636 }
2637
2638 ~PyObject_ptr()
2639 {
2640 Py_XDECREF(_obj);
2641 }
2642
2643 operator PyObject *() const
2644 {
2645 return _obj;
2646 }
2647
2648 PyObject *operator->() const
2649 {
2650 return _obj;
2651 }
2652 };
2653}
2654
2655
2656namespace swig {
2657 struct PyObject_var : PyObject_ptr {
2658 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2659
2660 PyObject_var & operator = (PyObject* obj)
2661 {
2662 Py_XDECREF(_obj);
2663 _obj = obj;
2664 return *this;
2665 }
2666 };
2667}
2668
2669
2ef75293
RD		 2670#include "wx/wxPython/wxPython.h"
2671#include "wx/wxPython/pyclasses.h"
2672#include "wx/wxPython/pyistream.h"
2673
2674#include <wx/xml/xml.h>
2675#include <wx/xrc/xmlres.h>
2676
2677 static const wxString wxPyEmptyString(wxEmptyString);
2678 static const wxString wxPyUTF8String(wxT("UTF-8"));
2679 static const wxString wxPyStyleString(wxT("style"));
2680 static const wxString wxPySizeString(wxT("size"));
2681 static const wxString wxPyPosString(wxT("pos"));
2682 static const wxString wxPyBitmapString(wxT("bitmap"));
2683 static const wxString wxPyIconString(wxT("icon"));
2684 static const wxString wxPyFontString(wxT("font"));
2685
0085ce49 2686 #define SWIG_From_long PyInt_FromLong
093d3ff1
RD		 2687
2688
0085ce49
RD		 2689SWIGINTERNINLINE PyObject *
2690SWIG_From_int (int value)
2691{
2692 return SWIG_From_long (value);
2693}
2ef75293
RD		 2694
2695
0085ce49
RD		 2696#include <limits.h>
2697#ifndef LLONG_MIN
2698# define LLONG_MIN LONG_LONG_MIN
2699#endif
2700#ifndef LLONG_MAX
2701# define LLONG_MAX LONG_LONG_MAX
2702#endif
2703#ifndef ULLONG_MAX
2704# define ULLONG_MAX ULONG_LONG_MAX
2705#endif
2ef75293
RD		 2706
2707
093d3ff1 2708SWIGINTERN int
0085ce49 2709SWIG_AsVal_long (PyObject* obj, long* val)
2ef75293
RD		 2710{
2711 if (PyNumber_Check(obj)) {
2712 if (val) *val = PyInt_AsLong(obj);
0085ce49 2713 return SWIG_OK;
2ef75293 2714 }
0085ce49 2715 return SWIG_TypeError;
2ef75293
RD		 2716}
2717
2718
093d3ff1 2719SWIGINTERN int
0085ce49
RD		 2720SWIG_AsVal_int (PyObject * obj, int *val)
2721{
2ef75293 2722 long v;
0085ce49
RD		 2723 int res = SWIG_AsVal_long (obj, &v);
2724 if (SWIG_IsOK(res)) {
2725 if ((v < INT_MIN || v > INT_MAX)) {
2726 return SWIG_OverflowError;
2ef75293 2727 } else {
0085ce49 2728 if (val) *val = static_cast< int >(v);
2ef75293 2729 }
0085ce49
RD		 2730 }
2731 return res;
2ef75293
RD		 2732}
2733
0085ce49 2734SWIGINTERN bool wxXmlResource_LoadFromString(wxXmlResource *self,wxString const &data){
2ef75293
RD		 2735 static int s_memFileIdx = 0;
2736
2737 // Check for memory FS. If not present, load the handler:
2738 wxMemoryFSHandler::AddFile(wxT("XRC_resource/dummy_file"),
2739 wxT("dummy data"));
2740 wxFileSystem fsys;
2741 wxFSFile *f = fsys.OpenFile(wxT("memory:XRC_resource/dummy_file"));
2742 wxMemoryFSHandler::RemoveFile(wxT("XRC_resource/dummy_file"));
2743 if (f)
2744 delete f;
2745 else
2746 wxFileSystem::AddHandler(new wxMemoryFSHandler);
2747
2748 // Now put the resource data into the memory FS
2749 wxString filename(wxT("XRC_resource/data_string_"));
2750 filename << s_memFileIdx;
2751 s_memFileIdx += 1;
2752 wxMemoryFSHandler::AddFile(filename, data);
2753
2754 // Load the "file" into the resource object
2755 bool retval = self->Load(wxT("memory:") + filename );
2756
2757 return retval;
2758 }
2759
2760class wxPyXmlSubclassFactory : public wxXmlSubclassFactory
2761{
2762public:
2763 wxPyXmlSubclassFactory() {}
2764 DEC_PYCALLBACK_OBJECT_STRING_pure(Create);
2765 PYPRIVATE;
2766};
2767
2768IMP_PYCALLBACK_OBJECT_STRING_pure(wxPyXmlSubclassFactory, wxXmlSubclassFactory, Create);
2769
2770 // C++ version of Python aware wxXmlResourceHandler, for the pure virtual
2771 // callbacks, as well as to make some protected things public so they can
2772 // be wrapped.
2773class wxPyXmlResourceHandler : public wxXmlResourceHandler {
2774public:
2775 wxPyXmlResourceHandler() : wxXmlResourceHandler() {}
2776 //~wxPyXmlResourceHandler();
2777
2778 // Base class virtuals
2779
2780 DEC_PYCALLBACK_OBJECT__pure(DoCreateResource);
2781 DEC_PYCALLBACK_BOOL_NODE_pure(CanHandle);
2782
2783
2784 // accessors for protected members
2785
2786 wxXmlResource* GetResource() { return m_resource; }
2787 wxXmlNode* GetNode() { return m_node; }
2788 wxString GetClass() { return m_class; }
2789 wxObject* GetParent() { return m_parent; }
2790 wxObject* GetInstance() { return m_instance; }
2791 wxWindow* GetParentAsWindow() { return m_parentAsWindow; }
2ef75293
RD		 2792
2793
2794 // turn some protected methods into public via delegation
2795
2796 bool IsOfClass(wxXmlNode *node, const wxString& classname)
2797 { return wxXmlResourceHandler::IsOfClass(node, classname); }
2798
2799 wxString GetNodeContent(wxXmlNode *node)
2800 { return wxXmlResourceHandler::GetNodeContent(node); }
2801
2802 bool HasParam(const wxString& param)
2803 { return wxXmlResourceHandler::HasParam(param); }
2804
2805 wxXmlNode *GetParamNode(const wxString& param)
2806 { return wxXmlResourceHandler::GetParamNode(param); }
2807
2808 wxString GetParamValue(const wxString& param)
2809 { return wxXmlResourceHandler::GetParamValue(param); }
2810
2811 void AddStyle(const wxString& name, int value)
2812 { wxXmlResourceHandler::AddStyle(name, value); }
2813
2814 void AddWindowStyles()
2815 { wxXmlResourceHandler::AddWindowStyles(); }
2816
2817 int GetStyle(const wxString& param = wxT("style"), int defaults = 0)
2818 { return wxXmlResourceHandler::GetStyle(param, defaults); }
2819
ae8162c8 2820 wxString GetText(const wxString& param, bool translate = true)
2ef75293
RD		 2821 { return wxXmlResourceHandler::GetText(param, translate); }
2822
2823 int GetID()
2824 { return wxXmlResourceHandler::GetID(); }
2825
2826 wxString GetName()
2827 { return wxXmlResourceHandler::GetName(); }
2828
ae8162c8 2829 bool GetBool(const wxString& param, bool defaultv = false)
2ef75293
RD		 2830 { return wxXmlResourceHandler::GetBool(param, defaultv); }
2831
2832 long GetLong( const wxString& param, long defaultv = 0 )
2833 { return wxXmlResourceHandler::GetLong(param, defaultv); }
2834
2835 wxColour GetColour(const wxString& param)
2836 { return wxXmlResourceHandler::GetColour(param); }
2837
2838 wxSize GetSize(const wxString& param = wxT("size"))
2839 { return wxXmlResourceHandler::GetSize(param); }
2840
2841 wxPoint GetPosition(const wxString& param = wxT("pos"))
2842 { return wxXmlResourceHandler::GetPosition(param); }
2843
2844 wxCoord GetDimension(const wxString& param, wxCoord defaultv = 0)
2845 { return wxXmlResourceHandler::GetDimension(param, defaultv); }
2846
2847 wxBitmap GetBitmap(const wxString& param = wxT("bitmap"),
2848 const wxArtClient& defaultArtClient = wxART_OTHER,
2849 wxSize size = wxDefaultSize)
2850 { return wxXmlResourceHandler::GetBitmap(param, defaultArtClient, size); }
2851
2852 wxIcon GetIcon(const wxString& param = wxT("icon"),
2853 const wxArtClient& defaultArtClient = wxART_OTHER,
2854 wxSize size = wxDefaultSize)
2855 { return wxXmlResourceHandler::GetIcon(param, defaultArtClient, size); }
2856
2857 wxFont GetFont(const wxString& param = wxT("font"))
2858 { return wxXmlResourceHandler::GetFont(param); }
2859
2860 void SetupWindow(wxWindow *wnd)
2861 { wxXmlResourceHandler::SetupWindow(wnd); }
2862
ae8162c8 2863 void CreateChildren(wxObject *parent, bool this_hnd_only = false)
2ef75293
RD		 2864 { wxXmlResourceHandler::CreateChildren(parent, this_hnd_only); }
2865
2866 void CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode = NULL)
2867 { wxXmlResourceHandler::CreateChildrenPrivately(parent, rootnode); }
2868
2869 wxObject *CreateResFromNode(wxXmlNode *node,
2870 wxObject *parent, wxObject *instance = NULL)
2871 { return wxXmlResourceHandler::CreateResFromNode(node, parent, instance); }
2872
2873 wxFileSystem& GetCurFileSystem()
2874 { return wxXmlResourceHandler::GetCurFileSystem(); }
2875
2876
2877 PYPRIVATE;
2878};
2879
2880IMP_PYCALLBACK_OBJECT__pure(wxPyXmlResourceHandler, wxXmlResourceHandler, DoCreateResource);
2881IMP_PYCALLBACK_BOOL_NODE_pure(wxPyXmlResourceHandler, wxXmlResourceHandler, CanHandle);
2882
2883
2884
093d3ff1 2885SWIGINTERN int
0085ce49 2886SWIG_AsVal_bool (PyObject *obj, bool *val)
2ef75293 2887{
2ef75293
RD		 2888 if (obj == Py_True) {
2889 if (val) *val = true;
0085ce49
RD		 2890 return SWIG_OK;
2891 } else if (obj == Py_False) {
2ef75293 2892 if (val) *val = false;
0085ce49 2893 return SWIG_OK;
093d3ff1 2894 } else {
0085ce49
RD		 2895 long v = 0;
2896 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2897 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2898 return res;
2ef75293 2899 }
2ef75293
RD		 2900}
2901
2902#ifdef __cplusplus
2903extern "C" {
2904#endif
0085ce49
RD		 2905SWIGINTERN int UTF8String_set(PyObject *) {
2906 SWIG_Error(SWIG_AttributeError,"Variable UTF8String is read-only.");
2907 return 1;
2ef75293
RD		 2908}
2909
2910
0085ce49
RD		 2911SWIGINTERN PyObject *UTF8String_get(void) {
2912 PyObject *pyobj = 0;
2913
2914 {
2ef75293 2915#if wxUSE_UNICODE
0085ce49 2916 pyobj = PyUnicode_FromWideChar((&wxPyUTF8String)->c_str(), (&wxPyUTF8String)->Len());
2ef75293 2917#else
0085ce49 2918 pyobj = PyString_FromStringAndSize((&wxPyUTF8String)->c_str(), (&wxPyUTF8String)->Len());
2ef75293 2919#endif
0085ce49
RD		 2920 }
2921 return pyobj;
2ef75293
RD		 2922}
2923
2924
0085ce49
RD		 2925SWIGINTERN int StyleString_set(PyObject *) {
2926 SWIG_Error(SWIG_AttributeError,"Variable StyleString is read-only.");
2927 return 1;
2ef75293
RD		 2928}
2929
2930
0085ce49
RD		 2931SWIGINTERN PyObject *StyleString_get(void) {
2932 PyObject *pyobj = 0;
2933
2934 {
2ef75293 2935#if wxUSE_UNICODE
0085ce49 2936 pyobj = PyUnicode_FromWideChar((&wxPyStyleString)->c_str(), (&wxPyStyleString)->Len());
2ef75293 2937#else
0085ce49 2938 pyobj = PyString_FromStringAndSize((&wxPyStyleString)->c_str(), (&wxPyStyleString)->Len());
2ef75293 2939#endif
0085ce49
RD		 2940 }
2941 return pyobj;
2ef75293
RD		 2942}
2943
2944
0085ce49
RD		 2945SWIGINTERN int SizeString_set(PyObject *) {
2946 SWIG_Error(SWIG_AttributeError,"Variable SizeString is read-only.");
2947 return 1;
2ef75293
RD		 2948}
2949
2950
0085ce49
RD		 2951SWIGINTERN PyObject *SizeString_get(void) {
2952 PyObject *pyobj = 0;
2953
2954 {
2ef75293 2955#if wxUSE_UNICODE
0085ce49 2956 pyobj = PyUnicode_FromWideChar((&wxPySizeString)->c_str(), (&wxPySizeString)->Len());
2ef75293 2957#else
0085ce49 2958 pyobj = PyString_FromStringAndSize((&wxPySizeString)->c_str(), (&wxPySizeString)->Len());
2ef75293 2959#endif
0085ce49
RD		 2960 }
2961 return pyobj;
2ef75293
RD		 2962}
2963
2964
0085ce49
RD		 2965SWIGINTERN int PosString_set(PyObject *) {
2966 SWIG_Error(SWIG_AttributeError,"Variable PosString is read-only.");
2967 return 1;
2ef75293
RD		 2968}
2969
2970
0085ce49
RD		 2971SWIGINTERN PyObject *PosString_get(void) {
2972 PyObject *pyobj = 0;
2973
2974 {
2ef75293 2975#if wxUSE_UNICODE
0085ce49 2976 pyobj = PyUnicode_FromWideChar((&wxPyPosString)->c_str(), (&wxPyPosString)->Len());
2ef75293 2977#else
0085ce49 2978 pyobj = PyString_FromStringAndSize((&wxPyPosString)->c_str(), (&wxPyPosString)->Len());
2ef75293 2979#endif
0085ce49
RD		 2980 }
2981 return pyobj;
2ef75293
RD		 2982}
2983
2984
0085ce49
RD		 2985SWIGINTERN int BitmapString_set(PyObject *) {
2986 SWIG_Error(SWIG_AttributeError,"Variable BitmapString is read-only.");
2987 return 1;
2ef75293
RD		 2988}
2989
2990
0085ce49
RD		 2991SWIGINTERN PyObject *BitmapString_get(void) {
2992 PyObject *pyobj = 0;
2993
2994 {
2ef75293 2995#if wxUSE_UNICODE
0085ce49 2996 pyobj = PyUnicode_FromWideChar((&wxPyBitmapString)->c_str(), (&wxPyBitmapString)->Len());
2ef75293 2997#else
0085ce49 2998 pyobj = PyString_FromStringAndSize((&wxPyBitmapString)->c_str(), (&wxPyBitmapString)->Len());
2ef75293 2999#endif
0085ce49
RD		 3000 }
3001 return pyobj;
2ef75293
RD		 3002}
3003
3004
0085ce49
RD		 3005SWIGINTERN int IconString_set(PyObject *) {
3006 SWIG_Error(SWIG_AttributeError,"Variable IconString is read-only.");
3007 return 1;
2ef75293
RD		 3008}
3009
3010
0085ce49
RD		 3011SWIGINTERN PyObject *IconString_get(void) {
3012 PyObject *pyobj = 0;
3013
3014 {
2ef75293 3015#if wxUSE_UNICODE
0085ce49 3016 pyobj = PyUnicode_FromWideChar((&wxPyIconString)->c_str(), (&wxPyIconString)->Len());
2ef75293 3017#else
0085ce49 3018 pyobj = PyString_FromStringAndSize((&wxPyIconString)->c_str(), (&wxPyIconString)->Len());
2ef75293 3019#endif
0085ce49
RD		 3020 }
3021 return pyobj;
2ef75293
RD		 3022}
3023
3024
0085ce49
RD		 3025SWIGINTERN int FontString_set(PyObject *) {
3026 SWIG_Error(SWIG_AttributeError,"Variable FontString is read-only.");
3027 return 1;
2ef75293
RD		 3028}
3029
3030
0085ce49
RD		 3031SWIGINTERN PyObject *FontString_get(void) {
3032 PyObject *pyobj = 0;
3033
3034 {
2ef75293 3035#if wxUSE_UNICODE
0085ce49 3036 pyobj = PyUnicode_FromWideChar((&wxPyFontString)->c_str(), (&wxPyFontString)->Len());
2ef75293 3037#else
0085ce49 3038 pyobj = PyString_FromStringAndSize((&wxPyFontString)->c_str(), (&wxPyFontString)->Len());
2ef75293 3039#endif
0085ce49
RD		 3040 }
3041 return pyobj;
3042}
3043
3044
3045SWIGINTERN PyObject *_wrap_new_XmlResource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3046 PyObject *resultobj = 0;
3047 wxString *arg1 = 0 ;
3048 int arg2 = (int) wxXRC_USE_LOCALE ;
3049 wxXmlResource *result = 0 ;
3050 bool temp1 = false ;
3051 int val2 ;
3052 int ecode2 = 0 ;
3053 PyObject * obj0 = 0 ;
3054 PyObject * obj1 = 0 ;
3055 char * kwnames[] = {
3056 (char *) "filemask",(char *) "flags", NULL
3057 };
3058
3059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_XmlResource",kwnames,&obj0,&obj1)) SWIG_fail;
3060 {
3061 arg1 = wxString_in_helper(obj0);
3062 if (arg1 == NULL) SWIG_fail;
3063 temp1 = true;
3064 }
3065 if (obj1) {
3066 ecode2 = SWIG_AsVal_int(obj1, &val2);
3067 if (!SWIG_IsOK(ecode2)) {
3068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XmlResource" "', expected argument " "2"" of type '" "int""'");
3069 }
3070 arg2 = static_cast< int >(val2);
3071 }
3072 {
3073 PyThreadState* __tstate = wxPyBeginAllowThreads();
3074 result = (wxXmlResource *)new wxXmlResource((wxString const &)*arg1,arg2);
3075 wxPyEndAllowThreads(__tstate);
3076 if (PyErr_Occurred()) SWIG_fail;
3077 }
3078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlResource, SWIG_POINTER_NEW | 0 );
3079 {
3080 if (temp1)
3081 delete arg1;
3082 }
3083 return resultobj;
3084fail:
3085 {
3086 if (temp1)
3087 delete arg1;
3088 }
3089 return NULL;
2ef75293
RD		 3090}
3091
3092
0085ce49
RD		 3093SWIGINTERN PyObject *_wrap_new_EmptyXmlResource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3094 PyObject *resultobj = 0;
3095 int arg1 = (int) wxXRC_USE_LOCALE ;
3096 wxXmlResource *result = 0 ;
3097 int val1 ;
3098 int ecode1 = 0 ;
3099 PyObject * obj0 = 0 ;
3100 char * kwnames[] = {
3101 (char *) "flags", NULL
3102 };
3103
3104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_EmptyXmlResource",kwnames,&obj0)) SWIG_fail;
3105 if (obj0) {
3106 ecode1 = SWIG_AsVal_int(obj0, &val1);
3107 if (!SWIG_IsOK(ecode1)) {
3108 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyXmlResource" "', expected argument " "1"" of type '" "int""'");
3109 }
3110 arg1 = static_cast< int >(val1);
3111 }
3112 {
3113 PyThreadState* __tstate = wxPyBeginAllowThreads();
3114 result = (wxXmlResource *)new wxXmlResource(arg1);
3115 wxPyEndAllowThreads(__tstate);
3116 if (PyErr_Occurred()) SWIG_fail;
3117 }
3118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlResource, SWIG_POINTER_OWN | 0 );
3119 return resultobj;
3120fail:
3121 return NULL;
2ef75293
RD		 3122}
3123
3124
0085ce49
RD		 3125SWIGINTERN PyObject *_wrap_delete_XmlResource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3126 PyObject *resultobj = 0;
3127 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3128 void *argp1 = 0 ;
3129 int res1 = 0 ;
3130 PyObject *swig_obj[1] ;
3131
3132 if (!args) SWIG_fail;
3133 swig_obj[0] = args;
3134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlResource, SWIG_POINTER_DISOWN | 0 );
3135 if (!SWIG_IsOK(res1)) {
3136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XmlResource" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3137 }
3138 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3139 {
3140 PyThreadState* __tstate = wxPyBeginAllowThreads();
3141 delete arg1;
2ef75293 3142
0085ce49
RD		 3143 wxPyEndAllowThreads(__tstate);
3144 if (PyErr_Occurred()) SWIG_fail;
3145 }
3146 resultobj = SWIG_Py_Void();
3147 return resultobj;
3148fail:
3149 return NULL;
3150}
3151
3152
3153SWIGINTERN PyObject *_wrap_XmlResource_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3154 PyObject *resultobj = 0;
3155 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3156 wxString *arg2 = 0 ;
3157 bool result;
3158 void *argp1 = 0 ;
3159 int res1 = 0 ;
3160 bool temp2 = false ;
3161 PyObject * obj0 = 0 ;
3162 PyObject * obj1 = 0 ;
3163 char * kwnames[] = {
3164 (char *) "self",(char *) "filemask", NULL
3165 };
3166
3167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_Load",kwnames,&obj0,&obj1)) SWIG_fail;
3168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3169 if (!SWIG_IsOK(res1)) {
3170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_Load" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3171 }
3172 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3173 {
3174 arg2 = wxString_in_helper(obj1);
3175 if (arg2 == NULL) SWIG_fail;
3176 temp2 = true;
3177 }
3178 {
3179 PyThreadState* __tstate = wxPyBeginAllowThreads();
3180 result = (bool)(arg1)->Load((wxString const &)*arg2);
3181 wxPyEndAllowThreads(__tstate);
3182 if (PyErr_Occurred()) SWIG_fail;
3183 }
3184 {
3185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3186 }
3187 {
3188 if (temp2)
3189 delete arg2;
3190 }
3191 return resultobj;
3192fail:
3193 {
3194 if (temp2)
3195 delete arg2;
3196 }
3197 return NULL;
3198}
3199
3200
3201SWIGINTERN PyObject *_wrap_XmlResource_LoadFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3202 PyObject *resultobj = 0;
3203 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3204 wxString *arg2 = 0 ;
3205 bool result;
3206 void *argp1 = 0 ;
3207 int res1 = 0 ;
3208 bool temp2 = false ;
3209 PyObject * obj0 = 0 ;
3210 PyObject * obj1 = 0 ;
3211 char * kwnames[] = {
3212 (char *) "self",(char *) "data", NULL
3213 };
3214
3215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_LoadFromString",kwnames,&obj0,&obj1)) SWIG_fail;
3216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3217 if (!SWIG_IsOK(res1)) {
3218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadFromString" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3219 }
3220 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3221 {
3222 arg2 = wxString_in_helper(obj1);
3223 if (arg2 == NULL) SWIG_fail;
3224 temp2 = true;
3225 }
3226 {
3227 PyThreadState* __tstate = wxPyBeginAllowThreads();
3228 result = (bool)wxXmlResource_LoadFromString(arg1,(wxString const &)*arg2);
3229 wxPyEndAllowThreads(__tstate);
3230 if (PyErr_Occurred()) SWIG_fail;
3231 }
3232 {
3233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3234 }
3235 {
3236 if (temp2)
3237 delete arg2;
3238 }
3239 return resultobj;
3240fail:
3241 {
3242 if (temp2)
3243 delete arg2;
3244 }
3245 return NULL;
3246}
3247
3248
3249SWIGINTERN PyObject *_wrap_XmlResource_Unload(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3250 PyObject *resultobj = 0;
3251 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3252 wxString *arg2 = 0 ;
3253 bool result;
3254 void *argp1 = 0 ;
3255 int res1 = 0 ;
3256 bool temp2 = false ;
3257 PyObject * obj0 = 0 ;
3258 PyObject * obj1 = 0 ;
3259 char * kwnames[] = {
3260 (char *) "self",(char *) "filename", NULL
3261 };
3262
3263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_Unload",kwnames,&obj0,&obj1)) SWIG_fail;
3264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3265 if (!SWIG_IsOK(res1)) {
3266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_Unload" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3267 }
3268 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3269 {
3270 arg2 = wxString_in_helper(obj1);
3271 if (arg2 == NULL) SWIG_fail;
3272 temp2 = true;
3273 }
3274 {
3275 PyThreadState* __tstate = wxPyBeginAllowThreads();
3276 result = (bool)(arg1)->Unload((wxString const &)*arg2);
3277 wxPyEndAllowThreads(__tstate);
3278 if (PyErr_Occurred()) SWIG_fail;
3279 }
3280 {
3281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3282 }
3283 {
3284 if (temp2)
3285 delete arg2;
3286 }
3287 return resultobj;
3288fail:
3289 {
3290 if (temp2)
3291 delete arg2;
3292 }
3293 return NULL;
2ef75293
RD		 3294}
3295
3296
0085ce49
RD		 3297SWIGINTERN PyObject *_wrap_XmlResource_InitAllHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3298 PyObject *resultobj = 0;
3299 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3300 void *argp1 = 0 ;
3301 int res1 = 0 ;
3302 PyObject *swig_obj[1] ;
3303
3304 if (!args) SWIG_fail;
3305 swig_obj[0] = args;
3306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3307 if (!SWIG_IsOK(res1)) {
3308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_InitAllHandlers" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3309 }
3310 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3311 {
3312 PyThreadState* __tstate = wxPyBeginAllowThreads();
3313 (arg1)->InitAllHandlers();
3314 wxPyEndAllowThreads(__tstate);
3315 if (PyErr_Occurred()) SWIG_fail;
3316 }
3317 resultobj = SWIG_Py_Void();
3318 return resultobj;
3319fail:
3320 return NULL;
3321}
3322
3323
3324SWIGINTERN PyObject *_wrap_XmlResource_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3325 PyObject *resultobj = 0;
3326 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3327 wxPyXmlResourceHandler *arg2 = (wxPyXmlResourceHandler *) 0 ;
3328 void *argp1 = 0 ;
3329 int res1 = 0 ;
3330 void *argp2 = 0 ;
3331 int res2 = 0 ;
3332 PyObject * obj0 = 0 ;
3333 PyObject * obj1 = 0 ;
3334 char * kwnames[] = {
3335 (char *) "self",(char *) "handler", NULL
3336 };
3337
3338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_AddHandler",kwnames,&obj0,&obj1)) SWIG_fail;
3339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3340 if (!SWIG_IsOK(res1)) {
3341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_AddHandler" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3342 }
3343 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3344 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
3345 if (!SWIG_IsOK(res2)) {
3346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_AddHandler" "', expected argument " "2"" of type '" "wxPyXmlResourceHandler *""'");
3347 }
3348 arg2 = reinterpret_cast< wxPyXmlResourceHandler * >(argp2);
3349 {
3350 PyThreadState* __tstate = wxPyBeginAllowThreads();
3351 (arg1)->AddHandler(arg2);
3352 wxPyEndAllowThreads(__tstate);
3353 if (PyErr_Occurred()) SWIG_fail;
3354 }
3355 resultobj = SWIG_Py_Void();
3356 return resultobj;
3357fail:
3358 return NULL;
3359}
3360
3361
3362SWIGINTERN PyObject *_wrap_XmlResource_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3363 PyObject *resultobj = 0;
3364 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3365 wxPyXmlResourceHandler *arg2 = (wxPyXmlResourceHandler *) 0 ;
3366 void *argp1 = 0 ;
3367 int res1 = 0 ;
3368 void *argp2 = 0 ;
3369 int res2 = 0 ;
3370 PyObject * obj0 = 0 ;
3371 PyObject * obj1 = 0 ;
3372 char * kwnames[] = {
3373 (char *) "self",(char *) "handler", NULL
3374 };
3375
3376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_InsertHandler",kwnames,&obj0,&obj1)) SWIG_fail;
3377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3378 if (!SWIG_IsOK(res1)) {
3379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_InsertHandler" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3380 }
3381 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3382 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
3383 if (!SWIG_IsOK(res2)) {
3384 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_InsertHandler" "', expected argument " "2"" of type '" "wxPyXmlResourceHandler *""'");
3385 }
3386 arg2 = reinterpret_cast< wxPyXmlResourceHandler * >(argp2);
3387 {
3388 PyThreadState* __tstate = wxPyBeginAllowThreads();
3389 (arg1)->InsertHandler(arg2);
3390 wxPyEndAllowThreads(__tstate);
3391 if (PyErr_Occurred()) SWIG_fail;
3392 }
3393 resultobj = SWIG_Py_Void();
3394 return resultobj;
3395fail:
3396 return NULL;
2ef75293
RD		 3397}
3398
3399
0085ce49
RD		 3400SWIGINTERN PyObject *_wrap_XmlResource_ClearHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3401 PyObject *resultobj = 0;
3402 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3403 void *argp1 = 0 ;
3404 int res1 = 0 ;
3405 PyObject *swig_obj[1] ;
3406
3407 if (!args) SWIG_fail;
3408 swig_obj[0] = args;
3409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3410 if (!SWIG_IsOK(res1)) {
3411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_ClearHandlers" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3412 }
3413 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3414 {
3415 PyThreadState* __tstate = wxPyBeginAllowThreads();
3416 (arg1)->ClearHandlers();
3417 wxPyEndAllowThreads(__tstate);
3418 if (PyErr_Occurred()) SWIG_fail;
3419 }
3420 resultobj = SWIG_Py_Void();
3421 return resultobj;
3422fail:
3423 return NULL;
2ef75293
RD		 3424}
3425
3426
0085ce49
RD		 3427SWIGINTERN PyObject *_wrap_XmlResource_AddSubclassFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3428 PyObject *resultobj = 0;
3429 wxPyXmlSubclassFactory *arg1 = (wxPyXmlSubclassFactory *) 0 ;
3430 void *argp1 = 0 ;
3431 int res1 = 0 ;
3432 PyObject * obj0 = 0 ;
3433 char * kwnames[] = {
3434 (char *) "factory", NULL
3435 };
3436
3437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlResource_AddSubclassFactory",kwnames,&obj0)) SWIG_fail;
3438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlSubclassFactory, 0 | 0 );
3439 if (!SWIG_IsOK(res1)) {
3440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_AddSubclassFactory" "', expected argument " "1"" of type '" "wxPyXmlSubclassFactory *""'");
3441 }
3442 arg1 = reinterpret_cast< wxPyXmlSubclassFactory * >(argp1);
3443 {
3444 PyThreadState* __tstate = wxPyBeginAllowThreads();
3445 wxXmlResource::AddSubclassFactory(arg1);
3446 wxPyEndAllowThreads(__tstate);
3447 if (PyErr_Occurred()) SWIG_fail;
3448 }
3449 resultobj = SWIG_Py_Void();
3450 return resultobj;
3451fail:
3452 return NULL;
3453}
3454
3455
3456SWIGINTERN PyObject *_wrap_XmlResource_LoadMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3457 PyObject *resultobj = 0;
3458 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3459 wxString *arg2 = 0 ;
3460 wxMenu *result = 0 ;
3461 void *argp1 = 0 ;
3462 int res1 = 0 ;
3463 bool temp2 = false ;
3464 PyObject * obj0 = 0 ;
3465 PyObject * obj1 = 0 ;
3466 char * kwnames[] = {
3467 (char *) "self",(char *) "name", NULL
3468 };
3469
3470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_LoadMenu",kwnames,&obj0,&obj1)) SWIG_fail;
3471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3472 if (!SWIG_IsOK(res1)) {
3473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadMenu" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3474 }
3475 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3476 {
3477 arg2 = wxString_in_helper(obj1);
3478 if (arg2 == NULL) SWIG_fail;
3479 temp2 = true;
3480 }
3481 {
3482 PyThreadState* __tstate = wxPyBeginAllowThreads();
3483 result = (wxMenu *)(arg1)->LoadMenu((wxString const &)*arg2);
3484 wxPyEndAllowThreads(__tstate);
3485 if (PyErr_Occurred()) SWIG_fail;
3486 }
3487 {
3488 resultobj = wxPyMake_wxObject(result, 0);
3489 }
3490 {
3491 if (temp2)
3492 delete arg2;
3493 }
3494 return resultobj;
3495fail:
3496 {
3497 if (temp2)
3498 delete arg2;
3499 }
3500 return NULL;
3501}
3502
3503
3504SWIGINTERN PyObject *_wrap_XmlResource_LoadMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3505 PyObject *resultobj = 0;
3506 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3507 wxString *arg2 = 0 ;
3508 wxMenuBar *result = 0 ;
3509 void *argp1 = 0 ;
3510 int res1 = 0 ;
3511 bool temp2 = false ;
3512 PyObject * obj0 = 0 ;
3513 PyObject * obj1 = 0 ;
3514 char * kwnames[] = {
3515 (char *) "self",(char *) "name", NULL
3516 };
3517
3518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_LoadMenuBar",kwnames,&obj0,&obj1)) SWIG_fail;
3519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3520 if (!SWIG_IsOK(res1)) {
3521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadMenuBar" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3522 }
3523 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3524 {
3525 arg2 = wxString_in_helper(obj1);
3526 if (arg2 == NULL) SWIG_fail;
3527 temp2 = true;
3528 }
3529 {
3530 PyThreadState* __tstate = wxPyBeginAllowThreads();
3531 result = (wxMenuBar *)(arg1)->LoadMenuBar((wxString const &)*arg2);
3532 wxPyEndAllowThreads(__tstate);
3533 if (PyErr_Occurred()) SWIG_fail;
3534 }
3535 {
3536 resultobj = wxPyMake_wxObject(result, 0);
3537 }
3538 {
3539 if (temp2)
3540 delete arg2;
3541 }
3542 return resultobj;
3543fail:
3544 {
3545 if (temp2)
3546 delete arg2;
3547 }
3548 return NULL;
3549}
3550
3551
3552SWIGINTERN PyObject *_wrap_XmlResource_LoadMenuBarOnFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3553 PyObject *resultobj = 0;
3554 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3555 wxWindow *arg2 = (wxWindow *) 0 ;
3556 wxString *arg3 = 0 ;
3557 wxMenuBar *result = 0 ;
3558 void *argp1 = 0 ;
3559 int res1 = 0 ;
3560 void *argp2 = 0 ;
3561 int res2 = 0 ;
3562 bool temp3 = false ;
3563 PyObject * obj0 = 0 ;
3564 PyObject * obj1 = 0 ;
3565 PyObject * obj2 = 0 ;
3566 char * kwnames[] = {
3567 (char *) "self",(char *) "parent",(char *) "name", NULL
3568 };
3569
3570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResource_LoadMenuBarOnFrame",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3572 if (!SWIG_IsOK(res1)) {
3573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadMenuBarOnFrame" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3574 }
3575 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3576 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
3577 if (!SWIG_IsOK(res2)) {
3578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadMenuBarOnFrame" "', expected argument " "2"" of type '" "wxWindow *""'");
3579 }
3580 arg2 = reinterpret_cast< wxWindow * >(argp2);
3581 {
3582 arg3 = wxString_in_helper(obj2);
3583 if (arg3 == NULL) SWIG_fail;
3584 temp3 = true;
3585 }
3586 {
3587 PyThreadState* __tstate = wxPyBeginAllowThreads();
3588 result = (wxMenuBar *)(arg1)->LoadMenuBar(arg2,(wxString const &)*arg3);
3589 wxPyEndAllowThreads(__tstate);
3590 if (PyErr_Occurred()) SWIG_fail;
3591 }
3592 {
3593 resultobj = wxPyMake_wxObject(result, 0);
3594 }
3595 {
3596 if (temp3)
3597 delete arg3;
3598 }
3599 return resultobj;
3600fail:
3601 {
3602 if (temp3)
3603 delete arg3;
3604 }
3605 return NULL;
3606}
3607
3608
3609SWIGINTERN PyObject *_wrap_XmlResource_LoadToolBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3610 PyObject *resultobj = 0;
3611 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3612 wxWindow *arg2 = (wxWindow *) 0 ;
3613 wxString *arg3 = 0 ;
3614 wxToolBar *result = 0 ;
3615 void *argp1 = 0 ;
3616 int res1 = 0 ;
3617 void *argp2 = 0 ;
3618 int res2 = 0 ;
3619 bool temp3 = false ;
3620 PyObject * obj0 = 0 ;
3621 PyObject * obj1 = 0 ;
3622 PyObject * obj2 = 0 ;
3623 char * kwnames[] = {
3624 (char *) "self",(char *) "parent",(char *) "name", NULL
3625 };
3626
3627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResource_LoadToolBar",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3629 if (!SWIG_IsOK(res1)) {
3630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadToolBar" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3631 }
3632 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3633 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
3634 if (!SWIG_IsOK(res2)) {
3635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadToolBar" "', expected argument " "2"" of type '" "wxWindow *""'");
3636 }
3637 arg2 = reinterpret_cast< wxWindow * >(argp2);
3638 {
3639 arg3 = wxString_in_helper(obj2);
3640 if (arg3 == NULL) SWIG_fail;
3641 temp3 = true;
3642 }
3643 {
3644 PyThreadState* __tstate = wxPyBeginAllowThreads();
3645 result = (wxToolBar *)(arg1)->LoadToolBar(arg2,(wxString const &)*arg3);
3646 wxPyEndAllowThreads(__tstate);
3647 if (PyErr_Occurred()) SWIG_fail;
3648 }
3649 {
3650 resultobj = wxPyMake_wxObject(result, (bool)0);
3651 }
3652 {
3653 if (temp3)
3654 delete arg3;
3655 }
3656 return resultobj;
3657fail:
3658 {
3659 if (temp3)
3660 delete arg3;
3661 }
3662 return NULL;
3663}
3664
3665
3666SWIGINTERN PyObject *_wrap_XmlResource_LoadDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3667 PyObject *resultobj = 0;
3668 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3669 wxWindow *arg2 = (wxWindow *) 0 ;
3670 wxString *arg3 = 0 ;
3671 wxDialog *result = 0 ;
3672 void *argp1 = 0 ;
3673 int res1 = 0 ;
3674 void *argp2 = 0 ;
3675 int res2 = 0 ;
3676 bool temp3 = false ;
3677 PyObject * obj0 = 0 ;
3678 PyObject * obj1 = 0 ;
3679 PyObject * obj2 = 0 ;
3680 char * kwnames[] = {
3681 (char *) "self",(char *) "parent",(char *) "name", NULL
3682 };
3683
3684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResource_LoadDialog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3686 if (!SWIG_IsOK(res1)) {
3687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadDialog" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3688 }
3689 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3690 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
3691 if (!SWIG_IsOK(res2)) {
3692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadDialog" "', expected argument " "2"" of type '" "wxWindow *""'");
3693 }
3694 arg2 = reinterpret_cast< wxWindow * >(argp2);
3695 {
3696 arg3 = wxString_in_helper(obj2);
3697 if (arg3 == NULL) SWIG_fail;
3698 temp3 = true;
3699 }
3700 {
3701 PyThreadState* __tstate = wxPyBeginAllowThreads();
3702 result = (wxDialog *)(arg1)->LoadDialog(arg2,(wxString const &)*arg3);
3703 wxPyEndAllowThreads(__tstate);
3704 if (PyErr_Occurred()) SWIG_fail;
3705 }
3706 {
3707 resultobj = wxPyMake_wxObject(result, (bool)0);
3708 }
3709 {
3710 if (temp3)
3711 delete arg3;
3712 }
3713 return resultobj;
3714fail:
3715 {
3716 if (temp3)
3717 delete arg3;
3718 }
3719 return NULL;
3720}
3721
3722
3723SWIGINTERN PyObject *_wrap_XmlResource_LoadOnDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3724 PyObject *resultobj = 0;
3725 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3726 wxDialog *arg2 = (wxDialog *) 0 ;
3727 wxWindow *arg3 = (wxWindow *) 0 ;
3728 wxString *arg4 = 0 ;
3729 bool result;
3730 void *argp1 = 0 ;
3731 int res1 = 0 ;
3732 void *argp2 = 0 ;
3733 int res2 = 0 ;
3734 void *argp3 = 0 ;
3735 int res3 = 0 ;
3736 bool temp4 = false ;
3737 PyObject * obj0 = 0 ;
3738 PyObject * obj1 = 0 ;
3739 PyObject * obj2 = 0 ;
3740 PyObject * obj3 = 0 ;
3741 char * kwnames[] = {
3742 (char *) "self",(char *) "dlg",(char *) "parent",(char *) "name", NULL
3743 };
3744
3745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:XmlResource_LoadOnDialog",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3747 if (!SWIG_IsOK(res1)) {
3748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadOnDialog" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3749 }
3750 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3751 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDialog, 0 | 0 );
3752 if (!SWIG_IsOK(res2)) {
3753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadOnDialog" "', expected argument " "2"" of type '" "wxDialog *""'");
3754 }
3755 arg2 = reinterpret_cast< wxDialog * >(argp2);
3756 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
3757 if (!SWIG_IsOK(res3)) {
3758 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResource_LoadOnDialog" "', expected argument " "3"" of type '" "wxWindow *""'");
3759 }
3760 arg3 = reinterpret_cast< wxWindow * >(argp3);
3761 {
3762 arg4 = wxString_in_helper(obj3);
3763 if (arg4 == NULL) SWIG_fail;
3764 temp4 = true;
3765 }
3766 {
3767 PyThreadState* __tstate = wxPyBeginAllowThreads();
3768 result = (bool)(arg1)->LoadDialog(arg2,arg3,(wxString const &)*arg4);
3769 wxPyEndAllowThreads(__tstate);
3770 if (PyErr_Occurred()) SWIG_fail;
3771 }
3772 {
3773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3774 }
3775 {
3776 if (temp4)
3777 delete arg4;
3778 }
3779 return resultobj;
3780fail:
3781 {
3782 if (temp4)
3783 delete arg4;
3784 }
3785 return NULL;
3786}
3787
3788
3789SWIGINTERN PyObject *_wrap_XmlResource_LoadPanel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3790 PyObject *resultobj = 0;
3791 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3792 wxWindow *arg2 = (wxWindow *) 0 ;
3793 wxString *arg3 = 0 ;
3794 wxPanel *result = 0 ;
3795 void *argp1 = 0 ;
3796 int res1 = 0 ;
3797 void *argp2 = 0 ;
3798 int res2 = 0 ;
3799 bool temp3 = false ;
3800 PyObject * obj0 = 0 ;
3801 PyObject * obj1 = 0 ;
3802 PyObject * obj2 = 0 ;
3803 char * kwnames[] = {
3804 (char *) "self",(char *) "parent",(char *) "name", NULL
3805 };
3806
3807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResource_LoadPanel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3809 if (!SWIG_IsOK(res1)) {
3810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadPanel" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3811 }
3812 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3813 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
3814 if (!SWIG_IsOK(res2)) {
3815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadPanel" "', expected argument " "2"" of type '" "wxWindow *""'");
3816 }
3817 arg2 = reinterpret_cast< wxWindow * >(argp2);
3818 {
3819 arg3 = wxString_in_helper(obj2);
3820 if (arg3 == NULL) SWIG_fail;
3821 temp3 = true;
3822 }
3823 {
3824 PyThreadState* __tstate = wxPyBeginAllowThreads();
3825 result = (wxPanel *)(arg1)->LoadPanel(arg2,(wxString const &)*arg3);
3826 wxPyEndAllowThreads(__tstate);
3827 if (PyErr_Occurred()) SWIG_fail;
3828 }
3829 {
3830 resultobj = wxPyMake_wxObject(result, (bool)0);
3831 }
3832 {
3833 if (temp3)
3834 delete arg3;
3835 }
3836 return resultobj;
3837fail:
3838 {
3839 if (temp3)
3840 delete arg3;
3841 }
3842 return NULL;
3843}
3844
3845
3846SWIGINTERN PyObject *_wrap_XmlResource_LoadOnPanel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3847 PyObject *resultobj = 0;
3848 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3849 wxPanel *arg2 = (wxPanel *) 0 ;
3850 wxWindow *arg3 = (wxWindow *) 0 ;
3851 wxString *arg4 = 0 ;
3852 bool result;
3853 void *argp1 = 0 ;
3854 int res1 = 0 ;
3855 void *argp2 = 0 ;
3856 int res2 = 0 ;
3857 void *argp3 = 0 ;
3858 int res3 = 0 ;
3859 bool temp4 = false ;
3860 PyObject * obj0 = 0 ;
3861 PyObject * obj1 = 0 ;
3862 PyObject * obj2 = 0 ;
3863 PyObject * obj3 = 0 ;
3864 char * kwnames[] = {
3865 (char *) "self",(char *) "panel",(char *) "parent",(char *) "name", NULL
3866 };
3867
3868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:XmlResource_LoadOnPanel",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3870 if (!SWIG_IsOK(res1)) {
3871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadOnPanel" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3872 }
3873 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3874 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxPanel, 0 | 0 );
3875 if (!SWIG_IsOK(res2)) {
3876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadOnPanel" "', expected argument " "2"" of type '" "wxPanel *""'");
3877 }
3878 arg2 = reinterpret_cast< wxPanel * >(argp2);
3879 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
3880 if (!SWIG_IsOK(res3)) {
3881 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResource_LoadOnPanel" "', expected argument " "3"" of type '" "wxWindow *""'");
3882 }
3883 arg3 = reinterpret_cast< wxWindow * >(argp3);
3884 {
3885 arg4 = wxString_in_helper(obj3);
3886 if (arg4 == NULL) SWIG_fail;
3887 temp4 = true;
3888 }
3889 {
3890 PyThreadState* __tstate = wxPyBeginAllowThreads();
3891 result = (bool)(arg1)->LoadPanel(arg2,arg3,(wxString const &)*arg4);
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 (temp4)
3900 delete arg4;
3901 }
3902 return resultobj;
3903fail:
3904 {
3905 if (temp4)
3906 delete arg4;
3907 }
3908 return NULL;
3909}
3910
3911
3912SWIGINTERN PyObject *_wrap_XmlResource_LoadFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3913 PyObject *resultobj = 0;
3914 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3915 wxWindow *arg2 = (wxWindow *) 0 ;
3916 wxString *arg3 = 0 ;
3917 wxFrame *result = 0 ;
3918 void *argp1 = 0 ;
3919 int res1 = 0 ;
3920 void *argp2 = 0 ;
3921 int res2 = 0 ;
3922 bool temp3 = false ;
3923 PyObject * obj0 = 0 ;
3924 PyObject * obj1 = 0 ;
3925 PyObject * obj2 = 0 ;
3926 char * kwnames[] = {
3927 (char *) "self",(char *) "parent",(char *) "name", NULL
3928 };
3929
3930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResource_LoadFrame",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3932 if (!SWIG_IsOK(res1)) {
3933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadFrame" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3934 }
3935 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3936 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
3937 if (!SWIG_IsOK(res2)) {
3938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadFrame" "', expected argument " "2"" of type '" "wxWindow *""'");
3939 }
3940 arg2 = reinterpret_cast< wxWindow * >(argp2);
3941 {
3942 arg3 = wxString_in_helper(obj2);
3943 if (arg3 == NULL) SWIG_fail;
3944 temp3 = true;
3945 }
3946 {
3947 PyThreadState* __tstate = wxPyBeginAllowThreads();
3948 result = (wxFrame *)(arg1)->LoadFrame(arg2,(wxString const &)*arg3);
3949 wxPyEndAllowThreads(__tstate);
3950 if (PyErr_Occurred()) SWIG_fail;
3951 }
3952 {
3953 resultobj = wxPyMake_wxObject(result, (bool)0);
3954 }
3955 {
3956 if (temp3)
3957 delete arg3;
3958 }
3959 return resultobj;
3960fail:
3961 {
3962 if (temp3)
3963 delete arg3;
3964 }
3965 return NULL;
3966}
3967
3968
3969SWIGINTERN PyObject *_wrap_XmlResource_LoadOnFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3970 PyObject *resultobj = 0;
3971 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
3972 wxFrame *arg2 = (wxFrame *) 0 ;
3973 wxWindow *arg3 = (wxWindow *) 0 ;
3974 wxString *arg4 = 0 ;
3975 bool result;
3976 void *argp1 = 0 ;
3977 int res1 = 0 ;
3978 void *argp2 = 0 ;
3979 int res2 = 0 ;
3980 void *argp3 = 0 ;
3981 int res3 = 0 ;
3982 bool temp4 = false ;
3983 PyObject * obj0 = 0 ;
3984 PyObject * obj1 = 0 ;
3985 PyObject * obj2 = 0 ;
3986 PyObject * obj3 = 0 ;
3987 char * kwnames[] = {
3988 (char *) "self",(char *) "frame",(char *) "parent",(char *) "name", NULL
3989 };
3990
3991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:XmlResource_LoadOnFrame",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
3993 if (!SWIG_IsOK(res1)) {
3994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadOnFrame" "', expected argument " "1"" of type '" "wxXmlResource *""'");
3995 }
3996 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
3997 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
3998 if (!SWIG_IsOK(res2)) {
3999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadOnFrame" "', expected argument " "2"" of type '" "wxFrame *""'");
4000 }
4001 arg2 = reinterpret_cast< wxFrame * >(argp2);
4002 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
4003 if (!SWIG_IsOK(res3)) {
4004 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResource_LoadOnFrame" "', expected argument " "3"" of type '" "wxWindow *""'");
4005 }
4006 arg3 = reinterpret_cast< wxWindow * >(argp3);
4007 {
4008 arg4 = wxString_in_helper(obj3);
4009 if (arg4 == NULL) SWIG_fail;
4010 temp4 = true;
4011 }
4012 {
4013 PyThreadState* __tstate = wxPyBeginAllowThreads();
4014 result = (bool)(arg1)->LoadFrame(arg2,arg3,(wxString const &)*arg4);
4015 wxPyEndAllowThreads(__tstate);
4016 if (PyErr_Occurred()) SWIG_fail;
4017 }
4018 {
4019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4020 }
4021 {
4022 if (temp4)
4023 delete arg4;
4024 }
4025 return resultobj;
4026fail:
4027 {
4028 if (temp4)
4029 delete arg4;
4030 }
4031 return NULL;
4032}
4033
4034
4035SWIGINTERN PyObject *_wrap_XmlResource_LoadObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4036 PyObject *resultobj = 0;
4037 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4038 wxWindow *arg2 = (wxWindow *) 0 ;
4039 wxString *arg3 = 0 ;
4040 wxString *arg4 = 0 ;
4041 wxObject *result = 0 ;
4042 void *argp1 = 0 ;
4043 int res1 = 0 ;
4044 void *argp2 = 0 ;
4045 int res2 = 0 ;
4046 bool temp3 = false ;
4047 bool temp4 = false ;
4048 PyObject * obj0 = 0 ;
4049 PyObject * obj1 = 0 ;
4050 PyObject * obj2 = 0 ;
4051 PyObject * obj3 = 0 ;
4052 char * kwnames[] = {
4053 (char *) "self",(char *) "parent",(char *) "name",(char *) "classname", NULL
4054 };
4055
4056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:XmlResource_LoadObject",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4058 if (!SWIG_IsOK(res1)) {
4059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadObject" "', expected argument " "1"" of type '" "wxXmlResource *""'");
4060 }
4061 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4062 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4063 if (!SWIG_IsOK(res2)) {
4064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadObject" "', expected argument " "2"" of type '" "wxWindow *""'");
4065 }
4066 arg2 = reinterpret_cast< wxWindow * >(argp2);
4067 {
4068 arg3 = wxString_in_helper(obj2);
4069 if (arg3 == NULL) SWIG_fail;
4070 temp3 = true;
4071 }
4072 {
4073 arg4 = wxString_in_helper(obj3);
4074 if (arg4 == NULL) SWIG_fail;
4075 temp4 = true;
4076 }
4077 {
4078 PyThreadState* __tstate = wxPyBeginAllowThreads();
4079 result = (wxObject *)(arg1)->LoadObject(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
4080 wxPyEndAllowThreads(__tstate);
4081 if (PyErr_Occurred()) SWIG_fail;
4082 }
4083 {
4084 resultobj = wxPyMake_wxObject(result, (bool)0);
4085 }
4086 {
4087 if (temp3)
4088 delete arg3;
4089 }
4090 {
4091 if (temp4)
4092 delete arg4;
4093 }
4094 return resultobj;
4095fail:
4096 {
4097 if (temp3)
4098 delete arg3;
4099 }
4100 {
4101 if (temp4)
4102 delete arg4;
4103 }
4104 return NULL;
4105}
4106
4107
4108SWIGINTERN PyObject *_wrap_XmlResource_LoadOnObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4109 PyObject *resultobj = 0;
4110 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4111 wxObject *arg2 = (wxObject *) 0 ;
4112 wxWindow *arg3 = (wxWindow *) 0 ;
4113 wxString *arg4 = 0 ;
4114 wxString *arg5 = 0 ;
4115 bool result;
4116 void *argp1 = 0 ;
4117 int res1 = 0 ;
4118 void *argp2 = 0 ;
4119 int res2 = 0 ;
4120 void *argp3 = 0 ;
4121 int res3 = 0 ;
4122 bool temp4 = false ;
4123 bool temp5 = false ;
4124 PyObject * obj0 = 0 ;
4125 PyObject * obj1 = 0 ;
4126 PyObject * obj2 = 0 ;
4127 PyObject * obj3 = 0 ;
4128 PyObject * obj4 = 0 ;
4129 char * kwnames[] = {
4130 (char *) "self",(char *) "instance",(char *) "parent",(char *) "name",(char *) "classname", NULL
4131 };
4132
4133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:XmlResource_LoadOnObject",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
4134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4135 if (!SWIG_IsOK(res1)) {
4136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadOnObject" "', expected argument " "1"" of type '" "wxXmlResource *""'");
4137 }
4138 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4139 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
4140 if (!SWIG_IsOK(res2)) {
4141 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResource_LoadOnObject" "', expected argument " "2"" of type '" "wxObject *""'");
4142 }
4143 arg2 = reinterpret_cast< wxObject * >(argp2);
4144 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
4145 if (!SWIG_IsOK(res3)) {
4146 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResource_LoadOnObject" "', expected argument " "3"" of type '" "wxWindow *""'");
4147 }
4148 arg3 = reinterpret_cast< wxWindow * >(argp3);
4149 {
4150 arg4 = wxString_in_helper(obj3);
4151 if (arg4 == NULL) SWIG_fail;
4152 temp4 = true;
4153 }
4154 {
4155 arg5 = wxString_in_helper(obj4);
4156 if (arg5 == NULL) SWIG_fail;
4157 temp5 = true;
4158 }
4159 {
4160 PyThreadState* __tstate = wxPyBeginAllowThreads();
4161 result = (bool)(arg1)->LoadObject(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
4162 wxPyEndAllowThreads(__tstate);
4163 if (PyErr_Occurred()) SWIG_fail;
4164 }
4165 {
4166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4167 }
4168 {
4169 if (temp4)
4170 delete arg4;
4171 }
4172 {
4173 if (temp5)
4174 delete arg5;
4175 }
4176 return resultobj;
4177fail:
4178 {
4179 if (temp4)
4180 delete arg4;
4181 }
4182 {
4183 if (temp5)
4184 delete arg5;
4185 }
4186 return NULL;
4187}
4188
4189
4190SWIGINTERN PyObject *_wrap_XmlResource_LoadBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4191 PyObject *resultobj = 0;
4192 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4193 wxString *arg2 = 0 ;
4194 wxBitmap result;
4195 void *argp1 = 0 ;
4196 int res1 = 0 ;
4197 bool temp2 = false ;
4198 PyObject * obj0 = 0 ;
4199 PyObject * obj1 = 0 ;
4200 char * kwnames[] = {
4201 (char *) "self",(char *) "name", NULL
4202 };
4203
4204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_LoadBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
4205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4206 if (!SWIG_IsOK(res1)) {
4207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadBitmap" "', expected argument " "1"" of type '" "wxXmlResource *""'");
4208 }
4209 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4210 {
4211 arg2 = wxString_in_helper(obj1);
4212 if (arg2 == NULL) SWIG_fail;
4213 temp2 = true;
4214 }
4215 {
4216 PyThreadState* __tstate = wxPyBeginAllowThreads();
4217 result = (arg1)->LoadBitmap((wxString const &)*arg2);
4218 wxPyEndAllowThreads(__tstate);
4219 if (PyErr_Occurred()) SWIG_fail;
4220 }
4221 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
4222 {
4223 if (temp2)
4224 delete arg2;
4225 }
4226 return resultobj;
4227fail:
4228 {
4229 if (temp2)
4230 delete arg2;
4231 }
4232 return NULL;
4233}
4234
4235
4236SWIGINTERN PyObject *_wrap_XmlResource_LoadIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4237 PyObject *resultobj = 0;
4238 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4239 wxString *arg2 = 0 ;
4240 wxIcon result;
4241 void *argp1 = 0 ;
4242 int res1 = 0 ;
4243 bool temp2 = false ;
4244 PyObject * obj0 = 0 ;
4245 PyObject * obj1 = 0 ;
4246 char * kwnames[] = {
4247 (char *) "self",(char *) "name", NULL
4248 };
4249
4250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_LoadIcon",kwnames,&obj0,&obj1)) SWIG_fail;
4251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4252 if (!SWIG_IsOK(res1)) {
4253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_LoadIcon" "', expected argument " "1"" of type '" "wxXmlResource *""'");
4254 }
4255 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4256 {
4257 arg2 = wxString_in_helper(obj1);
4258 if (arg2 == NULL) SWIG_fail;
4259 temp2 = true;
4260 }
4261 {
4262 PyThreadState* __tstate = wxPyBeginAllowThreads();
4263 result = (arg1)->LoadIcon((wxString const &)*arg2);
4264 wxPyEndAllowThreads(__tstate);
4265 if (PyErr_Occurred()) SWIG_fail;
4266 }
4267 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
4268 {
4269 if (temp2)
4270 delete arg2;
4271 }
4272 return resultobj;
4273fail:
4274 {
4275 if (temp2)
4276 delete arg2;
4277 }
4278 return NULL;
4279}
4280
4281
4282SWIGINTERN PyObject *_wrap_XmlResource_AttachUnknownControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4283 PyObject *resultobj = 0;
4284 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4285 wxString *arg2 = 0 ;
4286 wxWindow *arg3 = (wxWindow *) 0 ;
4287 wxWindow *arg4 = (wxWindow *) NULL ;
4288 bool result;
4289 void *argp1 = 0 ;
4290 int res1 = 0 ;
4291 bool temp2 = false ;
4292 void *argp3 = 0 ;
4293 int res3 = 0 ;
4294 void *argp4 = 0 ;
4295 int res4 = 0 ;
4296 PyObject * obj0 = 0 ;
4297 PyObject * obj1 = 0 ;
4298 PyObject * obj2 = 0 ;
4299 PyObject * obj3 = 0 ;
4300 char * kwnames[] = {
4301 (char *) "self",(char *) "name",(char *) "control",(char *) "parent", NULL
4302 };
4303
4304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:XmlResource_AttachUnknownControl",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4306 if (!SWIG_IsOK(res1)) {
4307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_AttachUnknownControl" "', expected argument " "1"" of type '" "wxXmlResource *""'");
4308 }
4309 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4310 {
4311 arg2 = wxString_in_helper(obj1);
4312 if (arg2 == NULL) SWIG_fail;
4313 temp2 = true;
4314 }
4315 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
4316 if (!SWIG_IsOK(res3)) {
4317 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResource_AttachUnknownControl" "', expected argument " "3"" of type '" "wxWindow *""'");
4318 }
4319 arg3 = reinterpret_cast< wxWindow * >(argp3);
4320 if (obj3) {
4321 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
4322 if (!SWIG_IsOK(res4)) {
4323 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "XmlResource_AttachUnknownControl" "', expected argument " "4"" of type '" "wxWindow *""'");
2ef75293 4324 }
0085ce49
RD		 4325 arg4 = reinterpret_cast< wxWindow * >(argp4);
4326 }
4327 {
4328 PyThreadState* __tstate = wxPyBeginAllowThreads();
4329 result = (bool)(arg1)->AttachUnknownControl((wxString const &)*arg2,arg3,arg4);
4330 wxPyEndAllowThreads(__tstate);
4331 if (PyErr_Occurred()) SWIG_fail;
4332 }
4333 {
4334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4335 }
4336 {
4337 if (temp2)
4338 delete arg2;
4339 }
4340 return resultobj;
4341fail:
4342 {
4343 if (temp2)
4344 delete arg2;
4345 }
4346 return NULL;
2ef75293
RD		 4347}
4348
4349
0085ce49
RD		 4350SWIGINTERN PyObject *_wrap_XmlResource_GetXRCID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4351 PyObject *resultobj = 0;
2131d850 4352 wxString *arg1 = 0 ;
01f6b6d3 4353 int arg2 = (int) wxID_NONE ;
0085ce49 4354 int result;
2131d850 4355 bool temp1 = false ;
01f6b6d3
RD		 4356 int val2 ;
4357 int ecode2 = 0 ;
0085ce49 4358 PyObject * obj0 = 0 ;
01f6b6d3 4359 PyObject * obj1 = 0 ;
0085ce49 4360 char * kwnames[] = {
01f6b6d3 4361 (char *) "str_id",(char *) "value_if_not_found", NULL
0085ce49
RD		 4362 };
4363
01f6b6d3 4364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:XmlResource_GetXRCID",kwnames,&obj0,&obj1)) SWIG_fail;
2131d850
RD		 4365 {
4366 arg1 = wxString_in_helper(obj0);
4367 if (arg1 == NULL) SWIG_fail;
4368 temp1 = true;
01f6b6d3 4369 }
01f6b6d3
RD		 4370 if (obj1) {
4371 ecode2 = SWIG_AsVal_int(obj1, &val2);
4372 if (!SWIG_IsOK(ecode2)) {
4373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XmlResource_GetXRCID" "', expected argument " "2"" of type '" "int""'");
4374 }
4375 arg2 = static_cast< int >(val2);
0085ce49
RD		 4376 }
4377 {
4378 PyThreadState* __tstate = wxPyBeginAllowThreads();
2131d850 4379 result = (int)wxXmlResource::GetXRCID((wxString const &)*arg1,arg2);
0085ce49
RD		 4380 wxPyEndAllowThreads(__tstate);
4381 if (PyErr_Occurred()) SWIG_fail;
4382 }
4383 resultobj = SWIG_From_int(static_cast< int >(result));
2131d850
RD		 4384 {
4385 if (temp1)
4386 delete arg1;
4387 }
0085ce49
RD		 4388 return resultobj;
4389fail:
2131d850
RD		 4390 {
4391 if (temp1)
4392 delete arg1;
4393 }
0085ce49 4394 return NULL;
2ef75293
RD		 4395}
4396
4397
0085ce49
RD		 4398SWIGINTERN PyObject *_wrap_XmlResource_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4399 PyObject *resultobj = 0;
4400 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4401 long result;
4402 void *argp1 = 0 ;
4403 int res1 = 0 ;
4404 PyObject *swig_obj[1] ;
4405
4406 if (!args) SWIG_fail;
4407 swig_obj[0] = args;
4408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4409 if (!SWIG_IsOK(res1)) {
4410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_GetVersion" "', expected argument " "1"" of type '" "wxXmlResource const *""'");
4411 }
4412 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4413 {
4414 PyThreadState* __tstate = wxPyBeginAllowThreads();
4415 result = (long)((wxXmlResource const *)arg1)->GetVersion();
4416 wxPyEndAllowThreads(__tstate);
4417 if (PyErr_Occurred()) SWIG_fail;
4418 }
4419 resultobj = SWIG_From_long(static_cast< long >(result));
4420 return resultobj;
4421fail:
4422 return NULL;
4423}
4424
4425
4426SWIGINTERN PyObject *_wrap_XmlResource_CompareVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4427 PyObject *resultobj = 0;
4428 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4429 int arg2 ;
4430 int arg3 ;
4431 int arg4 ;
4432 int arg5 ;
4433 int result;
4434 void *argp1 = 0 ;
4435 int res1 = 0 ;
4436 int val2 ;
4437 int ecode2 = 0 ;
4438 int val3 ;
4439 int ecode3 = 0 ;
4440 int val4 ;
4441 int ecode4 = 0 ;
4442 int val5 ;
4443 int ecode5 = 0 ;
4444 PyObject * obj0 = 0 ;
4445 PyObject * obj1 = 0 ;
4446 PyObject * obj2 = 0 ;
4447 PyObject * obj3 = 0 ;
4448 PyObject * obj4 = 0 ;
4449 char * kwnames[] = {
4450 (char *) "self",(char *) "major",(char *) "minor",(char *) "release",(char *) "revision", NULL
4451 };
4452
4453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:XmlResource_CompareVersion",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
4454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4455 if (!SWIG_IsOK(res1)) {
4456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_CompareVersion" "', expected argument " "1"" of type '" "wxXmlResource const *""'");
4457 }
4458 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4459 ecode2 = SWIG_AsVal_int(obj1, &val2);
4460 if (!SWIG_IsOK(ecode2)) {
4461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XmlResource_CompareVersion" "', expected argument " "2"" of type '" "int""'");
4462 }
4463 arg2 = static_cast< int >(val2);
4464 ecode3 = SWIG_AsVal_int(obj2, &val3);
4465 if (!SWIG_IsOK(ecode3)) {
4466 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XmlResource_CompareVersion" "', expected argument " "3"" of type '" "int""'");
4467 }
4468 arg3 = static_cast< int >(val3);
4469 ecode4 = SWIG_AsVal_int(obj3, &val4);
4470 if (!SWIG_IsOK(ecode4)) {
4471 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XmlResource_CompareVersion" "', expected argument " "4"" of type '" "int""'");
4472 }
4473 arg4 = static_cast< int >(val4);
4474 ecode5 = SWIG_AsVal_int(obj4, &val5);
4475 if (!SWIG_IsOK(ecode5)) {
4476 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "XmlResource_CompareVersion" "', expected argument " "5"" of type '" "int""'");
4477 }
4478 arg5 = static_cast< int >(val5);
4479 {
4480 PyThreadState* __tstate = wxPyBeginAllowThreads();
4481 result = (int)((wxXmlResource const *)arg1)->CompareVersion(arg2,arg3,arg4,arg5);
4482 wxPyEndAllowThreads(__tstate);
4483 if (PyErr_Occurred()) SWIG_fail;
4484 }
4485 resultobj = SWIG_From_int(static_cast< int >(result));
4486 return resultobj;
4487fail:
4488 return NULL;
2ef75293
RD		 4489}
4490
4491
0085ce49
RD		 4492SWIGINTERN PyObject *_wrap_XmlResource_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4493 PyObject *resultobj = 0;
4494 wxXmlResource *result = 0 ;
4495
4496 if (!SWIG_Python_UnpackTuple(args,"XmlResource_Get",0,0,0)) SWIG_fail;
4497 {
4498 PyThreadState* __tstate = wxPyBeginAllowThreads();
4499 result = (wxXmlResource *)wxXmlResource::Get();
4500 wxPyEndAllowThreads(__tstate);
4501 if (PyErr_Occurred()) SWIG_fail;
4502 }
4503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlResource, 0 | 0 );
4504 return resultobj;
4505fail:
4506 return NULL;
4507}
4508
4509
4510SWIGINTERN PyObject *_wrap_XmlResource_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4511 PyObject *resultobj = 0;
4512 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4513 wxXmlResource *result = 0 ;
4514 void *argp1 = 0 ;
4515 int res1 = 0 ;
4516 PyObject * obj0 = 0 ;
4517 char * kwnames[] = {
4518 (char *) "res", NULL
4519 };
4520
4521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:XmlResource_Set",kwnames,&obj0)) SWIG_fail;
4522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4523 if (!SWIG_IsOK(res1)) {
4524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_Set" "', expected argument " "1"" of type '" "wxXmlResource *""'");
4525 }
4526 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4527 {
4528 PyThreadState* __tstate = wxPyBeginAllowThreads();
4529 result = (wxXmlResource *)wxXmlResource::Set(arg1);
4530 wxPyEndAllowThreads(__tstate);
4531 if (PyErr_Occurred()) SWIG_fail;
4532 }
4533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlResource, 0 | 0 );
4534 return resultobj;
4535fail:
4536 return NULL;
2ef75293
RD		 4537}
4538
4539
0085ce49
RD		 4540SWIGINTERN PyObject *_wrap_XmlResource_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4541 PyObject *resultobj = 0;
4542 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4543 int result;
4544 void *argp1 = 0 ;
4545 int res1 = 0 ;
4546 PyObject *swig_obj[1] ;
4547
4548 if (!args) SWIG_fail;
4549 swig_obj[0] = args;
4550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4551 if (!SWIG_IsOK(res1)) {
4552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_GetFlags" "', expected argument " "1"" of type '" "wxXmlResource *""'");
4553 }
4554 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4555 {
4556 PyThreadState* __tstate = wxPyBeginAllowThreads();
4557 result = (int)(arg1)->GetFlags();
4558 wxPyEndAllowThreads(__tstate);
4559 if (PyErr_Occurred()) SWIG_fail;
4560 }
4561 resultobj = SWIG_From_int(static_cast< int >(result));
4562 return resultobj;
4563fail:
4564 return NULL;
4565}
4566
4567
4568SWIGINTERN PyObject *_wrap_XmlResource_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4569 PyObject *resultobj = 0;
4570 wxXmlResource *arg1 = (wxXmlResource *) 0 ;
4571 int arg2 ;
4572 void *argp1 = 0 ;
4573 int res1 = 0 ;
4574 int val2 ;
4575 int ecode2 = 0 ;
4576 PyObject * obj0 = 0 ;
4577 PyObject * obj1 = 0 ;
4578 char * kwnames[] = {
4579 (char *) "self",(char *) "flags", NULL
4580 };
4581
4582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResource_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
4583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlResource, 0 | 0 );
4584 if (!SWIG_IsOK(res1)) {
4585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResource_SetFlags" "', expected argument " "1"" of type '" "wxXmlResource *""'");
4586 }
4587 arg1 = reinterpret_cast< wxXmlResource * >(argp1);
4588 ecode2 = SWIG_AsVal_int(obj1, &val2);
4589 if (!SWIG_IsOK(ecode2)) {
4590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XmlResource_SetFlags" "', expected argument " "2"" of type '" "int""'");
4591 }
4592 arg2 = static_cast< int >(val2);
4593 {
4594 PyThreadState* __tstate = wxPyBeginAllowThreads();
4595 (arg1)->SetFlags(arg2);
4596 wxPyEndAllowThreads(__tstate);
4597 if (PyErr_Occurred()) SWIG_fail;
4598 }
4599 resultobj = SWIG_Py_Void();
4600 return resultobj;
4601fail:
4602 return NULL;
2ef75293
RD		 4603}
4604
4605
0085ce49
RD		 4606SWIGINTERN PyObject *XmlResource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4607 PyObject *obj;
4608 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4609 SWIG_TypeNewClientData(SWIGTYPE_p_wxXmlResource, SWIG_NewClientData(obj));
4610 return SWIG_Py_Void();
2ef75293
RD		 4611}
4612
0085ce49
RD		 4613SWIGINTERN PyObject *XmlResource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4614 return SWIG_Python_InitShadowInstance(args);
2ef75293
RD		 4615}
4616
0085ce49
RD		 4617SWIGINTERN PyObject *_wrap_new_XmlSubclassFactory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4618 PyObject *resultobj = 0;
4619 wxPyXmlSubclassFactory *result = 0 ;
4620
4621 if (!SWIG_Python_UnpackTuple(args,"new_XmlSubclassFactory",0,0,0)) SWIG_fail;
4622 {
4623 PyThreadState* __tstate = wxPyBeginAllowThreads();
4624 result = (wxPyXmlSubclassFactory *)new wxPyXmlSubclassFactory();
4625 wxPyEndAllowThreads(__tstate);
4626 if (PyErr_Occurred()) SWIG_fail;
4627 }
4628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyXmlSubclassFactory, SWIG_POINTER_NEW | 0 );
4629 return resultobj;
4630fail:
4631 return NULL;
4632}
4633
4634
4635SWIGINTERN PyObject *_wrap_XmlSubclassFactory__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4636 PyObject *resultobj = 0;
4637 wxPyXmlSubclassFactory *arg1 = (wxPyXmlSubclassFactory *) 0 ;
4638 PyObject *arg2 = (PyObject *) 0 ;
4639 PyObject *arg3 = (PyObject *) 0 ;
4640 void *argp1 = 0 ;
4641 int res1 = 0 ;
4642 PyObject * obj0 = 0 ;
4643 PyObject * obj1 = 0 ;
4644 PyObject * obj2 = 0 ;
4645 char * kwnames[] = {
4646 (char *) "self",(char *) "self",(char *) "_class", NULL
4647 };
4648
4649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlSubclassFactory__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlSubclassFactory, 0 | 0 );
4651 if (!SWIG_IsOK(res1)) {
4652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlSubclassFactory__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyXmlSubclassFactory *""'");
4653 }
4654 arg1 = reinterpret_cast< wxPyXmlSubclassFactory * >(argp1);
4655 arg2 = obj1;
4656 arg3 = obj2;
4657 {
4658 PyThreadState* __tstate = wxPyBeginAllowThreads();
4659 (arg1)->_setCallbackInfo(arg2,arg3);
4660 wxPyEndAllowThreads(__tstate);
4661 if (PyErr_Occurred()) SWIG_fail;
4662 }
4663 resultobj = SWIG_Py_Void();
4664 return resultobj;
4665fail:
4666 return NULL;
4667}
4668
4669
4670SWIGINTERN PyObject *XmlSubclassFactory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4671 PyObject *obj;
4672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4673 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyXmlSubclassFactory, SWIG_NewClientData(obj));
4674 return SWIG_Py_Void();
4675}
4676
4677SWIGINTERN PyObject *XmlSubclassFactory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4678 return SWIG_Python_InitShadowInstance(args);
4679}
4680
4681SWIGINTERN PyObject *_wrap_new_XmlProperty(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4682 PyObject *resultobj = 0;
4683 wxString const &arg1_defvalue = wxPyEmptyString ;
4684 wxString *arg1 = (wxString *) &arg1_defvalue ;
4685 wxString const &arg2_defvalue = wxPyEmptyString ;
4686 wxString *arg2 = (wxString *) &arg2_defvalue ;
4687 wxXmlProperty *arg3 = (wxXmlProperty *) NULL ;
4688 wxXmlProperty *result = 0 ;
4689 bool temp1 = false ;
4690 bool temp2 = false ;
4691 void *argp3 = 0 ;
4692 int res3 = 0 ;
4693 PyObject * obj0 = 0 ;
4694 PyObject * obj1 = 0 ;
4695 PyObject * obj2 = 0 ;
4696 char * kwnames[] = {
4697 (char *) "name",(char *) "value",(char *) "next", NULL
4698 };
4699
4700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_XmlProperty",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4701 if (obj0) {
2ef75293 4702 {
0085ce49
RD		 4703 arg1 = wxString_in_helper(obj0);
4704 if (arg1 == NULL) SWIG_fail;
4705 temp1 = true;
2ef75293 4706 }
0085ce49
RD		 4707 }
4708 if (obj1) {
2ef75293 4709 {
0085ce49
RD		 4710 arg2 = wxString_in_helper(obj1);
4711 if (arg2 == NULL) SWIG_fail;
4712 temp2 = true;
2ef75293 4713 }
0085ce49
RD		 4714 }
4715 if (obj2) {
4716 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4717 if (!SWIG_IsOK(res3)) {
4718 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_XmlProperty" "', expected argument " "3"" of type '" "wxXmlProperty *""'");
2ef75293 4719 }
0085ce49
RD		 4720 arg3 = reinterpret_cast< wxXmlProperty * >(argp3);
4721 }
4722 {
4723 PyThreadState* __tstate = wxPyBeginAllowThreads();
4724 result = (wxXmlProperty *)new wxXmlProperty((wxString const &)*arg1,(wxString const &)*arg2,arg3);
4725 wxPyEndAllowThreads(__tstate);
4726 if (PyErr_Occurred()) SWIG_fail;
4727 }
4728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlProperty, SWIG_POINTER_NEW | 0 );
4729 {
4730 if (temp1)
4731 delete arg1;
4732 }
4733 {
4734 if (temp2)
4735 delete arg2;
4736 }
4737 return resultobj;
4738fail:
4739 {
4740 if (temp1)
4741 delete arg1;
4742 }
4743 {
4744 if (temp2)
4745 delete arg2;
4746 }
4747 return NULL;
2ef75293
RD		 4748}
4749
4750
0085ce49
RD		 4751SWIGINTERN PyObject *_wrap_XmlProperty_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4752 PyObject *resultobj = 0;
4753 wxXmlProperty *arg1 = (wxXmlProperty *) 0 ;
4754 wxString result;
4755 void *argp1 = 0 ;
4756 int res1 = 0 ;
4757 PyObject *swig_obj[1] ;
4758
4759 if (!args) SWIG_fail;
4760 swig_obj[0] = args;
4761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4762 if (!SWIG_IsOK(res1)) {
4763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlProperty_GetName" "', expected argument " "1"" of type '" "wxXmlProperty const *""'");
4764 }
4765 arg1 = reinterpret_cast< wxXmlProperty * >(argp1);
4766 {
4767 PyThreadState* __tstate = wxPyBeginAllowThreads();
4768 result = ((wxXmlProperty const *)arg1)->GetName();
4769 wxPyEndAllowThreads(__tstate);
4770 if (PyErr_Occurred()) SWIG_fail;
4771 }
4772 {
4773#if wxUSE_UNICODE
4774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4775#else
4776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4777#endif
4778 }
4779 return resultobj;
4780fail:
4781 return NULL;
2ef75293
RD		 4782}
4783
4784
0085ce49
RD		 4785SWIGINTERN PyObject *_wrap_XmlProperty_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4786 PyObject *resultobj = 0;
4787 wxXmlProperty *arg1 = (wxXmlProperty *) 0 ;
4788 wxString result;
4789 void *argp1 = 0 ;
4790 int res1 = 0 ;
4791 PyObject *swig_obj[1] ;
4792
4793 if (!args) SWIG_fail;
4794 swig_obj[0] = args;
4795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4796 if (!SWIG_IsOK(res1)) {
4797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlProperty_GetValue" "', expected argument " "1"" of type '" "wxXmlProperty const *""'");
4798 }
4799 arg1 = reinterpret_cast< wxXmlProperty * >(argp1);
4800 {
4801 PyThreadState* __tstate = wxPyBeginAllowThreads();
4802 result = ((wxXmlProperty const *)arg1)->GetValue();
4803 wxPyEndAllowThreads(__tstate);
4804 if (PyErr_Occurred()) SWIG_fail;
4805 }
4806 {
4807#if wxUSE_UNICODE
4808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4809#else
4810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4811#endif
4812 }
4813 return resultobj;
4814fail:
4815 return NULL;
2ef75293
RD		 4816}
4817
4818
0085ce49
RD		 4819SWIGINTERN PyObject *_wrap_XmlProperty_GetNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4820 PyObject *resultobj = 0;
4821 wxXmlProperty *arg1 = (wxXmlProperty *) 0 ;
4822 wxXmlProperty *result = 0 ;
4823 void *argp1 = 0 ;
4824 int res1 = 0 ;
4825 PyObject *swig_obj[1] ;
4826
4827 if (!args) SWIG_fail;
4828 swig_obj[0] = args;
4829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4830 if (!SWIG_IsOK(res1)) {
4831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlProperty_GetNext" "', expected argument " "1"" of type '" "wxXmlProperty const *""'");
4832 }
4833 arg1 = reinterpret_cast< wxXmlProperty * >(argp1);
4834 {
4835 PyThreadState* __tstate = wxPyBeginAllowThreads();
4836 result = (wxXmlProperty *)((wxXmlProperty const *)arg1)->GetNext();
4837 wxPyEndAllowThreads(__tstate);
4838 if (PyErr_Occurred()) SWIG_fail;
4839 }
4840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4841 return resultobj;
4842fail:
4843 return NULL;
4844}
4845
4846
4847SWIGINTERN PyObject *_wrap_XmlProperty_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4848 PyObject *resultobj = 0;
4849 wxXmlProperty *arg1 = (wxXmlProperty *) 0 ;
4850 wxString *arg2 = 0 ;
4851 void *argp1 = 0 ;
4852 int res1 = 0 ;
4853 bool temp2 = false ;
4854 PyObject * obj0 = 0 ;
4855 PyObject * obj1 = 0 ;
4856 char * kwnames[] = {
4857 (char *) "self",(char *) "name", NULL
4858 };
4859
4860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlProperty_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
4861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4862 if (!SWIG_IsOK(res1)) {
4863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlProperty_SetName" "', expected argument " "1"" of type '" "wxXmlProperty *""'");
4864 }
4865 arg1 = reinterpret_cast< wxXmlProperty * >(argp1);
4866 {
4867 arg2 = wxString_in_helper(obj1);
4868 if (arg2 == NULL) SWIG_fail;
4869 temp2 = true;
4870 }
4871 {
4872 PyThreadState* __tstate = wxPyBeginAllowThreads();
4873 (arg1)->SetName((wxString const &)*arg2);
4874 wxPyEndAllowThreads(__tstate);
4875 if (PyErr_Occurred()) SWIG_fail;
4876 }
4877 resultobj = SWIG_Py_Void();
4878 {
4879 if (temp2)
4880 delete arg2;
4881 }
4882 return resultobj;
4883fail:
4884 {
4885 if (temp2)
4886 delete arg2;
4887 }
4888 return NULL;
2ef75293
RD		 4889}
4890
4891
0085ce49
RD		 4892SWIGINTERN PyObject *_wrap_XmlProperty_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4893 PyObject *resultobj = 0;
4894 wxXmlProperty *arg1 = (wxXmlProperty *) 0 ;
4895 wxString *arg2 = 0 ;
4896 void *argp1 = 0 ;
4897 int res1 = 0 ;
4898 bool temp2 = false ;
4899 PyObject * obj0 = 0 ;
4900 PyObject * obj1 = 0 ;
4901 char * kwnames[] = {
4902 (char *) "self",(char *) "value", NULL
4903 };
4904
4905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlProperty_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
4906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4907 if (!SWIG_IsOK(res1)) {
4908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlProperty_SetValue" "', expected argument " "1"" of type '" "wxXmlProperty *""'");
4909 }
4910 arg1 = reinterpret_cast< wxXmlProperty * >(argp1);
4911 {
4912 arg2 = wxString_in_helper(obj1);
4913 if (arg2 == NULL) SWIG_fail;
4914 temp2 = true;
4915 }
4916 {
4917 PyThreadState* __tstate = wxPyBeginAllowThreads();
4918 (arg1)->SetValue((wxString const &)*arg2);
4919 wxPyEndAllowThreads(__tstate);
4920 if (PyErr_Occurred()) SWIG_fail;
4921 }
4922 resultobj = SWIG_Py_Void();
4923 {
4924 if (temp2)
4925 delete arg2;
4926 }
4927 return resultobj;
4928fail:
4929 {
4930 if (temp2)
4931 delete arg2;
4932 }
4933 return NULL;
4934}
4935
4936
4937SWIGINTERN PyObject *_wrap_XmlProperty_SetNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4938 PyObject *resultobj = 0;
4939 wxXmlProperty *arg1 = (wxXmlProperty *) 0 ;
4940 wxXmlProperty *arg2 = (wxXmlProperty *) 0 ;
4941 void *argp1 = 0 ;
4942 int res1 = 0 ;
4943 void *argp2 = 0 ;
4944 int res2 = 0 ;
4945 PyObject * obj0 = 0 ;
4946 PyObject * obj1 = 0 ;
4947 char * kwnames[] = {
4948 (char *) "self",(char *) "next", NULL
4949 };
4950
4951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlProperty_SetNext",kwnames,&obj0,&obj1)) SWIG_fail;
4952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4953 if (!SWIG_IsOK(res1)) {
4954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlProperty_SetNext" "', expected argument " "1"" of type '" "wxXmlProperty *""'");
4955 }
4956 arg1 = reinterpret_cast< wxXmlProperty * >(argp1);
4957 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
4958 if (!SWIG_IsOK(res2)) {
4959 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlProperty_SetNext" "', expected argument " "2"" of type '" "wxXmlProperty *""'");
4960 }
4961 arg2 = reinterpret_cast< wxXmlProperty * >(argp2);
4962 {
4963 PyThreadState* __tstate = wxPyBeginAllowThreads();
4964 (arg1)->SetNext(arg2);
4965 wxPyEndAllowThreads(__tstate);
4966 if (PyErr_Occurred()) SWIG_fail;
4967 }
4968 resultobj = SWIG_Py_Void();
4969 return resultobj;
4970fail:
4971 return NULL;
4972}
4973
4974
4975SWIGINTERN PyObject *XmlProperty_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4976 PyObject *obj;
4977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4978 SWIG_TypeNewClientData(SWIGTYPE_p_wxXmlProperty, SWIG_NewClientData(obj));
4979 return SWIG_Py_Void();
4980}
4981
4982SWIGINTERN PyObject *XmlProperty_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4983 return SWIG_Python_InitShadowInstance(args);
4984}
4985
4986SWIGINTERN PyObject *_wrap_new_XmlNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4987 PyObject *resultobj = 0;
4988 wxXmlNode *arg1 = (wxXmlNode *) NULL ;
4989 wxXmlNodeType arg2 = (wxXmlNodeType) 0 ;
4990 wxString const &arg3_defvalue = wxPyEmptyString ;
4991 wxString *arg3 = (wxString *) &arg3_defvalue ;
4992 wxString const &arg4_defvalue = wxPyEmptyString ;
4993 wxString *arg4 = (wxString *) &arg4_defvalue ;
4994 wxXmlProperty *arg5 = (wxXmlProperty *) NULL ;
4995 wxXmlNode *arg6 = (wxXmlNode *) NULL ;
4996 wxXmlNode *result = 0 ;
4997 void *argp1 = 0 ;
4998 int res1 = 0 ;
4999 int val2 ;
5000 int ecode2 = 0 ;
5001 bool temp3 = false ;
5002 bool temp4 = false ;
5003 void *argp5 = 0 ;
5004 int res5 = 0 ;
5005 void *argp6 = 0 ;
5006 int res6 = 0 ;
5007 PyObject * obj0 = 0 ;
5008 PyObject * obj1 = 0 ;
5009 PyObject * obj2 = 0 ;
5010 PyObject * obj3 = 0 ;
5011 PyObject * obj4 = 0 ;
5012 PyObject * obj5 = 0 ;
5013 char * kwnames[] = {
5014 (char *) "parent",(char *) "type",(char *) "name",(char *) "content",(char *) "props",(char *) "next", NULL
5015 };
5016
5017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_XmlNode",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
5018 if (obj0) {
5019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5020 if (!SWIG_IsOK(res1)) {
5021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_XmlNode" "', expected argument " "1"" of type '" "wxXmlNode *""'");
2ef75293 5022 }
0085ce49
RD		 5023 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5024 }
5025 if (obj1) {
5026 ecode2 = SWIG_AsVal_int(obj1, &val2);
5027 if (!SWIG_IsOK(ecode2)) {
5028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_XmlNode" "', expected argument " "2"" of type '" "wxXmlNodeType""'");
5029 }
5030 arg2 = static_cast< wxXmlNodeType >(val2);
5031 }
5032 if (obj2) {
2ef75293 5033 {
0085ce49
RD		 5034 arg3 = wxString_in_helper(obj2);
5035 if (arg3 == NULL) SWIG_fail;
5036 temp3 = true;
2ef75293 5037 }
0085ce49
RD		 5038 }
5039 if (obj3) {
2ef75293 5040 {
0085ce49
RD		 5041 arg4 = wxString_in_helper(obj3);
5042 if (arg4 == NULL) SWIG_fail;
5043 temp4 = true;
2ef75293 5044 }
0085ce49
RD		 5045 }
5046 if (obj4) {
5047 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
5048 if (!SWIG_IsOK(res5)) {
5049 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_XmlNode" "', expected argument " "5"" of type '" "wxXmlProperty *""'");
5050 }
5051 arg5 = reinterpret_cast< wxXmlProperty * >(argp5);
5052 }
5053 if (obj5) {
5054 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5055 if (!SWIG_IsOK(res6)) {
5056 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_XmlNode" "', expected argument " "6"" of type '" "wxXmlNode *""'");
5057 }
5058 arg6 = reinterpret_cast< wxXmlNode * >(argp6);
5059 }
5060 {
5061 PyThreadState* __tstate = wxPyBeginAllowThreads();
5062 result = (wxXmlNode *)new wxXmlNode(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
5063 wxPyEndAllowThreads(__tstate);
5064 if (PyErr_Occurred()) SWIG_fail;
5065 }
5066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlNode, SWIG_POINTER_NEW | 0 );
5067 {
5068 if (temp3)
5069 delete arg3;
5070 }
5071 {
5072 if (temp4)
5073 delete arg4;
5074 }
5075 return resultobj;
5076fail:
5077 {
5078 if (temp3)
5079 delete arg3;
5080 }
5081 {
5082 if (temp4)
5083 delete arg4;
5084 }
5085 return NULL;
2ef75293
RD		 5086}
5087
5088
0085ce49
RD		 5089SWIGINTERN PyObject *_wrap_delete_XmlNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5090 PyObject *resultobj = 0;
5091 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5092 void *argp1 = 0 ;
5093 int res1 = 0 ;
5094 PyObject *swig_obj[1] ;
5095
5096 if (!args) SWIG_fail;
5097 swig_obj[0] = args;
5098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlNode, SWIG_POINTER_DISOWN | 0 );
5099 if (!SWIG_IsOK(res1)) {
5100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XmlNode" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5101 }
5102 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5103 {
5104 PyThreadState* __tstate = wxPyBeginAllowThreads();
5105 delete arg1;
2ef75293 5106
0085ce49
RD		 5107 wxPyEndAllowThreads(__tstate);
5108 if (PyErr_Occurred()) SWIG_fail;
5109 }
5110 resultobj = SWIG_Py_Void();
5111 return resultobj;
5112fail:
5113 return NULL;
5114}
5115
5116
5117SWIGINTERN PyObject *_wrap_new_XmlNodeEasy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5118 PyObject *resultobj = 0;
5119 wxXmlNodeType arg1 ;
5120 wxString *arg2 = 0 ;
5121 wxString const &arg3_defvalue = wxPyEmptyString ;
5122 wxString *arg3 = (wxString *) &arg3_defvalue ;
5123 wxXmlNode *result = 0 ;
5124 int val1 ;
5125 int ecode1 = 0 ;
5126 bool temp2 = false ;
5127 bool temp3 = false ;
5128 PyObject * obj0 = 0 ;
5129 PyObject * obj1 = 0 ;
5130 PyObject * obj2 = 0 ;
5131 char * kwnames[] = {
5132 (char *) "type",(char *) "name",(char *) "content", NULL
5133 };
5134
5135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_XmlNodeEasy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5136 ecode1 = SWIG_AsVal_int(obj0, &val1);
5137 if (!SWIG_IsOK(ecode1)) {
5138 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_XmlNodeEasy" "', expected argument " "1"" of type '" "wxXmlNodeType""'");
5139 }
5140 arg1 = static_cast< wxXmlNodeType >(val1);
5141 {
5142 arg2 = wxString_in_helper(obj1);
5143 if (arg2 == NULL) SWIG_fail;
5144 temp2 = true;
5145 }
5146 if (obj2) {
2ef75293 5147 {
0085ce49
RD		 5148 arg3 = wxString_in_helper(obj2);
5149 if (arg3 == NULL) SWIG_fail;
5150 temp3 = true;
2ef75293 5151 }
0085ce49
RD		 5152 }
5153 {
5154 PyThreadState* __tstate = wxPyBeginAllowThreads();
5155 result = (wxXmlNode *)new wxXmlNode(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
5156 wxPyEndAllowThreads(__tstate);
5157 if (PyErr_Occurred()) SWIG_fail;
5158 }
5159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlNode, SWIG_POINTER_OWN | 0 );
5160 {
5161 if (temp2)
5162 delete arg2;
5163 }
5164 {
5165 if (temp3)
5166 delete arg3;
5167 }
5168 return resultobj;
5169fail:
5170 {
5171 if (temp2)
5172 delete arg2;
5173 }
5174 {
5175 if (temp3)
5176 delete arg3;
5177 }
5178 return NULL;
5179}
5180
5181
5182SWIGINTERN PyObject *_wrap_XmlNode_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5183 PyObject *resultobj = 0;
5184 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5185 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
5186 void *argp1 = 0 ;
5187 int res1 = 0 ;
5188 void *argp2 = 0 ;
5189 int res2 = 0 ;
5190 PyObject * obj0 = 0 ;
5191 PyObject * obj1 = 0 ;
5192 char * kwnames[] = {
5193 (char *) "self",(char *) "child", NULL
5194 };
5195
5196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
5197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5198 if (!SWIG_IsOK(res1)) {
5199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_AddChild" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5200 }
5201 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5202 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5203 if (!SWIG_IsOK(res2)) {
5204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlNode_AddChild" "', expected argument " "2"" of type '" "wxXmlNode *""'");
5205 }
5206 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
5207 {
5208 PyThreadState* __tstate = wxPyBeginAllowThreads();
5209 (arg1)->AddChild(arg2);
5210 wxPyEndAllowThreads(__tstate);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 resultobj = SWIG_Py_Void();
5214 return resultobj;
5215fail:
5216 return NULL;
5217}
5218
5219
5220SWIGINTERN PyObject *_wrap_XmlNode_InsertChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj = 0;
5222 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5223 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
5224 wxXmlNode *arg3 = (wxXmlNode *) 0 ;
5225 void *argp1 = 0 ;
5226 int res1 = 0 ;
5227 void *argp2 = 0 ;
5228 int res2 = 0 ;
5229 void *argp3 = 0 ;
5230 int res3 = 0 ;
5231 PyObject * obj0 = 0 ;
5232 PyObject * obj1 = 0 ;
5233 PyObject * obj2 = 0 ;
5234 char * kwnames[] = {
5235 (char *) "self",(char *) "child",(char *) "before_node", NULL
5236 };
5237
5238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlNode_InsertChild",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5240 if (!SWIG_IsOK(res1)) {
5241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_InsertChild" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5242 }
5243 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5244 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5245 if (!SWIG_IsOK(res2)) {
5246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlNode_InsertChild" "', expected argument " "2"" of type '" "wxXmlNode *""'");
5247 }
5248 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
5249 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5250 if (!SWIG_IsOK(res3)) {
5251 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlNode_InsertChild" "', expected argument " "3"" of type '" "wxXmlNode *""'");
5252 }
5253 arg3 = reinterpret_cast< wxXmlNode * >(argp3);
5254 {
5255 PyThreadState* __tstate = wxPyBeginAllowThreads();
5256 (arg1)->InsertChild(arg2,arg3);
5257 wxPyEndAllowThreads(__tstate);
5258 if (PyErr_Occurred()) SWIG_fail;
5259 }
5260 resultobj = SWIG_Py_Void();
5261 return resultobj;
5262fail:
5263 return NULL;
5264}
5265
5266
5267SWIGINTERN PyObject *_wrap_XmlNode_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5268 PyObject *resultobj = 0;
5269 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5270 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
5271 bool result;
5272 void *argp1 = 0 ;
5273 int res1 = 0 ;
5274 void *argp2 = 0 ;
5275 int res2 = 0 ;
5276 PyObject * obj0 = 0 ;
5277 PyObject * obj1 = 0 ;
5278 char * kwnames[] = {
5279 (char *) "self",(char *) "child", NULL
5280 };
5281
5282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
5283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5284 if (!SWIG_IsOK(res1)) {
5285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_RemoveChild" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5286 }
5287 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5288 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5289 if (!SWIG_IsOK(res2)) {
5290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlNode_RemoveChild" "', expected argument " "2"" of type '" "wxXmlNode *""'");
5291 }
5292 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
5293 {
5294 PyThreadState* __tstate = wxPyBeginAllowThreads();
5295 result = (bool)(arg1)->RemoveChild(arg2);
5296 wxPyEndAllowThreads(__tstate);
5297 if (PyErr_Occurred()) SWIG_fail;
5298 }
5299 {
5300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5301 }
5302 return resultobj;
5303fail:
5304 return NULL;
5305}
5306
5307
5308SWIGINTERN PyObject *_wrap_XmlNode_AddProperty(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5309 PyObject *resultobj = 0;
5310 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5311 wxXmlProperty *arg2 = (wxXmlProperty *) 0 ;
5312 void *argp1 = 0 ;
5313 int res1 = 0 ;
5314 void *argp2 = 0 ;
5315 int res2 = 0 ;
5316 PyObject * obj0 = 0 ;
5317 PyObject * obj1 = 0 ;
5318 char * kwnames[] = {
5319 (char *) "self",(char *) "prop", NULL
5320 };
5321
5322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_AddProperty",kwnames,&obj0,&obj1)) SWIG_fail;
5323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5324 if (!SWIG_IsOK(res1)) {
5325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_AddProperty" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5326 }
5327 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5328 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
5329 if (!SWIG_IsOK(res2)) {
5330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlNode_AddProperty" "', expected argument " "2"" of type '" "wxXmlProperty *""'");
5331 }
5332 arg2 = reinterpret_cast< wxXmlProperty * >(argp2);
5333 {
5334 PyThreadState* __tstate = wxPyBeginAllowThreads();
5335 (arg1)->AddProperty(arg2);
5336 wxPyEndAllowThreads(__tstate);
5337 if (PyErr_Occurred()) SWIG_fail;
5338 }
5339 resultobj = SWIG_Py_Void();
5340 return resultobj;
5341fail:
5342 return NULL;
5343}
5344
5345
5346SWIGINTERN PyObject *_wrap_XmlNode_AddPropertyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5347 PyObject *resultobj = 0;
5348 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5349 wxString *arg2 = 0 ;
5350 wxString *arg3 = 0 ;
5351 void *argp1 = 0 ;
5352 int res1 = 0 ;
5353 bool temp2 = false ;
5354 bool temp3 = false ;
5355 PyObject * obj0 = 0 ;
5356 PyObject * obj1 = 0 ;
5357 PyObject * obj2 = 0 ;
5358 char * kwnames[] = {
5359 (char *) "self",(char *) "name",(char *) "value", NULL
5360 };
5361
5362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlNode_AddPropertyName",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5364 if (!SWIG_IsOK(res1)) {
5365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_AddPropertyName" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5366 }
5367 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5368 {
5369 arg2 = wxString_in_helper(obj1);
5370 if (arg2 == NULL) SWIG_fail;
5371 temp2 = true;
5372 }
5373 {
5374 arg3 = wxString_in_helper(obj2);
5375 if (arg3 == NULL) SWIG_fail;
5376 temp3 = true;
5377 }
5378 {
5379 PyThreadState* __tstate = wxPyBeginAllowThreads();
5380 (arg1)->AddProperty((wxString const &)*arg2,(wxString const &)*arg3);
5381 wxPyEndAllowThreads(__tstate);
5382 if (PyErr_Occurred()) SWIG_fail;
5383 }
5384 resultobj = SWIG_Py_Void();
5385 {
5386 if (temp2)
5387 delete arg2;
5388 }
5389 {
5390 if (temp3)
5391 delete arg3;
5392 }
5393 return resultobj;
5394fail:
5395 {
5396 if (temp2)
5397 delete arg2;
5398 }
5399 {
5400 if (temp3)
5401 delete arg3;
5402 }
5403 return NULL;
5404}
5405
5406
5407SWIGINTERN PyObject *_wrap_XmlNode_DeleteProperty(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5408 PyObject *resultobj = 0;
5409 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5410 wxString *arg2 = 0 ;
5411 bool result;
5412 void *argp1 = 0 ;
5413 int res1 = 0 ;
5414 bool temp2 = false ;
5415 PyObject * obj0 = 0 ;
5416 PyObject * obj1 = 0 ;
5417 char * kwnames[] = {
5418 (char *) "self",(char *) "name", NULL
5419 };
5420
5421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_DeleteProperty",kwnames,&obj0,&obj1)) SWIG_fail;
5422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5423 if (!SWIG_IsOK(res1)) {
5424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_DeleteProperty" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5425 }
5426 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5427 {
5428 arg2 = wxString_in_helper(obj1);
5429 if (arg2 == NULL) SWIG_fail;
5430 temp2 = true;
5431 }
5432 {
5433 PyThreadState* __tstate = wxPyBeginAllowThreads();
5434 result = (bool)(arg1)->DeleteProperty((wxString const &)*arg2);
5435 wxPyEndAllowThreads(__tstate);
5436 if (PyErr_Occurred()) SWIG_fail;
5437 }
5438 {
5439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5440 }
5441 {
5442 if (temp2)
5443 delete arg2;
5444 }
5445 return resultobj;
5446fail:
5447 {
5448 if (temp2)
5449 delete arg2;
5450 }
5451 return NULL;
2ef75293
RD		 5452}
5453
5454
0085ce49
RD		 5455SWIGINTERN PyObject *_wrap_XmlNode_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5456 PyObject *resultobj = 0;
5457 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5458 wxXmlNodeType result;
5459 void *argp1 = 0 ;
5460 int res1 = 0 ;
5461 PyObject *swig_obj[1] ;
5462
5463 if (!args) SWIG_fail;
5464 swig_obj[0] = args;
5465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5466 if (!SWIG_IsOK(res1)) {
5467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_GetType" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5468 }
5469 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5470 {
5471 PyThreadState* __tstate = wxPyBeginAllowThreads();
5472 result = (wxXmlNodeType)((wxXmlNode const *)arg1)->GetType();
5473 wxPyEndAllowThreads(__tstate);
5474 if (PyErr_Occurred()) SWIG_fail;
5475 }
5476 resultobj = SWIG_From_int(static_cast< int >(result));
5477 return resultobj;
5478fail:
5479 return NULL;
2ef75293
RD		 5480}
5481
5482
0085ce49
RD		 5483SWIGINTERN PyObject *_wrap_XmlNode_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5484 PyObject *resultobj = 0;
5485 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5486 wxString result;
5487 void *argp1 = 0 ;
5488 int res1 = 0 ;
5489 PyObject *swig_obj[1] ;
5490
5491 if (!args) SWIG_fail;
5492 swig_obj[0] = args;
5493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5494 if (!SWIG_IsOK(res1)) {
5495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_GetName" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5496 }
5497 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5498 {
5499 PyThreadState* __tstate = wxPyBeginAllowThreads();
5500 result = ((wxXmlNode const *)arg1)->GetName();
5501 wxPyEndAllowThreads(__tstate);
5502 if (PyErr_Occurred()) SWIG_fail;
5503 }
5504 {
2ef75293 5505#if wxUSE_UNICODE
0085ce49 5506 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
2ef75293 5507#else
0085ce49 5508 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
2ef75293 5509#endif
0085ce49
RD		 5510 }
5511 return resultobj;
5512fail:
5513 return NULL;
2ef75293
RD		 5514}
5515
5516
0085ce49
RD		 5517SWIGINTERN PyObject *_wrap_XmlNode_GetContent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5518 PyObject *resultobj = 0;
5519 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5520 wxString result;
5521 void *argp1 = 0 ;
5522 int res1 = 0 ;
5523 PyObject *swig_obj[1] ;
5524
5525 if (!args) SWIG_fail;
5526 swig_obj[0] = args;
5527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5528 if (!SWIG_IsOK(res1)) {
5529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_GetContent" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5530 }
5531 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5532 {
5533 PyThreadState* __tstate = wxPyBeginAllowThreads();
5534 result = ((wxXmlNode const *)arg1)->GetContent();
5535 wxPyEndAllowThreads(__tstate);
5536 if (PyErr_Occurred()) SWIG_fail;
5537 }
5538 {
2ef75293 5539#if wxUSE_UNICODE
0085ce49 5540 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
2ef75293 5541#else
0085ce49 5542 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
2ef75293 5543#endif
0085ce49
RD		 5544 }
5545 return resultobj;
5546fail:
5547 return NULL;
2ef75293
RD		 5548}
5549
5550
0085ce49
RD		 5551SWIGINTERN PyObject *_wrap_XmlNode_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5552 PyObject *resultobj = 0;
5553 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5554 wxXmlNode *result = 0 ;
5555 void *argp1 = 0 ;
5556 int res1 = 0 ;
5557 PyObject *swig_obj[1] ;
5558
5559 if (!args) SWIG_fail;
5560 swig_obj[0] = args;
5561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5562 if (!SWIG_IsOK(res1)) {
5563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_GetParent" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5564 }
5565 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5566 {
5567 PyThreadState* __tstate = wxPyBeginAllowThreads();
5568 result = (wxXmlNode *)((wxXmlNode const *)arg1)->GetParent();
5569 wxPyEndAllowThreads(__tstate);
5570 if (PyErr_Occurred()) SWIG_fail;
5571 }
5572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlNode, 0 | 0 );
5573 return resultobj;
5574fail:
5575 return NULL;
2ef75293
RD		 5576}
5577
5578
0085ce49
RD		 5579SWIGINTERN PyObject *_wrap_XmlNode_GetNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5580 PyObject *resultobj = 0;
5581 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5582 wxXmlNode *result = 0 ;
5583 void *argp1 = 0 ;
5584 int res1 = 0 ;
5585 PyObject *swig_obj[1] ;
5586
5587 if (!args) SWIG_fail;
5588 swig_obj[0] = args;
5589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5590 if (!SWIG_IsOK(res1)) {
5591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_GetNext" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5592 }
5593 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5594 {
5595 PyThreadState* __tstate = wxPyBeginAllowThreads();
5596 result = (wxXmlNode *)((wxXmlNode const *)arg1)->GetNext();
5597 wxPyEndAllowThreads(__tstate);
5598 if (PyErr_Occurred()) SWIG_fail;
5599 }
5600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlNode, 0 | 0 );
5601 return resultobj;
5602fail:
5603 return NULL;
2ef75293
RD		 5604}
5605
5606
0085ce49
RD		 5607SWIGINTERN PyObject *_wrap_XmlNode_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5608 PyObject *resultobj = 0;
5609 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5610 wxXmlNode *result = 0 ;
5611 void *argp1 = 0 ;
5612 int res1 = 0 ;
5613 PyObject *swig_obj[1] ;
5614
5615 if (!args) SWIG_fail;
5616 swig_obj[0] = args;
5617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5618 if (!SWIG_IsOK(res1)) {
5619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_GetChildren" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5620 }
5621 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5622 {
5623 PyThreadState* __tstate = wxPyBeginAllowThreads();
5624 result = (wxXmlNode *)((wxXmlNode const *)arg1)->GetChildren();
5625 wxPyEndAllowThreads(__tstate);
5626 if (PyErr_Occurred()) SWIG_fail;
5627 }
5628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlNode, 0 | 0 );
5629 return resultobj;
5630fail:
5631 return NULL;
2ef75293
RD		 5632}
5633
5634
0085ce49
RD		 5635SWIGINTERN PyObject *_wrap_XmlNode_GetProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5636 PyObject *resultobj = 0;
5637 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5638 wxXmlProperty *result = 0 ;
5639 void *argp1 = 0 ;
5640 int res1 = 0 ;
5641 PyObject *swig_obj[1] ;
5642
5643 if (!args) SWIG_fail;
5644 swig_obj[0] = args;
5645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5646 if (!SWIG_IsOK(res1)) {
5647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_GetProperties" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5648 }
5649 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5650 {
5651 PyThreadState* __tstate = wxPyBeginAllowThreads();
5652 result = (wxXmlProperty *)((wxXmlNode const *)arg1)->GetProperties();
5653 wxPyEndAllowThreads(__tstate);
5654 if (PyErr_Occurred()) SWIG_fail;
5655 }
5656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlProperty, 0 | 0 );
5657 return resultobj;
5658fail:
5659 return NULL;
5660}
5661
5662
5663SWIGINTERN PyObject *_wrap_XmlNode_GetPropVal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5664 PyObject *resultobj = 0;
5665 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5666 wxString *arg2 = 0 ;
5667 wxString *arg3 = 0 ;
5668 wxString result;
5669 void *argp1 = 0 ;
5670 int res1 = 0 ;
5671 bool temp2 = false ;
5672 bool temp3 = false ;
5673 PyObject * obj0 = 0 ;
5674 PyObject * obj1 = 0 ;
5675 PyObject * obj2 = 0 ;
5676 char * kwnames[] = {
5677 (char *) "self",(char *) "propName",(char *) "defaultVal", NULL
5678 };
5679
5680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlNode_GetPropVal",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5682 if (!SWIG_IsOK(res1)) {
5683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_GetPropVal" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5684 }
5685 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5686 {
5687 arg2 = wxString_in_helper(obj1);
5688 if (arg2 == NULL) SWIG_fail;
5689 temp2 = true;
5690 }
5691 {
5692 arg3 = wxString_in_helper(obj2);
5693 if (arg3 == NULL) SWIG_fail;
5694 temp3 = true;
5695 }
5696 {
5697 PyThreadState* __tstate = wxPyBeginAllowThreads();
5698 result = ((wxXmlNode const *)arg1)->GetPropVal((wxString const &)*arg2,(wxString const &)*arg3);
5699 wxPyEndAllowThreads(__tstate);
5700 if (PyErr_Occurred()) SWIG_fail;
5701 }
5702 {
5703#if wxUSE_UNICODE
5704 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5705#else
5706 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5707#endif
5708 }
5709 {
5710 if (temp2)
5711 delete arg2;
5712 }
5713 {
5714 if (temp3)
5715 delete arg3;
5716 }
5717 return resultobj;
5718fail:
5719 {
5720 if (temp2)
5721 delete arg2;
5722 }
5723 {
5724 if (temp3)
5725 delete arg3;
5726 }
5727 return NULL;
5728}
5729
5730
5731SWIGINTERN PyObject *_wrap_XmlNode_HasProp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5732 PyObject *resultobj = 0;
5733 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5734 wxString *arg2 = 0 ;
5735 bool result;
5736 void *argp1 = 0 ;
5737 int res1 = 0 ;
5738 bool temp2 = false ;
5739 PyObject * obj0 = 0 ;
5740 PyObject * obj1 = 0 ;
5741 char * kwnames[] = {
5742 (char *) "self",(char *) "propName", NULL
5743 };
5744
5745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_HasProp",kwnames,&obj0,&obj1)) SWIG_fail;
5746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5747 if (!SWIG_IsOK(res1)) {
5748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_HasProp" "', expected argument " "1"" of type '" "wxXmlNode const *""'");
5749 }
5750 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5751 {
5752 arg2 = wxString_in_helper(obj1);
5753 if (arg2 == NULL) SWIG_fail;
5754 temp2 = true;
5755 }
5756 {
5757 PyThreadState* __tstate = wxPyBeginAllowThreads();
5758 result = (bool)((wxXmlNode const *)arg1)->HasProp((wxString const &)*arg2);
5759 wxPyEndAllowThreads(__tstate);
5760 if (PyErr_Occurred()) SWIG_fail;
5761 }
5762 {
5763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5764 }
5765 {
5766 if (temp2)
5767 delete arg2;
5768 }
5769 return resultobj;
5770fail:
5771 {
5772 if (temp2)
5773 delete arg2;
5774 }
5775 return NULL;
5776}
5777
5778
5779SWIGINTERN PyObject *_wrap_XmlNode_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5780 PyObject *resultobj = 0;
5781 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5782 wxXmlNodeType arg2 ;
5783 void *argp1 = 0 ;
5784 int res1 = 0 ;
5785 int val2 ;
5786 int ecode2 = 0 ;
5787 PyObject * obj0 = 0 ;
5788 PyObject * obj1 = 0 ;
5789 char * kwnames[] = {
5790 (char *) "self",(char *) "type", NULL
5791 };
5792
5793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
5794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5795 if (!SWIG_IsOK(res1)) {
5796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_SetType" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5797 }
5798 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5799 ecode2 = SWIG_AsVal_int(obj1, &val2);
5800 if (!SWIG_IsOK(ecode2)) {
5801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XmlNode_SetType" "', expected argument " "2"" of type '" "wxXmlNodeType""'");
5802 }
5803 arg2 = static_cast< wxXmlNodeType >(val2);
5804 {
5805 PyThreadState* __tstate = wxPyBeginAllowThreads();
5806 (arg1)->SetType(arg2);
5807 wxPyEndAllowThreads(__tstate);
5808 if (PyErr_Occurred()) SWIG_fail;
5809 }
5810 resultobj = SWIG_Py_Void();
5811 return resultobj;
5812fail:
5813 return NULL;
5814}
5815
5816
5817SWIGINTERN PyObject *_wrap_XmlNode_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5818 PyObject *resultobj = 0;
5819 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5820 wxString *arg2 = 0 ;
5821 void *argp1 = 0 ;
5822 int res1 = 0 ;
5823 bool temp2 = false ;
5824 PyObject * obj0 = 0 ;
5825 PyObject * obj1 = 0 ;
5826 char * kwnames[] = {
5827 (char *) "self",(char *) "name", NULL
5828 };
5829
5830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
5831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5832 if (!SWIG_IsOK(res1)) {
5833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_SetName" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5834 }
5835 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5836 {
5837 arg2 = wxString_in_helper(obj1);
5838 if (arg2 == NULL) SWIG_fail;
5839 temp2 = true;
5840 }
5841 {
5842 PyThreadState* __tstate = wxPyBeginAllowThreads();
5843 (arg1)->SetName((wxString const &)*arg2);
5844 wxPyEndAllowThreads(__tstate);
5845 if (PyErr_Occurred()) SWIG_fail;
5846 }
5847 resultobj = SWIG_Py_Void();
5848 {
5849 if (temp2)
5850 delete arg2;
5851 }
5852 return resultobj;
5853fail:
5854 {
5855 if (temp2)
5856 delete arg2;
5857 }
5858 return NULL;
2ef75293
RD		 5859}
5860
5861
0085ce49
RD		 5862SWIGINTERN PyObject *_wrap_XmlNode_SetContent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5863 PyObject *resultobj = 0;
5864 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5865 wxString *arg2 = 0 ;
5866 void *argp1 = 0 ;
5867 int res1 = 0 ;
5868 bool temp2 = false ;
5869 PyObject * obj0 = 0 ;
5870 PyObject * obj1 = 0 ;
5871 char * kwnames[] = {
5872 (char *) "self",(char *) "con", NULL
5873 };
5874
5875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_SetContent",kwnames,&obj0,&obj1)) SWIG_fail;
5876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5877 if (!SWIG_IsOK(res1)) {
5878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_SetContent" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5879 }
5880 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5881 {
5882 arg2 = wxString_in_helper(obj1);
5883 if (arg2 == NULL) SWIG_fail;
5884 temp2 = true;
5885 }
5886 {
5887 PyThreadState* __tstate = wxPyBeginAllowThreads();
5888 (arg1)->SetContent((wxString const &)*arg2);
5889 wxPyEndAllowThreads(__tstate);
5890 if (PyErr_Occurred()) SWIG_fail;
5891 }
5892 resultobj = SWIG_Py_Void();
5893 {
5894 if (temp2)
5895 delete arg2;
5896 }
5897 return resultobj;
5898fail:
5899 {
5900 if (temp2)
5901 delete arg2;
5902 }
5903 return NULL;
5904}
5905
5906
5907SWIGINTERN PyObject *_wrap_XmlNode_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5908 PyObject *resultobj = 0;
5909 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5910 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
5911 void *argp1 = 0 ;
5912 int res1 = 0 ;
5913 void *argp2 = 0 ;
5914 int res2 = 0 ;
5915 PyObject * obj0 = 0 ;
5916 PyObject * obj1 = 0 ;
5917 char * kwnames[] = {
5918 (char *) "self",(char *) "parent", NULL
5919 };
5920
5921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
5922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5923 if (!SWIG_IsOK(res1)) {
5924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_SetParent" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5925 }
5926 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5927 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5928 if (!SWIG_IsOK(res2)) {
5929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlNode_SetParent" "', expected argument " "2"" of type '" "wxXmlNode *""'");
5930 }
5931 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
5932 {
5933 PyThreadState* __tstate = wxPyBeginAllowThreads();
5934 (arg1)->SetParent(arg2);
5935 wxPyEndAllowThreads(__tstate);
5936 if (PyErr_Occurred()) SWIG_fail;
5937 }
5938 resultobj = SWIG_Py_Void();
5939 return resultobj;
5940fail:
5941 return NULL;
5942}
5943
5944
5945SWIGINTERN PyObject *_wrap_XmlNode_SetNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5946 PyObject *resultobj = 0;
5947 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5948 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
5949 void *argp1 = 0 ;
5950 int res1 = 0 ;
5951 void *argp2 = 0 ;
5952 int res2 = 0 ;
5953 PyObject * obj0 = 0 ;
5954 PyObject * obj1 = 0 ;
5955 char * kwnames[] = {
5956 (char *) "self",(char *) "next", NULL
5957 };
5958
5959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_SetNext",kwnames,&obj0,&obj1)) SWIG_fail;
5960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5961 if (!SWIG_IsOK(res1)) {
5962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_SetNext" "', expected argument " "1"" of type '" "wxXmlNode *""'");
5963 }
5964 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
5965 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5966 if (!SWIG_IsOK(res2)) {
5967 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlNode_SetNext" "', expected argument " "2"" of type '" "wxXmlNode *""'");
5968 }
5969 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
5970 {
5971 PyThreadState* __tstate = wxPyBeginAllowThreads();
5972 (arg1)->SetNext(arg2);
5973 wxPyEndAllowThreads(__tstate);
5974 if (PyErr_Occurred()) SWIG_fail;
5975 }
5976 resultobj = SWIG_Py_Void();
5977 return resultobj;
5978fail:
5979 return NULL;
5980}
5981
5982
5983SWIGINTERN PyObject *_wrap_XmlNode_SetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5984 PyObject *resultobj = 0;
5985 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
5986 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
5987 void *argp1 = 0 ;
5988 int res1 = 0 ;
5989 void *argp2 = 0 ;
5990 int res2 = 0 ;
5991 PyObject * obj0 = 0 ;
5992 PyObject * obj1 = 0 ;
5993 char * kwnames[] = {
5994 (char *) "self",(char *) "child", NULL
5995 };
5996
5997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_SetChildren",kwnames,&obj0,&obj1)) SWIG_fail;
5998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
5999 if (!SWIG_IsOK(res1)) {
6000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_SetChildren" "', expected argument " "1"" of type '" "wxXmlNode *""'");
6001 }
6002 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
6003 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
6004 if (!SWIG_IsOK(res2)) {
6005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlNode_SetChildren" "', expected argument " "2"" of type '" "wxXmlNode *""'");
6006 }
6007 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
6008 {
6009 PyThreadState* __tstate = wxPyBeginAllowThreads();
6010 (arg1)->SetChildren(arg2);
6011 wxPyEndAllowThreads(__tstate);
6012 if (PyErr_Occurred()) SWIG_fail;
6013 }
6014 resultobj = SWIG_Py_Void();
6015 return resultobj;
6016fail:
6017 return NULL;
6018}
6019
6020
6021SWIGINTERN PyObject *_wrap_XmlNode_SetProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6022 PyObject *resultobj = 0;
6023 wxXmlNode *arg1 = (wxXmlNode *) 0 ;
6024 wxXmlProperty *arg2 = (wxXmlProperty *) 0 ;
6025 void *argp1 = 0 ;
6026 int res1 = 0 ;
6027 void *argp2 = 0 ;
6028 int res2 = 0 ;
6029 PyObject * obj0 = 0 ;
6030 PyObject * obj1 = 0 ;
6031 char * kwnames[] = {
6032 (char *) "self",(char *) "prop", NULL
6033 };
6034
6035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlNode_SetProperties",kwnames,&obj0,&obj1)) SWIG_fail;
6036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlNode, 0 | 0 );
6037 if (!SWIG_IsOK(res1)) {
6038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlNode_SetProperties" "', expected argument " "1"" of type '" "wxXmlNode *""'");
6039 }
6040 arg1 = reinterpret_cast< wxXmlNode * >(argp1);
6041 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlProperty, 0 | 0 );
6042 if (!SWIG_IsOK(res2)) {
6043 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlNode_SetProperties" "', expected argument " "2"" of type '" "wxXmlProperty *""'");
6044 }
6045 arg2 = reinterpret_cast< wxXmlProperty * >(argp2);
6046 {
6047 PyThreadState* __tstate = wxPyBeginAllowThreads();
6048 (arg1)->SetProperties(arg2);
6049 wxPyEndAllowThreads(__tstate);
6050 if (PyErr_Occurred()) SWIG_fail;
6051 }
6052 resultobj = SWIG_Py_Void();
6053 return resultobj;
6054fail:
6055 return NULL;
2ef75293
RD		 6056}
6057
6058
0085ce49
RD		 6059SWIGINTERN PyObject *XmlNode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6060 PyObject *obj;
6061 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6062 SWIG_TypeNewClientData(SWIGTYPE_p_wxXmlNode, SWIG_NewClientData(obj));
6063 return SWIG_Py_Void();
2ef75293
RD		 6064}
6065
0085ce49
RD		 6066SWIGINTERN PyObject *XmlNode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6067 return SWIG_Python_InitShadowInstance(args);
2ef75293
RD		 6068}
6069
0085ce49
RD		 6070SWIGINTERN PyObject *_wrap_new_XmlDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6071 PyObject *resultobj = 0;
6072 wxString *arg1 = 0 ;
6073 wxString const &arg2_defvalue = wxPyUTF8String ;
6074 wxString *arg2 = (wxString *) &arg2_defvalue ;
6075 wxXmlDocument *result = 0 ;
6076 bool temp1 = false ;
6077 bool temp2 = false ;
6078 PyObject * obj0 = 0 ;
6079 PyObject * obj1 = 0 ;
6080 char * kwnames[] = {
6081 (char *) "filename",(char *) "encoding", NULL
6082 };
6083
6084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_XmlDocument",kwnames,&obj0,&obj1)) SWIG_fail;
6085 {
6086 arg1 = wxString_in_helper(obj0);
6087 if (arg1 == NULL) SWIG_fail;
6088 temp1 = true;
6089 }
6090 if (obj1) {
2ef75293 6091 {
0085ce49
RD		 6092 arg2 = wxString_in_helper(obj1);
6093 if (arg2 == NULL) SWIG_fail;
6094 temp2 = true;
2ef75293 6095 }
0085ce49
RD		 6096 }
6097 {
6098 PyThreadState* __tstate = wxPyBeginAllowThreads();
6099 result = (wxXmlDocument *)new wxXmlDocument((wxString const &)*arg1,(wxString const &)*arg2);
6100 wxPyEndAllowThreads(__tstate);
6101 if (PyErr_Occurred()) SWIG_fail;
6102 }
6103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_NEW | 0 );
6104 {
6105 if (temp1)
6106 delete arg1;
6107 }
6108 {
6109 if (temp2)
6110 delete arg2;
6111 }
6112 return resultobj;
6113fail:
6114 {
6115 if (temp1)
6116 delete arg1;
6117 }
6118 {
6119 if (temp2)
6120 delete arg2;
6121 }
6122 return NULL;
6123}
6124
6125
6126SWIGINTERN PyObject *_wrap_new_XmlDocumentFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6127 PyObject *resultobj = 0;
6128 wxInputStream *arg1 = 0 ;
6129 wxString const &arg2_defvalue = wxPyUTF8String ;
6130 wxString *arg2 = (wxString *) &arg2_defvalue ;
6131 wxXmlDocument *result = 0 ;
6132 wxPyInputStream *temp1 ;
6133 bool created1 ;
6134 bool temp2 = false ;
6135 PyObject * obj0 = 0 ;
6136 PyObject * obj1 = 0 ;
6137 char * kwnames[] = {
6138 (char *) "stream",(char *) "encoding", NULL
6139 };
6140
6141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_XmlDocumentFromStream",kwnames,&obj0,&obj1)) SWIG_fail;
6142 {
6143 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
6144 arg1 = temp1->m_wxis;
6145 created1 = false;
6146 } else {
6147 PyErr_Clear(); // clear the failure of the wxPyConvert above
6148 arg1 = wxPyCBInputStream_create(obj0, false);
6149 if (arg1 == NULL) {
6150 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
6151 SWIG_fail;
6152 }
6153 created1 = true;
2ef75293 6154 }
0085ce49
RD		 6155 }
6156 if (obj1) {
2ef75293 6157 {
0085ce49
RD		 6158 arg2 = wxString_in_helper(obj1);
6159 if (arg2 == NULL) SWIG_fail;
6160 temp2 = true;
2ef75293 6161 }
0085ce49
RD		 6162 }
6163 {
6164 PyThreadState* __tstate = wxPyBeginAllowThreads();
6165 result = (wxXmlDocument *)new wxXmlDocument(*arg1,(wxString const &)*arg2);
6166 wxPyEndAllowThreads(__tstate);
6167 if (PyErr_Occurred()) SWIG_fail;
6168 }
6169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_OWN | 0 );
6170 {
6171 if (created1) delete arg1;
6172 }
6173 {
6174 if (temp2)
6175 delete arg2;
6176 }
6177 return resultobj;
6178fail:
6179 {
6180 if (created1) delete arg1;
6181 }
6182 {
6183 if (temp2)
6184 delete arg2;
6185 }
6186 return NULL;
2ef75293
RD		 6187}
6188
6189
0085ce49
RD		 6190SWIGINTERN PyObject *_wrap_new_EmptyXmlDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6191 PyObject *resultobj = 0;
6192 wxXmlDocument *result = 0 ;
6193
6194 if (!SWIG_Python_UnpackTuple(args,"new_EmptyXmlDocument",0,0,0)) SWIG_fail;
6195 {
6196 PyThreadState* __tstate = wxPyBeginAllowThreads();
6197 result = (wxXmlDocument *)new wxXmlDocument();
6198 wxPyEndAllowThreads(__tstate);
6199 if (PyErr_Occurred()) SWIG_fail;
6200 }
6201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_OWN | 0 );
6202 return resultobj;
6203fail:
6204 return NULL;
2ef75293
RD		 6205}
6206
6207
0085ce49
RD		 6208SWIGINTERN PyObject *_wrap_delete_XmlDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6209 PyObject *resultobj = 0;
6210 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6211 void *argp1 = 0 ;
6212 int res1 = 0 ;
6213 PyObject *swig_obj[1] ;
6214
6215 if (!args) SWIG_fail;
6216 swig_obj[0] = args;
6217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlDocument, SWIG_POINTER_DISOWN | 0 );
6218 if (!SWIG_IsOK(res1)) {
6219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XmlDocument" "', expected argument " "1"" of type '" "wxXmlDocument *""'");
6220 }
6221 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6222 {
6223 PyThreadState* __tstate = wxPyBeginAllowThreads();
6224 delete arg1;
2ef75293 6225
0085ce49
RD		 6226 wxPyEndAllowThreads(__tstate);
6227 if (PyErr_Occurred()) SWIG_fail;
6228 }
6229 resultobj = SWIG_Py_Void();
6230 return resultobj;
6231fail:
6232 return NULL;
6233}
6234
6235
6236SWIGINTERN PyObject *_wrap_XmlDocument_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6237 PyObject *resultobj = 0;
6238 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6239 wxString *arg2 = 0 ;
6240 wxString const &arg3_defvalue = wxPyUTF8String ;
6241 wxString *arg3 = (wxString *) &arg3_defvalue ;
6242 bool result;
6243 void *argp1 = 0 ;
6244 int res1 = 0 ;
6245 bool temp2 = false ;
6246 bool temp3 = false ;
6247 PyObject * obj0 = 0 ;
6248 PyObject * obj1 = 0 ;
6249 PyObject * obj2 = 0 ;
6250 char * kwnames[] = {
6251 (char *) "self",(char *) "filename",(char *) "encoding", NULL
6252 };
6253
6254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlDocument_Load",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6256 if (!SWIG_IsOK(res1)) {
6257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_Load" "', expected argument " "1"" of type '" "wxXmlDocument *""'");
6258 }
6259 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6260 {
6261 arg2 = wxString_in_helper(obj1);
6262 if (arg2 == NULL) SWIG_fail;
6263 temp2 = true;
6264 }
6265 if (obj2) {
2ef75293 6266 {
0085ce49
RD		 6267 arg3 = wxString_in_helper(obj2);
6268 if (arg3 == NULL) SWIG_fail;
6269 temp3 = true;
6270 }
6271 }
6272 {
6273 PyThreadState* __tstate = wxPyBeginAllowThreads();
6274 result = (bool)(arg1)->Load((wxString const &)*arg2,(wxString const &)*arg3);
6275 wxPyEndAllowThreads(__tstate);
6276 if (PyErr_Occurred()) SWIG_fail;
6277 }
6278 {
6279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6280 }
6281 {
6282 if (temp2)
6283 delete arg2;
6284 }
6285 {
6286 if (temp3)
6287 delete arg3;
6288 }
6289 return resultobj;
6290fail:
6291 {
6292 if (temp2)
6293 delete arg2;
6294 }
6295 {
6296 if (temp3)
6297 delete arg3;
6298 }
6299 return NULL;
6300}
6301
6302
6303SWIGINTERN PyObject *_wrap_XmlDocument_LoadFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6304 PyObject *resultobj = 0;
6305 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6306 wxInputStream *arg2 = 0 ;
6307 wxString const &arg3_defvalue = wxPyUTF8String ;
6308 wxString *arg3 = (wxString *) &arg3_defvalue ;
6309 bool result;
6310 void *argp1 = 0 ;
6311 int res1 = 0 ;
6312 wxPyInputStream *temp2 ;
6313 bool created2 ;
6314 bool temp3 = false ;
6315 PyObject * obj0 = 0 ;
6316 PyObject * obj1 = 0 ;
6317 PyObject * obj2 = 0 ;
6318 char * kwnames[] = {
6319 (char *) "self",(char *) "stream",(char *) "encoding", NULL
6320 };
6321
6322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlDocument_LoadFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6324 if (!SWIG_IsOK(res1)) {
6325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_LoadFromStream" "', expected argument " "1"" of type '" "wxXmlDocument *""'");
6326 }
6327 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6328 {
6329 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
6330 arg2 = temp2->m_wxis;
6331 created2 = false;
6332 } else {
6333 PyErr_Clear(); // clear the failure of the wxPyConvert above
6334 arg2 = wxPyCBInputStream_create(obj1, false);
6335 if (arg2 == NULL) {
6336 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
6337 SWIG_fail;
6338 }
6339 created2 = true;
2ef75293 6340 }
0085ce49
RD		 6341 }
6342 if (obj2) {
2ef75293 6343 {
0085ce49
RD		 6344 arg3 = wxString_in_helper(obj2);
6345 if (arg3 == NULL) SWIG_fail;
6346 temp3 = true;
2ef75293 6347 }
0085ce49
RD		 6348 }
6349 {
6350 PyThreadState* __tstate = wxPyBeginAllowThreads();
6351 result = (bool)(arg1)->Load(*arg2,(wxString const &)*arg3);
6352 wxPyEndAllowThreads(__tstate);
6353 if (PyErr_Occurred()) SWIG_fail;
6354 }
6355 {
6356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6357 }
6358 {
6359 if (created2) delete arg2;
6360 }
6361 {
6362 if (temp3)
6363 delete arg3;
6364 }
6365 return resultobj;
6366fail:
6367 {
6368 if (created2) delete arg2;
6369 }
6370 {
6371 if (temp3)
6372 delete arg3;
6373 }
6374 return NULL;
6375}
6376
6377
6378SWIGINTERN PyObject *_wrap_XmlDocument_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6379 PyObject *resultobj = 0;
6380 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6381 wxString *arg2 = 0 ;
6382 bool result;
6383 void *argp1 = 0 ;
6384 int res1 = 0 ;
6385 bool temp2 = false ;
6386 PyObject * obj0 = 0 ;
6387 PyObject * obj1 = 0 ;
6388 char * kwnames[] = {
6389 (char *) "self",(char *) "filename", NULL
6390 };
6391
6392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlDocument_Save",kwnames,&obj0,&obj1)) SWIG_fail;
6393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6394 if (!SWIG_IsOK(res1)) {
6395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_Save" "', expected argument " "1"" of type '" "wxXmlDocument const *""'");
6396 }
6397 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6398 {
6399 arg2 = wxString_in_helper(obj1);
6400 if (arg2 == NULL) SWIG_fail;
6401 temp2 = true;
6402 }
6403 {
6404 PyThreadState* __tstate = wxPyBeginAllowThreads();
6405 result = (bool)((wxXmlDocument const *)arg1)->Save((wxString const &)*arg2);
6406 wxPyEndAllowThreads(__tstate);
6407 if (PyErr_Occurred()) SWIG_fail;
6408 }
6409 {
6410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6411 }
6412 {
6413 if (temp2)
6414 delete arg2;
6415 }
6416 return resultobj;
6417fail:
6418 {
6419 if (temp2)
6420 delete arg2;
6421 }
6422 return NULL;
6423}
6424
6425
6426SWIGINTERN PyObject *_wrap_XmlDocument_SaveToStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6427 PyObject *resultobj = 0;
6428 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6429 wxOutputStream *arg2 = 0 ;
6430 bool result;
6431 void *argp1 = 0 ;
6432 int res1 = 0 ;
6433 void *argp2 = 0 ;
6434 int res2 = 0 ;
6435 PyObject * obj0 = 0 ;
6436 PyObject * obj1 = 0 ;
6437 char * kwnames[] = {
6438 (char *) "self",(char *) "stream", NULL
6439 };
6440
6441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlDocument_SaveToStream",kwnames,&obj0,&obj1)) SWIG_fail;
6442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6443 if (!SWIG_IsOK(res1)) {
6444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_SaveToStream" "', expected argument " "1"" of type '" "wxXmlDocument const *""'");
6445 }
6446 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6447 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxOutputStream, 0 );
6448 if (!SWIG_IsOK(res2)) {
6449 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlDocument_SaveToStream" "', expected argument " "2"" of type '" "wxOutputStream &""'");
6450 }
6451 if (!argp2) {
6452 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XmlDocument_SaveToStream" "', expected argument " "2"" of type '" "wxOutputStream &""'");
6453 }
6454 arg2 = reinterpret_cast< wxOutputStream * >(argp2);
6455 {
6456 PyThreadState* __tstate = wxPyBeginAllowThreads();
6457 result = (bool)((wxXmlDocument const *)arg1)->Save(*arg2);
6458 wxPyEndAllowThreads(__tstate);
6459 if (PyErr_Occurred()) SWIG_fail;
6460 }
6461 {
6462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6463 }
6464 return resultobj;
6465fail:
6466 return NULL;
2ef75293
RD		 6467}
6468
6469
0085ce49
RD		 6470SWIGINTERN PyObject *_wrap_XmlDocument_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6471 PyObject *resultobj = 0;
6472 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6473 bool result;
6474 void *argp1 = 0 ;
6475 int res1 = 0 ;
6476 PyObject *swig_obj[1] ;
6477
6478 if (!args) SWIG_fail;
6479 swig_obj[0] = args;
6480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6481 if (!SWIG_IsOK(res1)) {
6482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_IsOk" "', expected argument " "1"" of type '" "wxXmlDocument const *""'");
6483 }
6484 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6485 {
6486 PyThreadState* __tstate = wxPyBeginAllowThreads();
6487 result = (bool)((wxXmlDocument const *)arg1)->IsOk();
6488 wxPyEndAllowThreads(__tstate);
6489 if (PyErr_Occurred()) SWIG_fail;
6490 }
6491 {
6492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6493 }
6494 return resultobj;
6495fail:
6496 return NULL;
2ef75293
RD		 6497}
6498
6499
0085ce49
RD		 6500SWIGINTERN PyObject *_wrap_XmlDocument_GetRoot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6501 PyObject *resultobj = 0;
6502 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6503 wxXmlNode *result = 0 ;
6504 void *argp1 = 0 ;
6505 int res1 = 0 ;
6506 PyObject *swig_obj[1] ;
6507
6508 if (!args) SWIG_fail;
6509 swig_obj[0] = args;
6510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6511 if (!SWIG_IsOK(res1)) {
6512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_GetRoot" "', expected argument " "1"" of type '" "wxXmlDocument const *""'");
6513 }
6514 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6515 {
6516 PyThreadState* __tstate = wxPyBeginAllowThreads();
6517 result = (wxXmlNode *)((wxXmlDocument const *)arg1)->GetRoot();
6518 wxPyEndAllowThreads(__tstate);
6519 if (PyErr_Occurred()) SWIG_fail;
6520 }
6521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlNode, 0 | 0 );
6522 return resultobj;
6523fail:
6524 return NULL;
2ef75293
RD		 6525}
6526
6527
0085ce49
RD		 6528SWIGINTERN PyObject *_wrap_XmlDocument_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6529 PyObject *resultobj = 0;
6530 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6531 wxString result;
6532 void *argp1 = 0 ;
6533 int res1 = 0 ;
6534 PyObject *swig_obj[1] ;
6535
6536 if (!args) SWIG_fail;
6537 swig_obj[0] = args;
6538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6539 if (!SWIG_IsOK(res1)) {
6540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_GetVersion" "', expected argument " "1"" of type '" "wxXmlDocument const *""'");
6541 }
6542 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6543 {
6544 PyThreadState* __tstate = wxPyBeginAllowThreads();
6545 result = ((wxXmlDocument const *)arg1)->GetVersion();
6546 wxPyEndAllowThreads(__tstate);
6547 if (PyErr_Occurred()) SWIG_fail;
6548 }
6549 {
2ef75293 6550#if wxUSE_UNICODE
0085ce49 6551 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
2ef75293 6552#else
0085ce49 6553 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
2ef75293 6554#endif
0085ce49
RD		 6555 }
6556 return resultobj;
6557fail:
6558 return NULL;
2ef75293
RD		 6559}
6560
6561
0085ce49
RD		 6562SWIGINTERN PyObject *_wrap_XmlDocument_GetFileEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6563 PyObject *resultobj = 0;
6564 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6565 wxString result;
6566 void *argp1 = 0 ;
6567 int res1 = 0 ;
6568 PyObject *swig_obj[1] ;
6569
6570 if (!args) SWIG_fail;
6571 swig_obj[0] = args;
6572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6573 if (!SWIG_IsOK(res1)) {
6574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_GetFileEncoding" "', expected argument " "1"" of type '" "wxXmlDocument const *""'");
6575 }
6576 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6577 {
6578 PyThreadState* __tstate = wxPyBeginAllowThreads();
6579 result = ((wxXmlDocument const *)arg1)->GetFileEncoding();
6580 wxPyEndAllowThreads(__tstate);
6581 if (PyErr_Occurred()) SWIG_fail;
6582 }
6583 {
2ef75293 6584#if wxUSE_UNICODE
0085ce49 6585 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
2ef75293 6586#else
0085ce49 6587 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
2ef75293 6588#endif
0085ce49
RD		 6589 }
6590 return resultobj;
6591fail:
6592 return NULL;
6593}
6594
6595
6596SWIGINTERN PyObject *_wrap_XmlDocument_SetRoot(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6597 PyObject *resultobj = 0;
6598 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6599 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
6600 void *argp1 = 0 ;
6601 int res1 = 0 ;
6602 void *argp2 = 0 ;
6603 int res2 = 0 ;
6604 PyObject * obj0 = 0 ;
6605 PyObject * obj1 = 0 ;
6606 char * kwnames[] = {
6607 (char *) "self",(char *) "node", NULL
6608 };
6609
6610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlDocument_SetRoot",kwnames,&obj0,&obj1)) SWIG_fail;
6611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6612 if (!SWIG_IsOK(res1)) {
6613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_SetRoot" "', expected argument " "1"" of type '" "wxXmlDocument *""'");
6614 }
6615 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6616 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
6617 if (!SWIG_IsOK(res2)) {
6618 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlDocument_SetRoot" "', expected argument " "2"" of type '" "wxXmlNode *""'");
6619 }
6620 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
6621 {
6622 PyThreadState* __tstate = wxPyBeginAllowThreads();
6623 (arg1)->SetRoot(arg2);
6624 wxPyEndAllowThreads(__tstate);
6625 if (PyErr_Occurred()) SWIG_fail;
6626 }
6627 resultobj = SWIG_Py_Void();
6628 return resultobj;
6629fail:
6630 return NULL;
6631}
6632
6633
6634SWIGINTERN PyObject *_wrap_XmlDocument_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6635 PyObject *resultobj = 0;
6636 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6637 wxString *arg2 = 0 ;
6638 void *argp1 = 0 ;
6639 int res1 = 0 ;
6640 bool temp2 = false ;
6641 PyObject * obj0 = 0 ;
6642 PyObject * obj1 = 0 ;
6643 char * kwnames[] = {
6644 (char *) "self",(char *) "version", NULL
6645 };
6646
6647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlDocument_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
6648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6649 if (!SWIG_IsOK(res1)) {
6650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_SetVersion" "', expected argument " "1"" of type '" "wxXmlDocument *""'");
6651 }
6652 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6653 {
6654 arg2 = wxString_in_helper(obj1);
6655 if (arg2 == NULL) SWIG_fail;
6656 temp2 = true;
6657 }
6658 {
6659 PyThreadState* __tstate = wxPyBeginAllowThreads();
6660 (arg1)->SetVersion((wxString const &)*arg2);
6661 wxPyEndAllowThreads(__tstate);
6662 if (PyErr_Occurred()) SWIG_fail;
6663 }
6664 resultobj = SWIG_Py_Void();
6665 {
6666 if (temp2)
6667 delete arg2;
6668 }
6669 return resultobj;
6670fail:
6671 {
6672 if (temp2)
6673 delete arg2;
6674 }
6675 return NULL;
2ef75293
RD		 6676}
6677
6678
0085ce49
RD		 6679SWIGINTERN PyObject *_wrap_XmlDocument_SetFileEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6680 PyObject *resultobj = 0;
6681 wxXmlDocument *arg1 = (wxXmlDocument *) 0 ;
6682 wxString *arg2 = 0 ;
6683 void *argp1 = 0 ;
6684 int res1 = 0 ;
6685 bool temp2 = false ;
6686 PyObject * obj0 = 0 ;
6687 PyObject * obj1 = 0 ;
6688 char * kwnames[] = {
6689 (char *) "self",(char *) "encoding", NULL
6690 };
6691
6692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlDocument_SetFileEncoding",kwnames,&obj0,&obj1)) SWIG_fail;
6693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxXmlDocument, 0 | 0 );
6694 if (!SWIG_IsOK(res1)) {
6695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlDocument_SetFileEncoding" "', expected argument " "1"" of type '" "wxXmlDocument *""'");
6696 }
6697 arg1 = reinterpret_cast< wxXmlDocument * >(argp1);
6698 {
6699 arg2 = wxString_in_helper(obj1);
6700 if (arg2 == NULL) SWIG_fail;
6701 temp2 = true;
6702 }
6703 {
6704 PyThreadState* __tstate = wxPyBeginAllowThreads();
6705 (arg1)->SetFileEncoding((wxString const &)*arg2);
6706 wxPyEndAllowThreads(__tstate);
6707 if (PyErr_Occurred()) SWIG_fail;
6708 }
6709 resultobj = SWIG_Py_Void();
6710 {
6711 if (temp2)
6712 delete arg2;
6713 }
6714 return resultobj;
6715fail:
6716 {
6717 if (temp2)
6718 delete arg2;
6719 }
6720 return NULL;
2ef75293
RD		 6721}
6722
6723
0085ce49
RD		 6724SWIGINTERN PyObject *XmlDocument_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6725 PyObject *obj;
6726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6727 SWIG_TypeNewClientData(SWIGTYPE_p_wxXmlDocument, SWIG_NewClientData(obj));
6728 return SWIG_Py_Void();
2ef75293
RD		 6729}
6730
0085ce49
RD		 6731SWIGINTERN PyObject *XmlDocument_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6732 return SWIG_Python_InitShadowInstance(args);
6733}
2ef75293 6734
0085ce49
RD		 6735SWIGINTERN PyObject *_wrap_new_XmlResourceHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6736 PyObject *resultobj = 0;
6737 wxPyXmlResourceHandler *result = 0 ;
6738
6739 if (!SWIG_Python_UnpackTuple(args,"new_XmlResourceHandler",0,0,0)) SWIG_fail;
6740 {
6741 PyThreadState* __tstate = wxPyBeginAllowThreads();
6742 result = (wxPyXmlResourceHandler *)new wxPyXmlResourceHandler();
6743 wxPyEndAllowThreads(__tstate);
6744 if (PyErr_Occurred()) SWIG_fail;
6745 }
6746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_POINTER_NEW | 0 );
6747 return resultobj;
6748fail:
6749 return NULL;
6750}
6751
6752
6753SWIGINTERN PyObject *_wrap_XmlResourceHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6754 PyObject *resultobj = 0;
6755 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6756 PyObject *arg2 = (PyObject *) 0 ;
6757 PyObject *arg3 = (PyObject *) 0 ;
6758 void *argp1 = 0 ;
6759 int res1 = 0 ;
6760 PyObject * obj0 = 0 ;
6761 PyObject * obj1 = 0 ;
6762 PyObject * obj2 = 0 ;
6763 char * kwnames[] = {
6764 (char *) "self",(char *) "self",(char *) "_class", NULL
6765 };
6766
6767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResourceHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
6769 if (!SWIG_IsOK(res1)) {
6770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
6771 }
6772 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
6773 arg2 = obj1;
6774 arg3 = obj2;
6775 {
6776 PyThreadState* __tstate = wxPyBeginAllowThreads();
6777 (arg1)->_setCallbackInfo(arg2,arg3);
6778 wxPyEndAllowThreads(__tstate);
6779 if (PyErr_Occurred()) SWIG_fail;
6780 }
6781 resultobj = SWIG_Py_Void();
6782 return resultobj;
6783fail:
6784 return NULL;
6785}
6786
6787
6788SWIGINTERN PyObject *_wrap_XmlResourceHandler_CreateResource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6789 PyObject *resultobj = 0;
6790 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6791 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
6792 wxObject *arg3 = (wxObject *) 0 ;
6793 wxObject *arg4 = (wxObject *) 0 ;
6794 wxObject *result = 0 ;
6795 void *argp1 = 0 ;
6796 int res1 = 0 ;
6797 void *argp2 = 0 ;
6798 int res2 = 0 ;
6799 void *argp3 = 0 ;
6800 int res3 = 0 ;
6801 void *argp4 = 0 ;
6802 int res4 = 0 ;
6803 PyObject * obj0 = 0 ;
6804 PyObject * obj1 = 0 ;
6805 PyObject * obj2 = 0 ;
6806 PyObject * obj3 = 0 ;
6807 char * kwnames[] = {
6808 (char *) "self",(char *) "node",(char *) "parent",(char *) "instance", NULL
6809 };
6810
6811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:XmlResourceHandler_CreateResource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
6813 if (!SWIG_IsOK(res1)) {
6814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_CreateResource" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
6815 }
6816 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
6817 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
6818 if (!SWIG_IsOK(res2)) {
6819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResourceHandler_CreateResource" "', expected argument " "2"" of type '" "wxXmlNode *""'");
6820 }
6821 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
6822 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
6823 if (!SWIG_IsOK(res3)) {
6824 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResourceHandler_CreateResource" "', expected argument " "3"" of type '" "wxObject *""'");
6825 }
6826 arg3 = reinterpret_cast< wxObject * >(argp3);
6827 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxObject, 0 | 0 );
6828 if (!SWIG_IsOK(res4)) {
6829 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "XmlResourceHandler_CreateResource" "', expected argument " "4"" of type '" "wxObject *""'");
6830 }
6831 arg4 = reinterpret_cast< wxObject * >(argp4);
6832 {
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 result = (wxObject *)(arg1)->CreateResource(arg2,arg3,arg4);
6835 wxPyEndAllowThreads(__tstate);
6836 if (PyErr_Occurred()) SWIG_fail;
6837 }
6838 {
6839 resultobj = wxPyMake_wxObject(result, (bool)0);
6840 }
6841 return resultobj;
6842fail:
6843 return NULL;
6844}
6845
6846
6847SWIGINTERN PyObject *_wrap_XmlResourceHandler_SetParentResource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6848 PyObject *resultobj = 0;
6849 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6850 wxXmlResource *arg2 = (wxXmlResource *) 0 ;
6851 void *argp1 = 0 ;
6852 int res1 = 0 ;
6853 void *argp2 = 0 ;
6854 int res2 = 0 ;
6855 PyObject * obj0 = 0 ;
6856 PyObject * obj1 = 0 ;
6857 char * kwnames[] = {
6858 (char *) "self",(char *) "res", NULL
6859 };
6860
6861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_SetParentResource",kwnames,&obj0,&obj1)) SWIG_fail;
6862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
6863 if (!SWIG_IsOK(res1)) {
6864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_SetParentResource" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
6865 }
6866 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
6867 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlResource, 0 | 0 );
6868 if (!SWIG_IsOK(res2)) {
6869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResourceHandler_SetParentResource" "', expected argument " "2"" of type '" "wxXmlResource *""'");
6870 }
6871 arg2 = reinterpret_cast< wxXmlResource * >(argp2);
6872 {
6873 PyThreadState* __tstate = wxPyBeginAllowThreads();
6874 (arg1)->SetParentResource(arg2);
6875 wxPyEndAllowThreads(__tstate);
6876 if (PyErr_Occurred()) SWIG_fail;
6877 }
6878 resultobj = SWIG_Py_Void();
6879 return resultobj;
6880fail:
6881 return NULL;
2ef75293
RD		 6882}
6883
6884
0085ce49
RD		 6885SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetResource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6886 PyObject *resultobj = 0;
6887 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6888 wxXmlResource *result = 0 ;
6889 void *argp1 = 0 ;
6890 int res1 = 0 ;
6891 PyObject *swig_obj[1] ;
6892
6893 if (!args) SWIG_fail;
6894 swig_obj[0] = args;
6895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
6896 if (!SWIG_IsOK(res1)) {
6897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetResource" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
6898 }
6899 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
6900 {
6901 PyThreadState* __tstate = wxPyBeginAllowThreads();
6902 result = (wxXmlResource *)(arg1)->GetResource();
6903 wxPyEndAllowThreads(__tstate);
6904 if (PyErr_Occurred()) SWIG_fail;
6905 }
6906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlResource, 0 | 0 );
6907 return resultobj;
6908fail:
6909 return NULL;
2ef75293
RD		 6910}
6911
6912
0085ce49
RD		 6913SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6914 PyObject *resultobj = 0;
6915 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6916 wxXmlNode *result = 0 ;
6917 void *argp1 = 0 ;
6918 int res1 = 0 ;
6919 PyObject *swig_obj[1] ;
6920
6921 if (!args) SWIG_fail;
6922 swig_obj[0] = args;
6923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
6924 if (!SWIG_IsOK(res1)) {
6925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetNode" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
6926 }
6927 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
6928 {
6929 PyThreadState* __tstate = wxPyBeginAllowThreads();
6930 result = (wxXmlNode *)(arg1)->GetNode();
6931 wxPyEndAllowThreads(__tstate);
6932 if (PyErr_Occurred()) SWIG_fail;
6933 }
6934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlNode, 0 | 0 );
6935 return resultobj;
6936fail:
6937 return NULL;
2ef75293
RD		 6938}
6939
6940
0085ce49
RD		 6941SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6942 PyObject *resultobj = 0;
6943 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6944 wxString result;
6945 void *argp1 = 0 ;
6946 int res1 = 0 ;
6947 PyObject *swig_obj[1] ;
6948
6949 if (!args) SWIG_fail;
6950 swig_obj[0] = args;
6951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
6952 if (!SWIG_IsOK(res1)) {
6953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetClass" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
6954 }
6955 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
6956 {
6957 PyThreadState* __tstate = wxPyBeginAllowThreads();
6958 result = (arg1)->GetClass();
6959 wxPyEndAllowThreads(__tstate);
6960 if (PyErr_Occurred()) SWIG_fail;
6961 }
6962 {
2ef75293 6963#if wxUSE_UNICODE
0085ce49 6964 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
2ef75293 6965#else
0085ce49 6966 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
2ef75293 6967#endif
0085ce49
RD		 6968 }
6969 return resultobj;
6970fail:
6971 return NULL;
2ef75293
RD		 6972}
6973
6974
0085ce49
RD		 6975SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6976 PyObject *resultobj = 0;
6977 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
6978 wxObject *result = 0 ;
6979 void *argp1 = 0 ;
6980 int res1 = 0 ;
6981 PyObject *swig_obj[1] ;
6982
6983 if (!args) SWIG_fail;
6984 swig_obj[0] = args;
6985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
6986 if (!SWIG_IsOK(res1)) {
6987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetParent" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
6988 }
6989 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
6990 {
6991 PyThreadState* __tstate = wxPyBeginAllowThreads();
6992 result = (wxObject *)(arg1)->GetParent();
6993 wxPyEndAllowThreads(__tstate);
6994 if (PyErr_Occurred()) SWIG_fail;
6995 }
6996 {
6997 resultobj = wxPyMake_wxObject(result, (bool)0);
6998 }
6999 return resultobj;
7000fail:
7001 return NULL;
2ef75293
RD		 7002}
7003
7004
0085ce49
RD		 7005SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetInstance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7006 PyObject *resultobj = 0;
7007 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7008 wxObject *result = 0 ;
7009 void *argp1 = 0 ;
7010 int res1 = 0 ;
7011 PyObject *swig_obj[1] ;
7012
7013 if (!args) SWIG_fail;
7014 swig_obj[0] = args;
7015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7016 if (!SWIG_IsOK(res1)) {
7017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetInstance" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7018 }
7019 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7020 {
7021 PyThreadState* __tstate = wxPyBeginAllowThreads();
7022 result = (wxObject *)(arg1)->GetInstance();
7023 wxPyEndAllowThreads(__tstate);
7024 if (PyErr_Occurred()) SWIG_fail;
7025 }
7026 {
7027 resultobj = wxPyMake_wxObject(result, (bool)0);
7028 }
7029 return resultobj;
7030fail:
7031 return NULL;
2ef75293
RD		 7032}
7033
7034
0085ce49
RD		 7035SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetParentAsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7036 PyObject *resultobj = 0;
7037 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7038 wxWindow *result = 0 ;
7039 void *argp1 = 0 ;
7040 int res1 = 0 ;
7041 PyObject *swig_obj[1] ;
7042
7043 if (!args) SWIG_fail;
7044 swig_obj[0] = args;
7045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7046 if (!SWIG_IsOK(res1)) {
7047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetParentAsWindow" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7048 }
7049 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7050 {
7051 PyThreadState* __tstate = wxPyBeginAllowThreads();
7052 result = (wxWindow *)(arg1)->GetParentAsWindow();
7053 wxPyEndAllowThreads(__tstate);
7054 if (PyErr_Occurred()) SWIG_fail;
7055 }
7056 {
7057 resultobj = wxPyMake_wxObject(result, 0);
7058 }
7059 return resultobj;
7060fail:
7061 return NULL;
7062}
7063
7064
7065SWIGINTERN PyObject *_wrap_XmlResourceHandler_IsOfClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7066 PyObject *resultobj = 0;
7067 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7068 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
7069 wxString *arg3 = 0 ;
7070 bool result;
7071 void *argp1 = 0 ;
7072 int res1 = 0 ;
7073 void *argp2 = 0 ;
7074 int res2 = 0 ;
7075 bool temp3 = false ;
7076 PyObject * obj0 = 0 ;
7077 PyObject * obj1 = 0 ;
7078 PyObject * obj2 = 0 ;
7079 char * kwnames[] = {
7080 (char *) "self",(char *) "node",(char *) "classname", NULL
7081 };
7082
7083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResourceHandler_IsOfClass",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7085 if (!SWIG_IsOK(res1)) {
7086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_IsOfClass" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7087 }
7088 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7089 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
7090 if (!SWIG_IsOK(res2)) {
7091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResourceHandler_IsOfClass" "', expected argument " "2"" of type '" "wxXmlNode *""'");
7092 }
7093 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
7094 {
7095 arg3 = wxString_in_helper(obj2);
7096 if (arg3 == NULL) SWIG_fail;
7097 temp3 = true;
7098 }
7099 {
7100 PyThreadState* __tstate = wxPyBeginAllowThreads();
7101 result = (bool)(arg1)->IsOfClass(arg2,(wxString const &)*arg3);
7102 wxPyEndAllowThreads(__tstate);
7103 if (PyErr_Occurred()) SWIG_fail;
7104 }
7105 {
7106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7107 }
7108 {
7109 if (temp3)
7110 delete arg3;
7111 }
7112 return resultobj;
7113fail:
7114 {
7115 if (temp3)
7116 delete arg3;
7117 }
7118 return NULL;
7119}
7120
7121
7122SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetNodeContent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7123 PyObject *resultobj = 0;
7124 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7125 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
7126 wxString result;
7127 void *argp1 = 0 ;
7128 int res1 = 0 ;
7129 void *argp2 = 0 ;
7130 int res2 = 0 ;
7131 PyObject * obj0 = 0 ;
7132 PyObject * obj1 = 0 ;
7133 char * kwnames[] = {
7134 (char *) "self",(char *) "node", NULL
7135 };
7136
7137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_GetNodeContent",kwnames,&obj0,&obj1)) SWIG_fail;
7138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7139 if (!SWIG_IsOK(res1)) {
7140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetNodeContent" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7141 }
7142 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7143 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
7144 if (!SWIG_IsOK(res2)) {
7145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResourceHandler_GetNodeContent" "', expected argument " "2"" of type '" "wxXmlNode *""'");
7146 }
7147 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
7148 {
7149 PyThreadState* __tstate = wxPyBeginAllowThreads();
7150 result = (arg1)->GetNodeContent(arg2);
7151 wxPyEndAllowThreads(__tstate);
7152 if (PyErr_Occurred()) SWIG_fail;
7153 }
7154 {
7155#if wxUSE_UNICODE
7156 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7157#else
7158 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7159#endif
7160 }
7161 return resultobj;
7162fail:
7163 return NULL;
7164}
7165
7166
7167SWIGINTERN PyObject *_wrap_XmlResourceHandler_HasParam(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7168 PyObject *resultobj = 0;
7169 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7170 wxString *arg2 = 0 ;
7171 bool result;
7172 void *argp1 = 0 ;
7173 int res1 = 0 ;
7174 bool temp2 = false ;
7175 PyObject * obj0 = 0 ;
7176 PyObject * obj1 = 0 ;
7177 char * kwnames[] = {
7178 (char *) "self",(char *) "param", NULL
7179 };
7180
7181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_HasParam",kwnames,&obj0,&obj1)) SWIG_fail;
7182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7183 if (!SWIG_IsOK(res1)) {
7184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_HasParam" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7185 }
7186 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7187 {
7188 arg2 = wxString_in_helper(obj1);
7189 if (arg2 == NULL) SWIG_fail;
7190 temp2 = true;
7191 }
7192 {
7193 PyThreadState* __tstate = wxPyBeginAllowThreads();
7194 result = (bool)(arg1)->HasParam((wxString const &)*arg2);
7195 wxPyEndAllowThreads(__tstate);
7196 if (PyErr_Occurred()) SWIG_fail;
7197 }
7198 {
7199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7200 }
7201 {
7202 if (temp2)
7203 delete arg2;
7204 }
7205 return resultobj;
7206fail:
7207 {
7208 if (temp2)
7209 delete arg2;
7210 }
7211 return NULL;
7212}
7213
7214
7215SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetParamNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7216 PyObject *resultobj = 0;
7217 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7218 wxString *arg2 = 0 ;
7219 wxXmlNode *result = 0 ;
7220 void *argp1 = 0 ;
7221 int res1 = 0 ;
7222 bool temp2 = false ;
7223 PyObject * obj0 = 0 ;
7224 PyObject * obj1 = 0 ;
7225 char * kwnames[] = {
7226 (char *) "self",(char *) "param", NULL
7227 };
7228
7229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_GetParamNode",kwnames,&obj0,&obj1)) SWIG_fail;
7230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7231 if (!SWIG_IsOK(res1)) {
7232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetParamNode" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7233 }
7234 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7235 {
7236 arg2 = wxString_in_helper(obj1);
7237 if (arg2 == NULL) SWIG_fail;
7238 temp2 = true;
7239 }
7240 {
7241 PyThreadState* __tstate = wxPyBeginAllowThreads();
7242 result = (wxXmlNode *)(arg1)->GetParamNode((wxString const &)*arg2);
7243 wxPyEndAllowThreads(__tstate);
7244 if (PyErr_Occurred()) SWIG_fail;
7245 }
7246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXmlNode, 0 | 0 );
7247 {
7248 if (temp2)
7249 delete arg2;
7250 }
7251 return resultobj;
7252fail:
7253 {
7254 if (temp2)
7255 delete arg2;
7256 }
7257 return NULL;
7258}
7259
7260
7261SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetParamValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7262 PyObject *resultobj = 0;
7263 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7264 wxString *arg2 = 0 ;
7265 wxString result;
7266 void *argp1 = 0 ;
7267 int res1 = 0 ;
7268 bool temp2 = false ;
7269 PyObject * obj0 = 0 ;
7270 PyObject * obj1 = 0 ;
7271 char * kwnames[] = {
7272 (char *) "self",(char *) "param", NULL
7273 };
7274
7275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_GetParamValue",kwnames,&obj0,&obj1)) SWIG_fail;
7276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7277 if (!SWIG_IsOK(res1)) {
7278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetParamValue" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7279 }
7280 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7281 {
7282 arg2 = wxString_in_helper(obj1);
7283 if (arg2 == NULL) SWIG_fail;
7284 temp2 = true;
7285 }
7286 {
7287 PyThreadState* __tstate = wxPyBeginAllowThreads();
7288 result = (arg1)->GetParamValue((wxString const &)*arg2);
7289 wxPyEndAllowThreads(__tstate);
7290 if (PyErr_Occurred()) SWIG_fail;
7291 }
7292 {
7293#if wxUSE_UNICODE
7294 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7295#else
7296 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7297#endif
7298 }
7299 {
7300 if (temp2)
7301 delete arg2;
7302 }
7303 return resultobj;
7304fail:
7305 {
7306 if (temp2)
7307 delete arg2;
7308 }
7309 return NULL;
7310}
7311
7312
7313SWIGINTERN PyObject *_wrap_XmlResourceHandler_AddStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7314 PyObject *resultobj = 0;
7315 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7316 wxString *arg2 = 0 ;
7317 int arg3 ;
7318 void *argp1 = 0 ;
7319 int res1 = 0 ;
7320 bool temp2 = false ;
7321 int val3 ;
7322 int ecode3 = 0 ;
7323 PyObject * obj0 = 0 ;
7324 PyObject * obj1 = 0 ;
7325 PyObject * obj2 = 0 ;
7326 char * kwnames[] = {
7327 (char *) "self",(char *) "name",(char *) "value", NULL
7328 };
7329
7330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:XmlResourceHandler_AddStyle",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7332 if (!SWIG_IsOK(res1)) {
7333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_AddStyle" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7334 }
7335 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7336 {
7337 arg2 = wxString_in_helper(obj1);
7338 if (arg2 == NULL) SWIG_fail;
7339 temp2 = true;
7340 }
7341 ecode3 = SWIG_AsVal_int(obj2, &val3);
7342 if (!SWIG_IsOK(ecode3)) {
7343 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XmlResourceHandler_AddStyle" "', expected argument " "3"" of type '" "int""'");
7344 }
7345 arg3 = static_cast< int >(val3);
7346 {
7347 PyThreadState* __tstate = wxPyBeginAllowThreads();
7348 (arg1)->AddStyle((wxString const &)*arg2,arg3);
7349 wxPyEndAllowThreads(__tstate);
7350 if (PyErr_Occurred()) SWIG_fail;
7351 }
7352 resultobj = SWIG_Py_Void();
7353 {
7354 if (temp2)
7355 delete arg2;
7356 }
7357 return resultobj;
7358fail:
7359 {
7360 if (temp2)
7361 delete arg2;
7362 }
7363 return NULL;
2ef75293
RD		 7364}
7365
7366
0085ce49
RD		 7367SWIGINTERN PyObject *_wrap_XmlResourceHandler_AddWindowStyles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7368 PyObject *resultobj = 0;
7369 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7370 void *argp1 = 0 ;
7371 int res1 = 0 ;
7372 PyObject *swig_obj[1] ;
7373
7374 if (!args) SWIG_fail;
7375 swig_obj[0] = args;
7376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7377 if (!SWIG_IsOK(res1)) {
7378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_AddWindowStyles" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7379 }
7380 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7381 {
7382 PyThreadState* __tstate = wxPyBeginAllowThreads();
7383 (arg1)->AddWindowStyles();
7384 wxPyEndAllowThreads(__tstate);
7385 if (PyErr_Occurred()) SWIG_fail;
7386 }
7387 resultobj = SWIG_Py_Void();
7388 return resultobj;
7389fail:
7390 return NULL;
7391}
7392
7393
7394SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7395 PyObject *resultobj = 0;
7396 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7397 wxString const &arg2_defvalue = wxPyStyleString ;
7398 wxString *arg2 = (wxString *) &arg2_defvalue ;
7399 int arg3 = (int) 0 ;
7400 int result;
7401 void *argp1 = 0 ;
7402 int res1 = 0 ;
7403 bool temp2 = false ;
7404 int val3 ;
7405 int ecode3 = 0 ;
7406 PyObject * obj0 = 0 ;
7407 PyObject * obj1 = 0 ;
7408 PyObject * obj2 = 0 ;
7409 char * kwnames[] = {
7410 (char *) "self",(char *) "param",(char *) "defaults", NULL
7411 };
7412
7413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:XmlResourceHandler_GetStyle",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7415 if (!SWIG_IsOK(res1)) {
7416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetStyle" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7417 }
7418 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7419 if (obj1) {
2ef75293 7420 {
0085ce49
RD		 7421 arg2 = wxString_in_helper(obj1);
7422 if (arg2 == NULL) SWIG_fail;
7423 temp2 = true;
2ef75293 7424 }
0085ce49
RD		 7425 }
7426 if (obj2) {
7427 ecode3 = SWIG_AsVal_int(obj2, &val3);
7428 if (!SWIG_IsOK(ecode3)) {
7429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XmlResourceHandler_GetStyle" "', expected argument " "3"" of type '" "int""'");
7430 }
7431 arg3 = static_cast< int >(val3);
7432 }
7433 {
7434 PyThreadState* __tstate = wxPyBeginAllowThreads();
7435 result = (int)(arg1)->GetStyle((wxString const &)*arg2,arg3);
7436 wxPyEndAllowThreads(__tstate);
7437 if (PyErr_Occurred()) SWIG_fail;
7438 }
7439 resultobj = SWIG_From_int(static_cast< int >(result));
7440 {
7441 if (temp2)
7442 delete arg2;
7443 }
7444 return resultobj;
7445fail:
7446 {
7447 if (temp2)
7448 delete arg2;
7449 }
7450 return NULL;
7451}
7452
7453
7454SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7455 PyObject *resultobj = 0;
7456 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7457 wxString *arg2 = 0 ;
7458 bool arg3 = (bool) true ;
7459 wxString result;
7460 void *argp1 = 0 ;
7461 int res1 = 0 ;
7462 bool temp2 = false ;
7463 bool val3 ;
7464 int ecode3 = 0 ;
7465 PyObject * obj0 = 0 ;
7466 PyObject * obj1 = 0 ;
7467 PyObject * obj2 = 0 ;
7468 char * kwnames[] = {
7469 (char *) "self",(char *) "param",(char *) "translate", NULL
7470 };
7471
7472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_GetText",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7474 if (!SWIG_IsOK(res1)) {
7475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetText" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7476 }
7477 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7478 {
7479 arg2 = wxString_in_helper(obj1);
7480 if (arg2 == NULL) SWIG_fail;
7481 temp2 = true;
7482 }
7483 if (obj2) {
7484 ecode3 = SWIG_AsVal_bool(obj2, &val3);
7485 if (!SWIG_IsOK(ecode3)) {
7486 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XmlResourceHandler_GetText" "', expected argument " "3"" of type '" "bool""'");
7487 }
7488 arg3 = static_cast< bool >(val3);
7489 }
7490 {
7491 PyThreadState* __tstate = wxPyBeginAllowThreads();
7492 result = (arg1)->GetText((wxString const &)*arg2,arg3);
7493 wxPyEndAllowThreads(__tstate);
7494 if (PyErr_Occurred()) SWIG_fail;
7495 }
7496 {
7497#if wxUSE_UNICODE
7498 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7499#else
7500 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7501#endif
7502 }
7503 {
7504 if (temp2)
7505 delete arg2;
7506 }
7507 return resultobj;
7508fail:
7509 {
7510 if (temp2)
7511 delete arg2;
7512 }
7513 return NULL;
2ef75293
RD		 7514}
7515
7516
0085ce49
RD		 7517SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7518 PyObject *resultobj = 0;
7519 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7520 int result;
7521 void *argp1 = 0 ;
7522 int res1 = 0 ;
7523 PyObject *swig_obj[1] ;
7524
7525 if (!args) SWIG_fail;
7526 swig_obj[0] = args;
7527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7528 if (!SWIG_IsOK(res1)) {
7529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetID" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7530 }
7531 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7532 {
7533 PyThreadState* __tstate = wxPyBeginAllowThreads();
7534 result = (int)(arg1)->GetID();
7535 wxPyEndAllowThreads(__tstate);
7536 if (PyErr_Occurred()) SWIG_fail;
7537 }
7538 resultobj = SWIG_From_int(static_cast< int >(result));
7539 return resultobj;
7540fail:
7541 return NULL;
2ef75293
RD		 7542}
7543
7544
0085ce49
RD		 7545SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7546 PyObject *resultobj = 0;
7547 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7548 wxString result;
7549 void *argp1 = 0 ;
7550 int res1 = 0 ;
7551 PyObject *swig_obj[1] ;
7552
7553 if (!args) SWIG_fail;
7554 swig_obj[0] = args;
7555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7556 if (!SWIG_IsOK(res1)) {
7557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetName" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7558 }
7559 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7560 {
7561 PyThreadState* __tstate = wxPyBeginAllowThreads();
7562 result = (arg1)->GetName();
7563 wxPyEndAllowThreads(__tstate);
7564 if (PyErr_Occurred()) SWIG_fail;
7565 }
7566 {
7567#if wxUSE_UNICODE
7568 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7569#else
7570 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7571#endif
7572 }
7573 return resultobj;
7574fail:
7575 return NULL;
7576}
7577
7578
7579SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7580 PyObject *resultobj = 0;
7581 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7582 wxString *arg2 = 0 ;
7583 bool arg3 = (bool) false ;
7584 bool result;
7585 void *argp1 = 0 ;
7586 int res1 = 0 ;
7587 bool temp2 = false ;
7588 bool val3 ;
7589 int ecode3 = 0 ;
7590 PyObject * obj0 = 0 ;
7591 PyObject * obj1 = 0 ;
7592 PyObject * obj2 = 0 ;
7593 char * kwnames[] = {
7594 (char *) "self",(char *) "param",(char *) "defaultv", NULL
7595 };
7596
7597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_GetBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7599 if (!SWIG_IsOK(res1)) {
7600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetBool" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7601 }
7602 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7603 {
7604 arg2 = wxString_in_helper(obj1);
7605 if (arg2 == NULL) SWIG_fail;
7606 temp2 = true;
7607 }
7608 if (obj2) {
7609 ecode3 = SWIG_AsVal_bool(obj2, &val3);
7610 if (!SWIG_IsOK(ecode3)) {
7611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XmlResourceHandler_GetBool" "', expected argument " "3"" of type '" "bool""'");
7612 }
7613 arg3 = static_cast< bool >(val3);
7614 }
7615 {
7616 PyThreadState* __tstate = wxPyBeginAllowThreads();
7617 result = (bool)(arg1)->GetBool((wxString const &)*arg2,arg3);
7618 wxPyEndAllowThreads(__tstate);
7619 if (PyErr_Occurred()) SWIG_fail;
7620 }
7621 {
7622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7623 }
7624 {
7625 if (temp2)
7626 delete arg2;
7627 }
7628 return resultobj;
7629fail:
7630 {
7631 if (temp2)
7632 delete arg2;
7633 }
7634 return NULL;
7635}
7636
7637
7638SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7639 PyObject *resultobj = 0;
7640 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7641 wxString *arg2 = 0 ;
7642 long arg3 = (long) 0 ;
7643 long result;
7644 void *argp1 = 0 ;
7645 int res1 = 0 ;
7646 bool temp2 = false ;
7647 long val3 ;
7648 int ecode3 = 0 ;
7649 PyObject * obj0 = 0 ;
7650 PyObject * obj1 = 0 ;
7651 PyObject * obj2 = 0 ;
7652 char * kwnames[] = {
7653 (char *) "self",(char *) "param",(char *) "defaultv", NULL
7654 };
7655
7656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_GetLong",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7658 if (!SWIG_IsOK(res1)) {
7659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetLong" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7660 }
7661 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7662 {
7663 arg2 = wxString_in_helper(obj1);
7664 if (arg2 == NULL) SWIG_fail;
7665 temp2 = true;
7666 }
7667 if (obj2) {
7668 ecode3 = SWIG_AsVal_long(obj2, &val3);
7669 if (!SWIG_IsOK(ecode3)) {
7670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XmlResourceHandler_GetLong" "', expected argument " "3"" of type '" "long""'");
7671 }
7672 arg3 = static_cast< long >(val3);
7673 }
7674 {
7675 PyThreadState* __tstate = wxPyBeginAllowThreads();
7676 result = (long)(arg1)->GetLong((wxString const &)*arg2,arg3);
7677 wxPyEndAllowThreads(__tstate);
7678 if (PyErr_Occurred()) SWIG_fail;
7679 }
7680 resultobj = SWIG_From_long(static_cast< long >(result));
7681 {
7682 if (temp2)
7683 delete arg2;
7684 }
7685 return resultobj;
7686fail:
7687 {
7688 if (temp2)
7689 delete arg2;
7690 }
7691 return NULL;
7692}
7693
7694
7695SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7696 PyObject *resultobj = 0;
7697 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7698 wxString *arg2 = 0 ;
7699 wxColour result;
7700 void *argp1 = 0 ;
7701 int res1 = 0 ;
7702 bool temp2 = false ;
7703 PyObject * obj0 = 0 ;
7704 PyObject * obj1 = 0 ;
7705 char * kwnames[] = {
7706 (char *) "self",(char *) "param", NULL
7707 };
7708
7709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_GetColour",kwnames,&obj0,&obj1)) SWIG_fail;
7710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7711 if (!SWIG_IsOK(res1)) {
7712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetColour" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7713 }
7714 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7715 {
7716 arg2 = wxString_in_helper(obj1);
7717 if (arg2 == NULL) SWIG_fail;
7718 temp2 = true;
7719 }
7720 {
7721 PyThreadState* __tstate = wxPyBeginAllowThreads();
7722 result = (arg1)->GetColour((wxString const &)*arg2);
7723 wxPyEndAllowThreads(__tstate);
7724 if (PyErr_Occurred()) SWIG_fail;
7725 }
7726 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
7727 {
7728 if (temp2)
7729 delete arg2;
7730 }
7731 return resultobj;
7732fail:
7733 {
7734 if (temp2)
7735 delete arg2;
7736 }
7737 return NULL;
7738}
7739
7740
7741SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7742 PyObject *resultobj = 0;
7743 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7744 wxString const &arg2_defvalue = wxPySizeString ;
7745 wxString *arg2 = (wxString *) &arg2_defvalue ;
7746 wxSize result;
7747 void *argp1 = 0 ;
7748 int res1 = 0 ;
7749 bool temp2 = false ;
7750 PyObject * obj0 = 0 ;
7751 PyObject * obj1 = 0 ;
7752 char * kwnames[] = {
7753 (char *) "self",(char *) "param", NULL
7754 };
7755
7756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:XmlResourceHandler_GetSize",kwnames,&obj0,&obj1)) SWIG_fail;
7757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7758 if (!SWIG_IsOK(res1)) {
7759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetSize" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7760 }
7761 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7762 if (obj1) {
2ef75293 7763 {
0085ce49
RD		 7764 arg2 = wxString_in_helper(obj1);
7765 if (arg2 == NULL) SWIG_fail;
7766 temp2 = true;
2ef75293 7767 }
0085ce49
RD		 7768 }
7769 {
7770 PyThreadState* __tstate = wxPyBeginAllowThreads();
7771 result = (arg1)->GetSize((wxString const &)*arg2);
7772 wxPyEndAllowThreads(__tstate);
7773 if (PyErr_Occurred()) SWIG_fail;
7774 }
7775 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
7776 {
7777 if (temp2)
7778 delete arg2;
7779 }
7780 return resultobj;
7781fail:
7782 {
7783 if (temp2)
7784 delete arg2;
7785 }
7786 return NULL;
7787}
7788
7789
7790SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7791 PyObject *resultobj = 0;
7792 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7793 wxString const &arg2_defvalue = wxPyPosString ;
7794 wxString *arg2 = (wxString *) &arg2_defvalue ;
7795 wxPoint result;
7796 void *argp1 = 0 ;
7797 int res1 = 0 ;
7798 bool temp2 = false ;
7799 PyObject * obj0 = 0 ;
7800 PyObject * obj1 = 0 ;
7801 char * kwnames[] = {
7802 (char *) "self",(char *) "param", NULL
7803 };
7804
7805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:XmlResourceHandler_GetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
7806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7807 if (!SWIG_IsOK(res1)) {
7808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetPosition" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7809 }
7810 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7811 if (obj1) {
2ef75293 7812 {
0085ce49
RD		 7813 arg2 = wxString_in_helper(obj1);
7814 if (arg2 == NULL) SWIG_fail;
7815 temp2 = true;
2ef75293 7816 }
0085ce49
RD		 7817 }
7818 {
7819 PyThreadState* __tstate = wxPyBeginAllowThreads();
7820 result = (arg1)->GetPosition((wxString const &)*arg2);
7821 wxPyEndAllowThreads(__tstate);
7822 if (PyErr_Occurred()) SWIG_fail;
7823 }
7824 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7825 {
7826 if (temp2)
7827 delete arg2;
7828 }
7829 return resultobj;
7830fail:
7831 {
7832 if (temp2)
7833 delete arg2;
7834 }
7835 return NULL;
7836}
7837
7838
7839SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7840 PyObject *resultobj = 0;
7841 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7842 wxString *arg2 = 0 ;
7843 int arg3 = (int) 0 ;
7844 int result;
7845 void *argp1 = 0 ;
7846 int res1 = 0 ;
7847 bool temp2 = false ;
7848 int val3 ;
7849 int ecode3 = 0 ;
7850 PyObject * obj0 = 0 ;
7851 PyObject * obj1 = 0 ;
7852 PyObject * obj2 = 0 ;
7853 char * kwnames[] = {
7854 (char *) "self",(char *) "param",(char *) "defaultv", NULL
7855 };
7856
7857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_GetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7859 if (!SWIG_IsOK(res1)) {
7860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetDimension" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7861 }
7862 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7863 {
7864 arg2 = wxString_in_helper(obj1);
7865 if (arg2 == NULL) SWIG_fail;
7866 temp2 = true;
7867 }
7868 if (obj2) {
7869 ecode3 = SWIG_AsVal_int(obj2, &val3);
7870 if (!SWIG_IsOK(ecode3)) {
7871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XmlResourceHandler_GetDimension" "', expected argument " "3"" of type '" "int""'");
7872 }
7873 arg3 = static_cast< int >(val3);
7874 }
7875 {
7876 PyThreadState* __tstate = wxPyBeginAllowThreads();
7877 result = (int)(arg1)->GetDimension((wxString const &)*arg2,arg3);
7878 wxPyEndAllowThreads(__tstate);
7879 if (PyErr_Occurred()) SWIG_fail;
7880 }
7881 resultobj = SWIG_From_int(static_cast< int >(result));
7882 {
7883 if (temp2)
7884 delete arg2;
7885 }
7886 return resultobj;
7887fail:
7888 {
7889 if (temp2)
7890 delete arg2;
7891 }
7892 return NULL;
7893}
7894
7895
7896SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7897 PyObject *resultobj = 0;
7898 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7899 wxString const &arg2_defvalue = wxPyBitmapString ;
7900 wxString *arg2 = (wxString *) &arg2_defvalue ;
7901 wxArtClient const &arg3_defvalue = wxART_OTHER ;
7902 wxArtClient *arg3 = (wxArtClient *) &arg3_defvalue ;
7903 wxSize arg4 = (wxSize) wxDefaultSize ;
7904 wxBitmap result;
7905 void *argp1 = 0 ;
7906 int res1 = 0 ;
7907 bool temp2 = false ;
7908 void *argp3 = 0 ;
7909 int res3 = 0 ;
7910 void *argp4 ;
7911 int res4 = 0 ;
7912 PyObject * obj0 = 0 ;
7913 PyObject * obj1 = 0 ;
7914 PyObject * obj2 = 0 ;
7915 PyObject * obj3 = 0 ;
7916 char * kwnames[] = {
7917 (char *) "self",(char *) "param",(char *) "defaultArtClient",(char *) "size", NULL
7918 };
7919
7920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:XmlResourceHandler_GetBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
7922 if (!SWIG_IsOK(res1)) {
7923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetBitmap" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
7924 }
7925 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
7926 if (obj1) {
2ef75293 7927 {
0085ce49
RD		 7928 arg2 = wxString_in_helper(obj1);
7929 if (arg2 == NULL) SWIG_fail;
7930 temp2 = true;
2ef75293 7931 }
0085ce49
RD		 7932 }
7933 if (obj2) {
7934 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxArtClient, 0 | 0);
7935 if (!SWIG_IsOK(res3)) {
7936 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResourceHandler_GetBitmap" "', expected argument " "3"" of type '" "wxArtClient const &""'");
2ef75293 7937 }
0085ce49
RD		 7938 if (!argp3) {
7939 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XmlResourceHandler_GetBitmap" "', expected argument " "3"" of type '" "wxArtClient const &""'");
2ef75293 7940 }
0085ce49
RD		 7941 arg3 = reinterpret_cast< wxArtClient * >(argp3);
7942 }
7943 if (obj3) {
7944 {
7945 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxSize, 0 | 0);
7946 if (!SWIG_IsOK(res4)) {
7947 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "XmlResourceHandler_GetBitmap" "', expected argument " "4"" of type '" "wxSize""'");
7948 }
7949 if (!argp4) {
7950 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XmlResourceHandler_GetBitmap" "', expected argument " "4"" of type '" "wxSize""'");
7951 } else {
7952 wxSize * temp = reinterpret_cast< wxSize * >(argp4);
7953 arg4 = *temp;
7954 if (SWIG_IsNewObj(res4)) delete temp;
7955 }
2ef75293 7956 }
0085ce49
RD		 7957 }
7958 {
7959 PyThreadState* __tstate = wxPyBeginAllowThreads();
7960 result = (arg1)->GetBitmap((wxString const &)*arg2,(wxArtClient const &)*arg3,arg4);
7961 wxPyEndAllowThreads(__tstate);
7962 if (PyErr_Occurred()) SWIG_fail;
7963 }
7964 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
7965 {
7966 if (temp2)
7967 delete arg2;
7968 }
7969 return resultobj;
7970fail:
7971 {
7972 if (temp2)
7973 delete arg2;
7974 }
7975 return NULL;
7976}
7977
7978
7979SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7980 PyObject *resultobj = 0;
7981 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
7982 wxString const &arg2_defvalue = wxPyIconString ;
7983 wxString *arg2 = (wxString *) &arg2_defvalue ;
7984 wxArtClient const &arg3_defvalue = wxART_OTHER ;
7985 wxArtClient *arg3 = (wxArtClient *) &arg3_defvalue ;
7986 wxSize arg4 = (wxSize) wxDefaultSize ;
7987 wxIcon result;
7988 void *argp1 = 0 ;
7989 int res1 = 0 ;
7990 bool temp2 = false ;
7991 void *argp3 = 0 ;
7992 int res3 = 0 ;
7993 void *argp4 ;
7994 int res4 = 0 ;
7995 PyObject * obj0 = 0 ;
7996 PyObject * obj1 = 0 ;
7997 PyObject * obj2 = 0 ;
7998 PyObject * obj3 = 0 ;
7999 char * kwnames[] = {
8000 (char *) "self",(char *) "param",(char *) "defaultArtClient",(char *) "size", NULL
8001 };
8002
8003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:XmlResourceHandler_GetIcon",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
8005 if (!SWIG_IsOK(res1)) {
8006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetIcon" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
8007 }
8008 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
8009 if (obj1) {
2ef75293 8010 {
0085ce49
RD		 8011 arg2 = wxString_in_helper(obj1);
8012 if (arg2 == NULL) SWIG_fail;
8013 temp2 = true;
2ef75293 8014 }
0085ce49
RD		 8015 }
8016 if (obj2) {
8017 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxArtClient, 0 | 0);
8018 if (!SWIG_IsOK(res3)) {
8019 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResourceHandler_GetIcon" "', expected argument " "3"" of type '" "wxArtClient const &""'");
2ef75293 8020 }
0085ce49
RD		 8021 if (!argp3) {
8022 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XmlResourceHandler_GetIcon" "', expected argument " "3"" of type '" "wxArtClient const &""'");
2ef75293 8023 }
0085ce49
RD		 8024 arg3 = reinterpret_cast< wxArtClient * >(argp3);
8025 }
8026 if (obj3) {
8027 {
8028 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxSize, 0 | 0);
8029 if (!SWIG_IsOK(res4)) {
8030 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "XmlResourceHandler_GetIcon" "', expected argument " "4"" of type '" "wxSize""'");
8031 }
8032 if (!argp4) {
8033 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XmlResourceHandler_GetIcon" "', expected argument " "4"" of type '" "wxSize""'");
8034 } else {
8035 wxSize * temp = reinterpret_cast< wxSize * >(argp4);
8036 arg4 = *temp;
8037 if (SWIG_IsNewObj(res4)) delete temp;
8038 }
2ef75293 8039 }
0085ce49
RD		 8040 }
8041 {
8042 PyThreadState* __tstate = wxPyBeginAllowThreads();
8043 result = (arg1)->GetIcon((wxString const &)*arg2,(wxArtClient const &)*arg3,arg4);
8044 wxPyEndAllowThreads(__tstate);
8045 if (PyErr_Occurred()) SWIG_fail;
8046 }
8047 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
8048 {
8049 if (temp2)
8050 delete arg2;
8051 }
8052 return resultobj;
8053fail:
8054 {
8055 if (temp2)
8056 delete arg2;
8057 }
8058 return NULL;
8059}
8060
8061
8062SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8063 PyObject *resultobj = 0;
8064 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
8065 wxString const &arg2_defvalue = wxPyFontString ;
8066 wxString *arg2 = (wxString *) &arg2_defvalue ;
8067 wxFont result;
8068 void *argp1 = 0 ;
8069 int res1 = 0 ;
8070 bool temp2 = false ;
8071 PyObject * obj0 = 0 ;
8072 PyObject * obj1 = 0 ;
8073 char * kwnames[] = {
8074 (char *) "self",(char *) "param", NULL
8075 };
8076
8077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:XmlResourceHandler_GetFont",kwnames,&obj0,&obj1)) SWIG_fail;
8078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
8079 if (!SWIG_IsOK(res1)) {
8080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetFont" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
8081 }
8082 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
8083 if (obj1) {
2ef75293 8084 {
0085ce49
RD		 8085 arg2 = wxString_in_helper(obj1);
8086 if (arg2 == NULL) SWIG_fail;
8087 temp2 = true;
2ef75293 8088 }
0085ce49
RD		 8089 }
8090 {
8091 PyThreadState* __tstate = wxPyBeginAllowThreads();
8092 result = (arg1)->GetFont((wxString const &)*arg2);
8093 wxPyEndAllowThreads(__tstate);
8094 if (PyErr_Occurred()) SWIG_fail;
8095 }
8096 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
8097 {
8098 if (temp2)
8099 delete arg2;
8100 }
8101 return resultobj;
8102fail:
8103 {
8104 if (temp2)
8105 delete arg2;
8106 }
8107 return NULL;
8108}
8109
8110
8111SWIGINTERN PyObject *_wrap_XmlResourceHandler_SetupWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8112 PyObject *resultobj = 0;
8113 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
8114 wxWindow *arg2 = (wxWindow *) 0 ;
8115 void *argp1 = 0 ;
8116 int res1 = 0 ;
8117 void *argp2 = 0 ;
8118 int res2 = 0 ;
8119 PyObject * obj0 = 0 ;
8120 PyObject * obj1 = 0 ;
8121 char * kwnames[] = {
8122 (char *) "self",(char *) "wnd", NULL
8123 };
8124
8125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:XmlResourceHandler_SetupWindow",kwnames,&obj0,&obj1)) SWIG_fail;
8126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
8127 if (!SWIG_IsOK(res1)) {
8128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_SetupWindow" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
8129 }
8130 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
8131 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
8132 if (!SWIG_IsOK(res2)) {
8133 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResourceHandler_SetupWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
8134 }
8135 arg2 = reinterpret_cast< wxWindow * >(argp2);
8136 {
8137 PyThreadState* __tstate = wxPyBeginAllowThreads();
8138 (arg1)->SetupWindow(arg2);
8139 wxPyEndAllowThreads(__tstate);
8140 if (PyErr_Occurred()) SWIG_fail;
8141 }
8142 resultobj = SWIG_Py_Void();
8143 return resultobj;
8144fail:
8145 return NULL;
8146}
8147
8148
8149SWIGINTERN PyObject *_wrap_XmlResourceHandler_CreateChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8150 PyObject *resultobj = 0;
8151 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
8152 wxObject *arg2 = (wxObject *) 0 ;
8153 bool arg3 = (bool) false ;
8154 void *argp1 = 0 ;
8155 int res1 = 0 ;
8156 void *argp2 = 0 ;
8157 int res2 = 0 ;
8158 bool val3 ;
8159 int ecode3 = 0 ;
8160 PyObject * obj0 = 0 ;
8161 PyObject * obj1 = 0 ;
8162 PyObject * obj2 = 0 ;
8163 char * kwnames[] = {
8164 (char *) "self",(char *) "parent",(char *) "this_hnd_only", NULL
8165 };
8166
8167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_CreateChildren",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
8169 if (!SWIG_IsOK(res1)) {
8170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_CreateChildren" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
8171 }
8172 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
8173 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
8174 if (!SWIG_IsOK(res2)) {
8175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResourceHandler_CreateChildren" "', expected argument " "2"" of type '" "wxObject *""'");
8176 }
8177 arg2 = reinterpret_cast< wxObject * >(argp2);
8178 if (obj2) {
8179 ecode3 = SWIG_AsVal_bool(obj2, &val3);
8180 if (!SWIG_IsOK(ecode3)) {
8181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XmlResourceHandler_CreateChildren" "', expected argument " "3"" of type '" "bool""'");
8182 }
8183 arg3 = static_cast< bool >(val3);
8184 }
8185 {
8186 PyThreadState* __tstate = wxPyBeginAllowThreads();
8187 (arg1)->CreateChildren(arg2,arg3);
8188 wxPyEndAllowThreads(__tstate);
8189 if (PyErr_Occurred()) SWIG_fail;
8190 }
8191 resultobj = SWIG_Py_Void();
8192 return resultobj;
8193fail:
8194 return NULL;
8195}
8196
8197
8198SWIGINTERN PyObject *_wrap_XmlResourceHandler_CreateChildrenPrivately(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8199 PyObject *resultobj = 0;
8200 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
8201 wxObject *arg2 = (wxObject *) 0 ;
8202 wxXmlNode *arg3 = (wxXmlNode *) NULL ;
8203 void *argp1 = 0 ;
8204 int res1 = 0 ;
8205 void *argp2 = 0 ;
8206 int res2 = 0 ;
8207 void *argp3 = 0 ;
8208 int res3 = 0 ;
8209 PyObject * obj0 = 0 ;
8210 PyObject * obj1 = 0 ;
8211 PyObject * obj2 = 0 ;
8212 char * kwnames[] = {
8213 (char *) "self",(char *) "parent",(char *) "rootnode", NULL
8214 };
8215
8216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:XmlResourceHandler_CreateChildrenPrivately",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
8218 if (!SWIG_IsOK(res1)) {
8219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_CreateChildrenPrivately" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
8220 }
8221 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
8222 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
8223 if (!SWIG_IsOK(res2)) {
8224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResourceHandler_CreateChildrenPrivately" "', expected argument " "2"" of type '" "wxObject *""'");
8225 }
8226 arg2 = reinterpret_cast< wxObject * >(argp2);
8227 if (obj2) {
8228 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxXmlNode, 0 | 0 );
8229 if (!SWIG_IsOK(res3)) {
8230 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResourceHandler_CreateChildrenPrivately" "', expected argument " "3"" of type '" "wxXmlNode *""'");
2ef75293 8231 }
0085ce49
RD		 8232 arg3 = reinterpret_cast< wxXmlNode * >(argp3);
8233 }
8234 {
8235 PyThreadState* __tstate = wxPyBeginAllowThreads();
8236 (arg1)->CreateChildrenPrivately(arg2,arg3);
8237 wxPyEndAllowThreads(__tstate);
8238 if (PyErr_Occurred()) SWIG_fail;
8239 }
8240 resultobj = SWIG_Py_Void();
8241 return resultobj;
8242fail:
8243 return NULL;
8244}
8245
8246
8247SWIGINTERN PyObject *_wrap_XmlResourceHandler_CreateResFromNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8248 PyObject *resultobj = 0;
8249 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
8250 wxXmlNode *arg2 = (wxXmlNode *) 0 ;
8251 wxObject *arg3 = (wxObject *) 0 ;
8252 wxObject *arg4 = (wxObject *) NULL ;
8253 wxObject *result = 0 ;
8254 void *argp1 = 0 ;
8255 int res1 = 0 ;
8256 void *argp2 = 0 ;
8257 int res2 = 0 ;
8258 void *argp3 = 0 ;
8259 int res3 = 0 ;
8260 void *argp4 = 0 ;
8261 int res4 = 0 ;
8262 PyObject * obj0 = 0 ;
8263 PyObject * obj1 = 0 ;
8264 PyObject * obj2 = 0 ;
8265 PyObject * obj3 = 0 ;
8266 char * kwnames[] = {
8267 (char *) "self",(char *) "node",(char *) "parent",(char *) "instance", NULL
8268 };
8269
8270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:XmlResourceHandler_CreateResFromNode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
8272 if (!SWIG_IsOK(res1)) {
8273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_CreateResFromNode" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
8274 }
8275 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
8276 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxXmlNode, 0 | 0 );
8277 if (!SWIG_IsOK(res2)) {
8278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XmlResourceHandler_CreateResFromNode" "', expected argument " "2"" of type '" "wxXmlNode *""'");
8279 }
8280 arg2 = reinterpret_cast< wxXmlNode * >(argp2);
8281 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxObject, 0 | 0 );
8282 if (!SWIG_IsOK(res3)) {
8283 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "XmlResourceHandler_CreateResFromNode" "', expected argument " "3"" of type '" "wxObject *""'");
8284 }
8285 arg3 = reinterpret_cast< wxObject * >(argp3);
8286 if (obj3) {
8287 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxObject, 0 | 0 );
8288 if (!SWIG_IsOK(res4)) {
8289 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "XmlResourceHandler_CreateResFromNode" "', expected argument " "4"" of type '" "wxObject *""'");
2ef75293 8290 }
0085ce49
RD		 8291 arg4 = reinterpret_cast< wxObject * >(argp4);
8292 }
8293 {
8294 PyThreadState* __tstate = wxPyBeginAllowThreads();
8295 result = (wxObject *)(arg1)->CreateResFromNode(arg2,arg3,arg4);
8296 wxPyEndAllowThreads(__tstate);
8297 if (PyErr_Occurred()) SWIG_fail;
8298 }
8299 {
8300 resultobj = wxPyMake_wxObject(result, (bool)0);
8301 }
8302 return resultobj;
8303fail:
8304 return NULL;
2ef75293
RD		 8305}
8306
8307
0085ce49
RD		 8308SWIGINTERN PyObject *_wrap_XmlResourceHandler_GetCurFileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8309 PyObject *resultobj = 0;
8310 wxPyXmlResourceHandler *arg1 = (wxPyXmlResourceHandler *) 0 ;
8311 wxFileSystem *result = 0 ;
8312 void *argp1 = 0 ;
8313 int res1 = 0 ;
8314 PyObject *swig_obj[1] ;
8315
8316 if (!args) SWIG_fail;
8317 swig_obj[0] = args;
8318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyXmlResourceHandler, 0 | 0 );
8319 if (!SWIG_IsOK(res1)) {
8320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XmlResourceHandler_GetCurFileSystem" "', expected argument " "1"" of type '" "wxPyXmlResourceHandler *""'");
8321 }
8322 arg1 = reinterpret_cast< wxPyXmlResourceHandler * >(argp1);
8323 {
8324 PyThreadState* __tstate = wxPyBeginAllowThreads();
2ef75293 8325 {
0085ce49
RD		 8326 wxFileSystem &_result_ref = (arg1)->GetCurFileSystem();
8327 result = (wxFileSystem *) &_result_ref;
2ef75293 8328 }
0085ce49
RD		 8329 wxPyEndAllowThreads(__tstate);
8330 if (PyErr_Occurred()) SWIG_fail;
8331 }
8332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, 0 | 0 );
8333 return resultobj;
8334fail:
8335 return NULL;
2ef75293
RD		 8336}
8337
8338
0085ce49
RD		 8339SWIGINTERN PyObject *XmlResourceHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8340 PyObject *obj;
8341 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8342 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyXmlResourceHandler, SWIG_NewClientData(obj));
8343 return SWIG_Py_Void();
2ef75293
RD		 8344}
8345
0085ce49
RD		 8346SWIGINTERN PyObject *XmlResourceHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8347 return SWIG_Python_InitShadowInstance(args);
2ef75293
RD		 8348}
8349
2ef75293 8350static PyMethodDef SwigMethods[] = {
093d3ff1
RD		 8351 { (char *)"new_XmlResource", (PyCFunction) _wrap_new_XmlResource, METH_VARARGS | METH_KEYWORDS, NULL},
8352 { (char *)"new_EmptyXmlResource", (PyCFunction) _wrap_new_EmptyXmlResource, METH_VARARGS | METH_KEYWORDS, NULL},
0085ce49 8353 { (char *)"delete_XmlResource", (PyCFunction)_wrap_delete_XmlResource, METH_O, NULL},
093d3ff1
RD		 8354 { (char *)"XmlResource_Load", (PyCFunction) _wrap_XmlResource_Load, METH_VARARGS | METH_KEYWORDS, NULL},
8355 { (char *)"XmlResource_LoadFromString", (PyCFunction) _wrap_XmlResource_LoadFromString, METH_VARARGS | METH_KEYWORDS, NULL},
943e8dfd 8356 { (char *)"XmlResource_Unload", (PyCFunction) _wrap_XmlResource_Unload, METH_VARARGS | METH_KEYWORDS, NULL},
0085ce49 8357 { (char *)"XmlResource_InitAllHandlers", (PyCFunction)_wrap_XmlResource_InitAllHandlers, METH_O, NULL},
093d3ff1
RD		 8358 { (char *)"XmlResource_AddHandler", (PyCFunction) _wrap_XmlResource_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
8359 { (char *)"XmlResource_InsertHandler", (PyCFunction) _wrap_XmlResource_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
0085ce49 8360 { (char *)"XmlResource_ClearHandlers", (PyCFunction)_wrap_XmlResource_ClearHandlers, METH_O, NULL},
093d3ff1
RD		 8361 { (char *)"XmlResource_AddSubclassFactory", (PyCFunction) _wrap_XmlResource_AddSubclassFactory, METH_VARARGS | METH_KEYWORDS, NULL},
8362 { (char *)"XmlResource_LoadMenu", (PyCFunction) _wrap_XmlResource_LoadMenu, METH_VARARGS | METH_KEYWORDS, NULL},
8363 { (char *)"XmlResource_LoadMenuBar", (PyCFunction) _wrap_XmlResource_LoadMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
8364 { (char *)"XmlResource_LoadMenuBarOnFrame", (PyCFunction) _wrap_XmlResource_LoadMenuBarOnFrame, METH_VARARGS | METH_KEYWORDS, NULL},
8365 { (char *)"XmlResource_LoadToolBar", (PyCFunction) _wrap_XmlResource_LoadToolBar, METH_VARARGS | METH_KEYWORDS, NULL},
8366 { (char *)"XmlResource_LoadDialog", (PyCFunction) _wrap_XmlResource_LoadDialog, METH_VARARGS | METH_KEYWORDS, NULL},
8367 { (char *)"XmlResource_LoadOnDialog", (PyCFunction) _wrap_XmlResource_LoadOnDialog, METH_VARARGS | METH_KEYWORDS, NULL},
8368 { (char *)"XmlResource_LoadPanel", (PyCFunction) _wrap_XmlResource_LoadPanel, METH_VARARGS | METH_KEYWORDS, NULL},
8369 { (char *)"XmlResource_LoadOnPanel", (PyCFunction) _wrap_XmlResource_LoadOnPanel, METH_VARARGS | METH_KEYWORDS, NULL},
8370 { (char *)"XmlResource_LoadFrame", (PyCFunction) _wrap_XmlResource_LoadFrame, METH_VARARGS | METH_KEYWORDS, NULL},
8371 { (char *)"XmlResource_LoadOnFrame", (PyCFunction) _wrap_XmlResource_LoadOnFrame, METH_VARARGS | METH_KEYWORDS, NULL},
8372 { (char *)"XmlResource_LoadObject", (PyCFunction) _wrap_XmlResource_LoadObject, METH_VARARGS | METH_KEYWORDS, NULL},
8373 { (char *)"XmlResource_LoadOnObject", (PyCFunction) _wrap_XmlResource_LoadOnObject, METH_VARARGS | METH_KEYWORDS, NULL},
8374 { (char *)"XmlResource_LoadBitmap", (PyCFunction) _wrap_XmlResource_LoadBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
8375 { (char *)"XmlResource_LoadIcon", (PyCFunction) _wrap_XmlResource_LoadIcon, METH_VARARGS | METH_KEYWORDS, NULL},
8376 { (char *)"XmlResource_AttachUnknownControl", (PyCFunction) _wrap_XmlResource_AttachUnknownControl, METH_VARARGS | METH_KEYWORDS, NULL},
8377 { (char *)"XmlResource_GetXRCID", (PyCFunction) _wrap_XmlResource_GetXRCID, METH_VARARGS | METH_KEYWORDS, NULL},
0085ce49 8378 { (char *)"XmlResource_GetVersion", (PyCFunction)_wrap_XmlResource_GetVersion, METH_O, NULL},
093d3ff1 8379 { (char *)"XmlResource_CompareVersion", (PyCFunction) _wrap_XmlResource_CompareVersion, METH_VARARGS | METH_KEYWORDS, NULL},
0085ce49 8380 { (char *)"XmlResource_Get", (PyCFunction)_wrap_XmlResource_Get, METH_NOARGS, NULL},
093d3ff1 8381 { (char *)"XmlResource_Set", (PyCFunction) _wrap_XmlResource_Set, METH_VARARGS | METH_KEYWORDS, NULL},
0085ce49 8382 { (char *)"XmlResource_GetFlags", (PyCFunction)_wrap_XmlResource_GetFlags, METH_O, NULL},
093d3ff1
RD		 8383 { (char *)"XmlResource_SetFlags", (PyCFunction) _wrap_XmlResource_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
8384 { (char *)"XmlResource_swigregister", XmlResource_swigregister, METH_VARARGS, NULL},
0085ce49
RD		 8385 { (char *)"XmlResource_swiginit", XmlResource_swiginit, METH_VARARGS, NULL},
8386 { (char *)"new_XmlSubclassFactory", (PyCFunction)_wrap_new_XmlSubclassFactory, METH_NOARGS, NULL},
093d3ff1
RD		 8387 { (char *)"XmlSubclassFactory__setCallbackInfo", (PyCFunction) _wrap_XmlSubclassFactory__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
8388 { (char *)"XmlSubclassFactory_swigregister", XmlSubclassFactory_swigregister, METH_VARARGS, NULL},
0085ce49 8389 { (char *)"XmlSubclassFactory_swiginit", XmlSubclassFactory_swiginit, METH_VARARGS, NULL},
093d3ff1 8390 { (char *)"new_XmlProperty", (PyCFunction) _wrap_new_XmlProperty, METH_VARARGS | METH_KEYWORDS, NULL},
0085ce49
RD		 8391 { (char *)"XmlProperty_GetName", (PyCFunction)_wrap_XmlProperty_GetName, METH_O, NULL},
8392 { (char *)"XmlProperty_GetValue", (PyCFunction)_wrap_XmlProperty_GetValue, METH_O, NULL},
8393 { (char *)"XmlProperty_GetNext", (PyCFunction)_wrap_XmlProperty_GetNext, METH_O, NULL},
093d3ff1
RD		 8394 { (char *)"XmlProperty_SetName", (PyCFunction) _wrap_XmlProperty_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
8395 { (char *)"XmlProperty_SetValue", (PyCFunction) _wrap_XmlProperty_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
8396 { (char *)"XmlProperty_SetNext", (PyCFunction) _wrap_XmlProperty_SetNext, METH_VARARGS | METH_KEYWORDS, NULL},
8397 { (char *)"XmlProperty_swigregister", XmlProperty_swigregister, METH_VARARGS, NULL},
0085ce49 8398 { (char *)"XmlProperty_swiginit", XmlProperty_swiginit, METH_VARARGS, NULL},
093d3ff1 8399 { (char *)"new_XmlNode", (PyCFunction) _wrap_new_XmlNode, METH_VARARGS | METH_KEYWORDS, NULL},
0085ce49 8400 { (char *)"delete_XmlNode", (PyCFunction)_wrap_delete_XmlNode, METH_O, NULL},
093d3ff1
RD		 8401 { (char *)"new_XmlNodeEasy", (PyCFunction) _wrap_new_XmlNodeEasy, METH_VARARGS | METH_KEYWORDS, NULL},
8402 { (char *)"XmlNode_AddChild", (PyCFunction) _wrap_XmlNode_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
8403 { (char *)"XmlNode_InsertChild", (PyCFunction) _wrap_XmlNode_InsertChild, METH_VARARGS | METH_KEYWORDS, NULL},
8404 { (char *)"XmlNode_RemoveChild", (PyCFunction) _wrap_XmlNode_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
8405 { (char *)"XmlNode_AddProperty", (PyCFunction) _wrap_XmlNode_AddProperty, METH_VARARGS | METH_KEYWORDS, NULL},
8406 { (char *)"XmlNode_AddPropertyName", (PyCFunction) _wrap_XmlNode_AddPropertyName, METH_VARARGS | METH_KEYWORDS, NULL},
8407 { (char *)"XmlNode_DeleteProperty", (PyCFunction) _wrap_XmlNode_DeleteProperty, METH_VARARGS | METH_KEYWORDS, NULL},
0085ce49
RD		 8408 { (char *)"XmlNode_GetType", (PyCFunction)_wrap_XmlNode_GetType, METH_O, NULL},
8409 { (char *)"XmlNode_GetName", (PyCFunction)_wrap_XmlNode_GetName, METH_O, NULL},
8410 { (char *)"XmlNode_GetContent", (PyCFunction)_wrap_XmlNode_GetContent, METH_O, NULL},
8411 { (char *)"XmlNode_GetParent", (PyCFunction)_wrap_XmlNode_GetParent, METH_O, NULL},
8412 { (char *)"XmlNode_GetNext", (PyCFunction)_wrap_XmlNode_GetNext, METH_O, NULL},
8413 { (char *)"XmlNode_GetChildren", (PyCFunction)_wrap_XmlNode_GetChildren, METH_O, NULL},
8414 { (char *)"XmlNode_GetProperties", (PyCFunction)_wrap_XmlNode_GetProperties, METH_O, NULL},
093d3ff1
RD		 8415 { (char *)"XmlNode_GetPropVal", (PyCFunction) _wrap_XmlNode_GetPropVal, METH_VARARGS | METH_KEYWORDS, NULL},
8416 { (char *)"XmlNode_HasProp", (PyCFunction) _wrap_XmlNode_HasProp, METH_VARARGS | METH_KEYWORDS, NULL},
8417 { (char *)"XmlNode_SetType", (PyCFunction) _wrap_XmlNode_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
8418 { (char *)"XmlNode_SetName", (PyCFunction) _wrap_XmlNode_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
8419 { (char *)"XmlNode_SetContent", (PyCFunction) _wrap_XmlNode_SetContent, METH_VARARGS | METH_KEYWORDS, NULL},
8420 { (char *)"XmlNode_SetParent", (PyCFunction) _wrap_XmlNode_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
8421 { (char *)"XmlNode_SetNext", (PyCFunction) _wrap_XmlNode_SetNext, METH_VARARGS | METH_KEYWORDS, NULL},
8422 { (char *)"XmlNode_SetChildren", (PyCFunction) _wrap_XmlNode_SetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
8423 { (char *)"XmlNode_SetProperties", (PyCFunction) _wrap_XmlNode_SetProperties, METH_VARARGS | METH_KEYWORDS, NULL},
8424 { (char *)"XmlNode_swigregister", XmlNode_swigregister, METH_VARARGS, NULL},
0085ce49 8425 { (char *)"XmlNode_swiginit", XmlNode_swiginit, METH_VARARGS, NULL},
093d3ff1
RD		 8426 { (char *)"new_XmlDocument", (PyCFunction) _wrap_new_XmlDocument, METH_VARARGS | METH_KEYWORDS, NULL},
8427 { (char *)"new_XmlDocumentFromStream", (PyCFunction) _wrap_new_XmlDocumentFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
0085ce49
RD		 8428 { (char *)"new_EmptyXmlDocument", (PyCFunction)_wrap_new_EmptyXmlDocument, METH_NOARGS, NULL},
8429 { (char *)"delete_XmlDocument", (PyCFunction)_wrap_delete_XmlDocument, METH_O, NULL},
093d3ff1
RD		 8430 { (char *)"XmlDocument_Load", (PyCFunction) _wrap_XmlDocument_Load, METH_VARARGS | METH_KEYWORDS, NULL},
8431 { (char *)"XmlDocument_LoadFromStream", (PyCFunction) _wrap_XmlDocument_LoadFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
8432 { (char *)"XmlDocument_Save", (PyCFunction) _wrap_XmlDocument_Save, METH_VARARGS | METH_KEYWORDS, NULL},
8433 { (char *)"XmlDocument_SaveToStream", (PyCFunction) _wrap_XmlDocument_SaveToStream, METH_VARARGS | METH_KEYWORDS, NULL},
0085ce49
RD		 8434 { (char *)"XmlDocument_IsOk", (PyCFunction)_wrap_XmlDocument_IsOk, METH_O, NULL},
8435 { (char *)"XmlDocument_GetRoot", (PyCFunction)_wrap_XmlDocument_GetRoot, METH_O, NULL},
8436 { (char *)"XmlDocument_GetVersion", (PyCFunction)_wrap_XmlDocument_GetVersion, METH_O, NULL},
8437 { (char *)"XmlDocument_GetFileEncoding", (PyCFunction)_wrap_XmlDocument_GetFileEncoding, METH_O, NULL},
093d3ff1
RD		 8438 { (char *)"XmlDocument_SetRoot", (PyCFunction) _wrap_XmlDocument_SetRoot, METH_VARARGS | METH_KEYWORDS, NULL},
8439 { (char *)"XmlDocument_SetVersion", (PyCFunction) _wrap_XmlDocument_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
8440 { (char *)"XmlDocument_SetFileEncoding", (PyCFunction) _wrap_XmlDocument_SetFileEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
8441 { (char *)"XmlDocument_swigregister", XmlDocument_swigregister, METH_VARARGS, NULL},
0085ce49
RD		 8442 { (char *)"XmlDocument_swiginit", XmlDocument_swiginit, METH_VARARGS, NULL},
8443 { (char *)"new_XmlResourceHandler", (PyCFunction)_wrap_new_XmlResourceHandler, METH_NOARGS, NULL},
093d3ff1
RD		 8444 { (char *)"XmlResourceHandler__setCallbackInfo", (PyCFunction) _wrap_XmlResourceHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
8445 { (char *)"XmlResourceHandler_CreateResource", (PyCFunction) _wrap_XmlResourceHandler_CreateResource, METH_VARARGS | METH_KEYWORDS, NULL},
8446 { (char *)"XmlResourceHandler_SetParentResource", (PyCFunction) _wrap_XmlResourceHandler_SetParentResource, METH_VARARGS | METH_KEYWORDS, NULL},
0085ce49
RD		 8447 { (char *)"XmlResourceHandler_GetResource", (PyCFunction)_wrap_XmlResourceHandler_GetResource, METH_O, NULL},
8448 { (char *)"XmlResourceHandler_GetNode", (PyCFunction)_wrap_XmlResourceHandler_GetNode, METH_O, NULL},
8449 { (char *)"XmlResourceHandler_GetClass", (PyCFunction)_wrap_XmlResourceHandler_GetClass, METH_O, NULL},
8450 { (char *)"XmlResourceHandler_GetParent", (PyCFunction)_wrap_XmlResourceHandler_GetParent, METH_O, NULL},
8451 { (char *)"XmlResourceHandler_GetInstance", (PyCFunction)_wrap_XmlResourceHandler_GetInstance, METH_O, NULL},
8452 { (char *)"XmlResourceHandler_GetParentAsWindow", (PyCFunction)_wrap_XmlResourceHandler_GetParentAsWindow, METH_O, NULL},
093d3ff1
RD		 8453 { (char *)"XmlResourceHandler_IsOfClass", (PyCFunction) _wrap_XmlResourceHandler_IsOfClass, METH_VARARGS | METH_KEYWORDS, NULL},
8454 { (char *)"XmlResourceHandler_GetNodeContent", (PyCFunction) _wrap_XmlResourceHandler_GetNodeContent, METH_VARARGS | METH_KEYWORDS, NULL},
8455 { (char *)"XmlResourceHandler_HasParam", (PyCFunction) _wrap_XmlResourceHandler_HasParam, METH_VARARGS | METH_KEYWORDS, NULL},
8456 { (char *)"XmlResourceHandler_GetParamNode", (PyCFunction) _wrap_XmlResourceHandler_GetParamNode, METH_VARARGS | METH_KEYWORDS, NULL},
8457 { (char *)"XmlResourceHandler_GetParamValue", (PyCFunction) _wrap_XmlResourceHandler_GetParamValue, METH_VARARGS | METH_KEYWORDS, NULL},
8458 { (char *)"XmlResourceHandler_AddStyle", (PyCFunction) _wrap_XmlResourceHandler_AddStyle, METH_VARARGS | METH_KEYWORDS, NULL},
0085ce49 8459 { (char *)"XmlResourceHandler_AddWindowStyles", (PyCFunction)_wrap_XmlResourceHandler_AddWindowStyles, METH_O, NULL},
093d3ff1
RD		 8460 { (char *)"XmlResourceHandler_GetStyle", (PyCFunction) _wrap_XmlResourceHandler_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
8461 { (char *)"XmlResourceHandler_GetText", (PyCFunction) _wrap_XmlResourceHandler_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
0085ce49
RD		 8462 { (char *)"XmlResourceHandler_GetID", (PyCFunction)_wrap_XmlResourceHandler_GetID, METH_O, NULL},
8463 { (char *)"XmlResourceHandler_GetName", (PyCFunction)_wrap_XmlResourceHandler_GetName, METH_O, NULL},
093d3ff1
RD		 8464 { (char *)"XmlResourceHandler_GetBool", (PyCFunction) _wrap_XmlResourceHandler_GetBool, METH_VARARGS | METH_KEYWORDS, NULL},
8465 { (char *)"XmlResourceHandler_GetLong", (PyCFunction) _wrap_XmlResourceHandler_GetLong, METH_VARARGS | METH_KEYWORDS, NULL},
8466 { (char *)"XmlResourceHandler_GetColour", (PyCFunction) _wrap_XmlResourceHandler_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
8467 { (char *)"XmlResourceHandler_GetSize", (PyCFunction) _wrap_XmlResourceHandler_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
8468 { (char *)"XmlResourceHandler_GetPosition", (PyCFunction) _wrap_XmlResourceHandler_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
8469 { (char *)"XmlResourceHandler_GetDimension", (PyCFunction) _wrap_XmlResourceHandler_GetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
8470 { (char *)"XmlResourceHandler_GetBitmap", (PyCFunction) _wrap_XmlResourceHandler_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
8471 { (char *)"XmlResourceHandler_GetIcon", (PyCFunction) _wrap_XmlResourceHandler_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
8472 { (char *)"XmlResourceHandler_GetFont", (PyCFunction) _wrap_XmlResourceHandler_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
8473 { (char *)"XmlResourceHandler_SetupWindow", (PyCFunction) _wrap_XmlResourceHandler_SetupWindow, METH_VARARGS | METH_KEYWORDS, NULL},
8474 { (char *)"XmlResourceHandler_CreateChildren", (PyCFunction) _wrap_XmlResourceHandler_CreateChildren, METH_VARARGS | METH_KEYWORDS, NULL},
8475 { (char *)"XmlResourceHandler_CreateChildrenPrivately", (PyCFunction) _wrap_XmlResourceHandler_CreateChildrenPrivately, METH_VARARGS | METH_KEYWORDS, NULL},
8476 { (char *)"XmlResourceHandler_CreateResFromNode", (PyCFunction) _wrap_XmlResourceHandler_CreateResFromNode, METH_VARARGS | METH_KEYWORDS, NULL},
0085ce49 8477 { (char *)"XmlResourceHandler_GetCurFileSystem", (PyCFunction)_wrap_XmlResourceHandler_GetCurFileSystem, METH_O, NULL},
093d3ff1 8478 { (char *)"XmlResourceHandler_swigregister", XmlResourceHandler_swigregister, METH_VARARGS, NULL},
0085ce49 8479 { (char *)"XmlResourceHandler_swiginit", XmlResourceHandler_swiginit, METH_VARARGS, NULL},
2ef75293
RD		 8480 { NULL, NULL, 0, NULL }
8481};
8482
8483
8484/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
8485
8486static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
8487 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
8488}
8489static void *_p_wxXmlDocumentTo_p_wxObject(void *x) {
8490 return (void *)((wxObject *) ((wxXmlDocument *) x));
8491}
2ef75293
RD		 8492static void *_p_wxSizerItemTo_p_wxObject(void *x) {
8493 return (void *)((wxObject *) ((wxSizerItem *) x));
8494}
34e0a3bb
RD		 8495static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
8496 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
8497}
2ef75293
RD		 8498static void *_p_wxScrollEventTo_p_wxObject(void *x) {
8499 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
8500}
8501static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
8502 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
8503}
8504static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
8505 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
8506}
8507static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
8508 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
8509}
8510static void *_p_wxSizerTo_p_wxObject(void *x) {
8511 return (void *)((wxObject *) ((wxSizer *) x));
8512}
8513static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
8514 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
8515}
8516static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
8517 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
8518}
8519static void *_p_wxEventTo_p_wxObject(void *x) {
8520 return (void *)((wxObject *) ((wxEvent *) x));
8521}
8522static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
8523 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
8524}
8525static void *_p_wxGridSizerTo_p_wxObject(void *x) {
8526 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
8527}
8528static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
8529 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
8530}
2131d850
RD		 8531static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
8532 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
8533}
2ef75293
RD		 8534static void *_p_wxPaintEventTo_p_wxObject(void *x) {
8535 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
8536}
8537static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
8538 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
8539}
8540static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
8541 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
8542}
8543static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
8544 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
8545}
8546static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
8547 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
8548}
8549static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
8550 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
8551}
8552static void *_p_wxControlTo_p_wxObject(void *x) {
8553 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
8554}
8555static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
8556 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
8557}
8558static void *_p_wxFSFileTo_p_wxObject(void *x) {
8559 return (void *)((wxObject *) ((wxFSFile *) x));
8560}
8561static void *_p_wxPySizerTo_p_wxObject(void *x) {
8562 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
8563}
8564static void *_p_wxPyEventTo_p_wxObject(void *x) {
8565 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
8566}
8567static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
8568 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
8569}
8570static void *_p_wxShowEventTo_p_wxObject(void *x) {
8571 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
8572}
8573static void *_p_wxMenuItemTo_p_wxObject(void *x) {
8574 return (void *)((wxObject *) ((wxMenuItem *) x));
8575}
53aa7709
RD		 8576static void *_p_wxDateEventTo_p_wxObject(void *x) {
8577 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
8578}
2ef75293
RD		 8579static void *_p_wxIdleEventTo_p_wxObject(void *x) {
8580 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
8581}
8582static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
8583 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
8584}
8585static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
8586 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
8587}
8588static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
8589 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
8590}
8591static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
8592 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
8593}
8594static void *_p_wxSizeEventTo_p_wxObject(void *x) {
8595 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
8596}
8597static void *_p_wxMoveEventTo_p_wxObject(void *x) {
8598 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
8599}
8600static void *_p_wxActivateEventTo_p_wxObject(void *x) {
8601 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
8602}
2ef75293
RD		 8603static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
8604 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
8605}
8606static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
8607 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
8608}
8609static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
8610 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
8611}
8612static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
8613 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
8614}
8615static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
8616 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
8617}
8618static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
8619 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
8620}
8621static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
8622 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
8623}
8624static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
8625 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
8626}
8627static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
8628 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
8629}
943e8dfd
RD		 8630static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
8631 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
8632}
2ef75293
RD		 8633static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
8634 return (void *)((wxObject *) ((wxImageHandler *) x));
8635}
943e8dfd
RD		 8636static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
8637 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
8638}
2ef75293
RD		 8639static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
8640 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
8641}
8642static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
8643 return (void *)((wxObject *) ((wxEvtHandler *) x));
8644}
34e0a3bb
RD		 8645static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
8646 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
8647}
2ef75293
RD		 8648static void *_p_wxPyXmlResourceHandlerTo_p_wxObject(void *x) {
8649 return (void *)((wxObject *) ((wxPyXmlResourceHandler *) x));
8650}
51b83b37
RD		 8651static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
8652 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
8653}
2ef75293
RD		 8654static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
8655 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
8656}
8657static void *_p_wxImageTo_p_wxObject(void *x) {
8658 return (void *)((wxObject *) ((wxImage *) x));
8659}
8660static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
8661 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
8662}
8663static void *_p_wxXmlResourceTo_p_wxObject(void *x) {
8664 return (void *)((wxObject *) ((wxXmlResource *) x));
8665}
8666static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
8667 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
8668}
8669static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
8670 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
8671}
8672static void *_p_wxKeyEventTo_p_wxObject(void *x) {
8673 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
8674}
8675static void *_p_wxWindowTo_p_wxObject(void *x) {
8676 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
8677}
8678static void *_p_wxMenuTo_p_wxObject(void *x) {
8679 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
8680}
8681static void *_p_wxMenuBarTo_p_wxObject(void *x) {
8682 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
8683}
8684static void *_p_wxFileSystemTo_p_wxObject(void *x) {
8685 return (void *)((wxObject *) ((wxFileSystem *) x));
8686}
8687static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
8688 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
8689}
8690static void *_p_wxMenuEventTo_p_wxObject(void *x) {
8691 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
8692}
8693static void *_p_wxPyAppTo_p_wxObject(void *x) {
8694 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
8695}
8696static void *_p_wxCloseEventTo_p_wxObject(void *x) {
8697 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
8698}
8699static void *_p_wxMouseEventTo_p_wxObject(void *x) {
8700 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
8701}
8702static void *_p_wxEraseEventTo_p_wxObject(void *x) {
8703 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
8704}
8705static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
8706 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
8707}
8708static void *_p_wxCommandEventTo_p_wxObject(void *x) {
8709 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
8710}
8711static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
8712 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
8713}
8714static void *_p_wxFocusEventTo_p_wxObject(void *x) {
8715 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
8716}
8717static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
8718 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
8719}
8720static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
8721 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
8722}
8723static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
8724 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
8725}
8726static void *_p_wxValidatorTo_p_wxObject(void *x) {
8727 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
8728}
2131d850
RD		 8729static void *_p_wxControlTo_p_wxWindow(void *x) {
8730 return (void *)((wxWindow *) ((wxControl *) x));
8731}
8732static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
8733 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
8734}
8735static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
8736 return (void *)((wxWindow *) ((wxMenuBar *) x));
8737}
0085ce49
RD		 8738static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
8739static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, (void*)0, 0};
8740static swig_type_info _swigt__p_int = {"_p_int", "int *|wxEventType *", 0, 0, (void*)0, 0};
8741static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
8742static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
8743static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
8744static swig_type_info _swigt__p_wxArtClient = {"_p_wxArtClient", "wxArtClient *", 0, 0, (void*)0, 0};
8745static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
8746static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
8747static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", "wxDialog *", 0, 0, (void*)0, 0};
8748static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
8749static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
8750static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
8751static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
8752static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
8753static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
8754static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
8755static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
0085ce49 8756static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
34e0a3bb 8757static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
0085ce49
RD		 8758static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
8759static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
8760static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
8761static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
8762static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
8763static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
8764static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
8765static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", 0, 0, 0, 0, 0};
8766static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", 0, 0, 0, 0, 0};
8767static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
8768static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
8769static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
2131d850 8770static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
0085ce49
RD		 8771static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
8772static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
8773static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
8774static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
8775static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
8776static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
8777static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
8778static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
8779static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
8780static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
8781static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
8782static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
8783static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
8784static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
0085ce49
RD		 8785static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
8786static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
8787static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
2131d850 8788static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
0085ce49
RD		 8789static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
8790static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
2131d850 8791static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
0085ce49
RD		 8792static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
8793static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
0085ce49
RD		 8794static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
8795static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
8796static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
8797static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
8798static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
8799static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
8800static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
8801static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
8802static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
8803static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
8804static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
8805static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
8806static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
8807static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", 0, 0, 0, 0, 0};
34e0a3bb 8808static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
0085ce49
RD		 8809static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
8810static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
8811static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
8812static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
8813static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
8814static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
8815static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
8816static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
8817static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
8818static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
8819static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
0085ce49
RD		 8820static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
8821static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
34e0a3bb 8822static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
0085ce49 8823static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
2131d850 8824static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
0085ce49
RD		 8825static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
8826static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
8827static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
8828static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
8829static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
8830static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
8831static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
8832static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", "wxPanel *", 0, 0, (void*)0, 0};
8833static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
8834static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
8835static swig_type_info _swigt__p_wxPyXmlResourceHandler = {"_p_wxPyXmlResourceHandler", "wxPyXmlResourceHandler *", 0, 0, (void*)0, 0};
8836static swig_type_info _swigt__p_wxPyXmlSubclassFactory = {"_p_wxPyXmlSubclassFactory", "wxPyXmlSubclassFactory *", 0, 0, (void*)0, 0};
8837static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
8838static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
8839static swig_type_info _swigt__p_wxXmlDocument = {"_p_wxXmlDocument", "wxXmlDocument *", 0, 0, (void*)0, 0};
8840static swig_type_info _swigt__p_wxXmlNode = {"_p_wxXmlNode", "wxXmlNode *", 0, 0, (void*)0, 0};
8841static swig_type_info _swigt__p_wxXmlProperty = {"_p_wxXmlProperty", "wxXmlProperty *", 0, 0, (void*)0, 0};
8842static swig_type_info _swigt__p_wxXmlResource = {"_p_wxXmlResource", "wxXmlResource *", 0, 0, (void*)0, 0};
32fe5131
RD		 8843
8844static swig_type_info *swig_type_initial[] = {
8845 &_swigt__p_char,
8846 &_swigt__p_form_ops_t,
8847 &_swigt__p_int,
8848 &_swigt__p_unsigned_char,
8849 &_swigt__p_unsigned_int,
8850 &_swigt__p_unsigned_long,
8851 &_swigt__p_wxANIHandler,
8852 &_swigt__p_wxAcceleratorTable,
8853 &_swigt__p_wxActivateEvent,
8854 &_swigt__p_wxArtClient,
8855 &_swigt__p_wxBMPHandler,
8856 &_swigt__p_wxBitmap,
8857 &_swigt__p_wxBoxSizer,
8858 &_swigt__p_wxCURHandler,
8859 &_swigt__p_wxChildFocusEvent,
2131d850 8860 &_swigt__p_wxClipboardTextEvent,
32fe5131
RD		 8861 &_swigt__p_wxCloseEvent,
8862 &_swigt__p_wxColour,
8863 &_swigt__p_wxCommandEvent,
8864 &_swigt__p_wxContextMenuEvent,
8865 &_swigt__p_wxControl,
8866 &_swigt__p_wxControlWithItems,
8867 &_swigt__p_wxDateEvent,
8868 &_swigt__p_wxDialog,
8869 &_swigt__p_wxDisplayChangedEvent,
8870 &_swigt__p_wxDropFilesEvent,
8871 &_swigt__p_wxDuplexMode,
8872 &_swigt__p_wxEraseEvent,
8873 &_swigt__p_wxEvent,
8874 &_swigt__p_wxEvtHandler,
8875 &_swigt__p_wxFSFile,
8876 &_swigt__p_wxFileSystem,
8877 &_swigt__p_wxFlexGridSizer,
8878 &_swigt__p_wxFocusEvent,
8879 &_swigt__p_wxFont,
8880 &_swigt__p_wxFrame,
8881 &_swigt__p_wxGBSizerItem,
8882 &_swigt__p_wxGIFHandler,
8883 &_swigt__p_wxGridBagSizer,
8884 &_swigt__p_wxGridSizer,
8885 &_swigt__p_wxICOHandler,
8886 &_swigt__p_wxIcon,
8887 &_swigt__p_wxIconizeEvent,
8888 &_swigt__p_wxIdleEvent,
8889 &_swigt__p_wxImage,
8890 &_swigt__p_wxImageHandler,
8891 &_swigt__p_wxIndividualLayoutConstraint,
8892 &_swigt__p_wxInitDialogEvent,
8893 &_swigt__p_wxInputStream,
8894 &_swigt__p_wxJPEGHandler,
8895 &_swigt__p_wxKeyEvent,
8896 &_swigt__p_wxLayoutConstraints,
8897 &_swigt__p_wxMaximizeEvent,
8898 &_swigt__p_wxMenu,
8899 &_swigt__p_wxMenuBar,
8900 &_swigt__p_wxMenuEvent,
8901 &_swigt__p_wxMenuItem,
8902 &_swigt__p_wxMouseCaptureChangedEvent,
34e0a3bb 8903 &_swigt__p_wxMouseCaptureLostEvent,
32fe5131
RD		 8904 &_swigt__p_wxMouseEvent,
8905 &_swigt__p_wxMoveEvent,
8906 &_swigt__p_wxNavigationKeyEvent,
8907 &_swigt__p_wxNcPaintEvent,
8908 &_swigt__p_wxNotifyEvent,
8909 &_swigt__p_wxObject,
8910 &_swigt__p_wxOutputStream,
8911 &_swigt__p_wxPCXHandler,
8912 &_swigt__p_wxPNGHandler,
8913 &_swigt__p_wxPNMHandler,
8914 &_swigt__p_wxPaintEvent,
8915 &_swigt__p_wxPaletteChangedEvent,
8916 &_swigt__p_wxPanel,
8917 &_swigt__p_wxPaperSize,
8918 &_swigt__p_wxPoint,
8919 &_swigt__p_wxPyApp,
8920 &_swigt__p_wxPyCommandEvent,
8921 &_swigt__p_wxPyEvent,
8922 &_swigt__p_wxPyImageHandler,
8923 &_swigt__p_wxPySizer,
8924 &_swigt__p_wxPyValidator,
8925 &_swigt__p_wxPyXmlResourceHandler,
8926 &_swigt__p_wxPyXmlSubclassFactory,
8927 &_swigt__p_wxQueryNewPaletteEvent,
8928 &_swigt__p_wxScrollEvent,
8929 &_swigt__p_wxScrollWinEvent,
8930 &_swigt__p_wxSetCursorEvent,
8931 &_swigt__p_wxShowEvent,
8932 &_swigt__p_wxSize,
8933 &_swigt__p_wxSizeEvent,
8934 &_swigt__p_wxSizer,
8935 &_swigt__p_wxSizerItem,
8936 &_swigt__p_wxStaticBoxSizer,
8937 &_swigt__p_wxStdDialogButtonSizer,
8938 &_swigt__p_wxSysColourChangedEvent,
8939 &_swigt__p_wxTIFFHandler,
8940 &_swigt__p_wxUpdateUIEvent,
8941 &_swigt__p_wxValidator,
8942 &_swigt__p_wxWindow,
8943 &_swigt__p_wxWindowCreateEvent,
8944 &_swigt__p_wxWindowDestroyEvent,
8945 &_swigt__p_wxXPMHandler,
8946 &_swigt__p_wxXmlDocument,
8947 &_swigt__p_wxXmlNode,
8948 &_swigt__p_wxXmlProperty,
8949 &_swigt__p_wxXmlResource,
32fe5131
RD		 8950};
8951
8952static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
8953static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
8954static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
8955static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
8956static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
8957static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
8958static swig_cast_info _swigc__p_wxArtClient[] = { {&_swigt__p_wxArtClient, 0, 0, 0},{0, 0, 0, 0}};
8959static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
8960static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
8961static swig_cast_info _swigc__p_wxDialog[] = { {&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};
8962static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
8963static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
8964static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
8965static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
8966static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
8967static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
8968static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
32fe5131 8969static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
34e0a3bb 8970static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
32fe5131
RD		 8971static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
8972static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
8973static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
8974static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
8975static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
8976static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
8977static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
8978static swig_cast_info _swigc__p_wxMenu[] = {{&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
8979static swig_cast_info _swigc__p_wxEvent[] = {{&_swigt__p_wxEvent, 0, 0, 0},{0, 0, 0, 0}};
8980static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
8981static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
8982static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
2131d850 8983static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
32fe5131
RD		 8984static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
8985static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
8986static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
8987static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
8988static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
8989static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
8990static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
8991static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
8992static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
8993static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
8994static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
8995static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
8996static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
8997static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
32fe5131
RD		 8998static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
8999static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
9000static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
2131d850 9001static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
32fe5131
RD		 9002static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
9003static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
2131d850 9004static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
32fe5131
RD		 9005static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
9006static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
32fe5131
RD		 9007static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
9008static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
9009static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
9010static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
9011static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
9012static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
9013static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
9014static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
9015static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
9016static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
9017static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
9018static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
9019static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
9020static swig_cast_info _swigc__p_wxEvtHandler[] = {{&_swigt__p_wxEvtHandler, 0, 0, 0},{0, 0, 0, 0}};
34e0a3bb 9021static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
32fe5131
RD		 9022static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
9023static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
9024static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
9025static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
9026static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
9027static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
9028static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
9029static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
9030static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
9031static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
9032static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
32fe5131
RD		 9033static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
9034static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
34e0a3bb 9035static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
32fe5131 9036static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
2131d850 9037static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
32fe5131
RD		 9038static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
9039static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
9040static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
9041static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
9042static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
9043static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
34e0a3bb 9044static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxXmlDocument, _p_wxXmlDocumentTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyXmlResourceHandler, _p_wxPyXmlResourceHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxXmlResource, _p_wxXmlResourceTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
32fe5131
RD		 9045static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
9046static swig_cast_info _swigc__p_wxPanel[] = { {&_swigt__p_wxPanel, 0, 0, 0},{0, 0, 0, 0}};
9047static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
9048static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
9049static swig_cast_info _swigc__p_wxPyXmlResourceHandler[] = { {&_swigt__p_wxPyXmlResourceHandler, 0, 0, 0},{0, 0, 0, 0}};
9050static swig_cast_info _swigc__p_wxPyXmlSubclassFactory[] = { {&_swigt__p_wxPyXmlSubclassFactory, 0, 0, 0},{0, 0, 0, 0}};
9051static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
9052static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
9053static swig_cast_info _swigc__p_wxXmlDocument[] = { {&_swigt__p_wxXmlDocument, 0, 0, 0},{0, 0, 0, 0}};
9054static swig_cast_info _swigc__p_wxXmlNode[] = { {&_swigt__p_wxXmlNode, 0, 0, 0},{0, 0, 0, 0}};
9055static swig_cast_info _swigc__p_wxXmlProperty[] = { {&_swigt__p_wxXmlProperty, 0, 0, 0},{0, 0, 0, 0}};
9056static swig_cast_info _swigc__p_wxXmlResource[] = { {&_swigt__p_wxXmlResource, 0, 0, 0},{0, 0, 0, 0}};
32fe5131
RD		 9057
9058static swig_cast_info *swig_cast_initial[] = {
9059 _swigc__p_char,
9060 _swigc__p_form_ops_t,
9061 _swigc__p_int,
9062 _swigc__p_unsigned_char,
9063 _swigc__p_unsigned_int,
9064 _swigc__p_unsigned_long,
9065 _swigc__p_wxANIHandler,
9066 _swigc__p_wxAcceleratorTable,
9067 _swigc__p_wxActivateEvent,
9068 _swigc__p_wxArtClient,
9069 _swigc__p_wxBMPHandler,
9070 _swigc__p_wxBitmap,
9071 _swigc__p_wxBoxSizer,
9072 _swigc__p_wxCURHandler,
9073 _swigc__p_wxChildFocusEvent,
2131d850 9074 _swigc__p_wxClipboardTextEvent,
32fe5131
RD		 9075 _swigc__p_wxCloseEvent,
9076 _swigc__p_wxColour,
9077 _swigc__p_wxCommandEvent,
9078 _swigc__p_wxContextMenuEvent,
9079 _swigc__p_wxControl,
9080 _swigc__p_wxControlWithItems,
9081 _swigc__p_wxDateEvent,
9082 _swigc__p_wxDialog,
9083 _swigc__p_wxDisplayChangedEvent,
9084 _swigc__p_wxDropFilesEvent,
9085 _swigc__p_wxDuplexMode,
9086 _swigc__p_wxEraseEvent,
9087 _swigc__p_wxEvent,
9088 _swigc__p_wxEvtHandler,
9089 _swigc__p_wxFSFile,
9090 _swigc__p_wxFileSystem,
9091 _swigc__p_wxFlexGridSizer,
9092 _swigc__p_wxFocusEvent,
9093 _swigc__p_wxFont,
9094 _swigc__p_wxFrame,
9095 _swigc__p_wxGBSizerItem,
9096 _swigc__p_wxGIFHandler,
9097 _swigc__p_wxGridBagSizer,
9098 _swigc__p_wxGridSizer,
9099 _swigc__p_wxICOHandler,
9100 _swigc__p_wxIcon,
9101 _swigc__p_wxIconizeEvent,
9102 _swigc__p_wxIdleEvent,
9103 _swigc__p_wxImage,
9104 _swigc__p_wxImageHandler,
9105 _swigc__p_wxIndividualLayoutConstraint,
9106 _swigc__p_wxInitDialogEvent,
9107 _swigc__p_wxInputStream,
9108 _swigc__p_wxJPEGHandler,
9109 _swigc__p_wxKeyEvent,
9110 _swigc__p_wxLayoutConstraints,
9111 _swigc__p_wxMaximizeEvent,
9112 _swigc__p_wxMenu,
9113 _swigc__p_wxMenuBar,
9114 _swigc__p_wxMenuEvent,
9115 _swigc__p_wxMenuItem,
9116 _swigc__p_wxMouseCaptureChangedEvent,
34e0a3bb 9117 _swigc__p_wxMouseCaptureLostEvent,
32fe5131
RD		 9118 _swigc__p_wxMouseEvent,
9119 _swigc__p_wxMoveEvent,
9120 _swigc__p_wxNavigationKeyEvent,
9121 _swigc__p_wxNcPaintEvent,
9122 _swigc__p_wxNotifyEvent,
9123 _swigc__p_wxObject,
9124 _swigc__p_wxOutputStream,
9125 _swigc__p_wxPCXHandler,
9126 _swigc__p_wxPNGHandler,
9127 _swigc__p_wxPNMHandler,
9128 _swigc__p_wxPaintEvent,
9129 _swigc__p_wxPaletteChangedEvent,
9130 _swigc__p_wxPanel,
9131 _swigc__p_wxPaperSize,
9132 _swigc__p_wxPoint,
9133 _swigc__p_wxPyApp,
9134 _swigc__p_wxPyCommandEvent,
9135 _swigc__p_wxPyEvent,
9136 _swigc__p_wxPyImageHandler,
9137 _swigc__p_wxPySizer,
9138 _swigc__p_wxPyValidator,
9139 _swigc__p_wxPyXmlResourceHandler,
9140 _swigc__p_wxPyXmlSubclassFactory,
9141 _swigc__p_wxQueryNewPaletteEvent,
9142 _swigc__p_wxScrollEvent,
9143 _swigc__p_wxScrollWinEvent,
9144 _swigc__p_wxSetCursorEvent,
9145 _swigc__p_wxShowEvent,
9146 _swigc__p_wxSize,
9147 _swigc__p_wxSizeEvent,
9148 _swigc__p_wxSizer,
9149 _swigc__p_wxSizerItem,
9150 _swigc__p_wxStaticBoxSizer,
9151 _swigc__p_wxStdDialogButtonSizer,
9152 _swigc__p_wxSysColourChangedEvent,
9153 _swigc__p_wxTIFFHandler,
9154 _swigc__p_wxUpdateUIEvent,
9155 _swigc__p_wxValidator,
9156 _swigc__p_wxWindow,
9157 _swigc__p_wxWindowCreateEvent,
9158 _swigc__p_wxWindowDestroyEvent,
9159 _swigc__p_wxXPMHandler,
9160 _swigc__p_wxXmlDocument,
9161 _swigc__p_wxXmlNode,
9162 _swigc__p_wxXmlProperty,
9163 _swigc__p_wxXmlResource,
2ef75293
RD		 9164};
9165
9166
9167/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
9168
9169static swig_const_info swig_const_table[] = {
9170{0, 0, 0, 0.0, 0, 0}};
9171
9172#ifdef __cplusplus
9173}
9174#endif
0085ce49 9175/* -----------------------------------------------------------------------------
32fe5131
RD		 9176 * Type initialization:
9177 * This problem is tough by the requirement that no dynamic
9178 * memory is used. Also, since swig_type_info structures store pointers to
9179 * swig_cast_info structures and swig_cast_info structures store pointers back
9180 * to swig_type_info structures, we need some lookup code at initialization.
9181 * The idea is that swig generates all the structures that are needed.
9182 * The runtime then collects these partially filled structures.
9183 * The SWIG_InitializeModule function takes these initial arrays out of
9184 * swig_module, and does all the lookup, filling in the swig_module.types
9185 * array with the correct data and linking the correct swig_cast_info
9186 * structures together.
0085ce49 9187 *
32fe5131
RD		 9188 * The generated swig_type_info structures are assigned staticly to an initial
9189 * array. We just loop though that array, and handle each type individually.
9190 * First we lookup if this type has been already loaded, and if so, use the
9191 * loaded structure instead of the generated one. Then we have to fill in the
9192 * cast linked list. The cast data is initially stored in something like a
9193 * two-dimensional array. Each row corresponds to a type (there are the same
9194 * number of rows as there are in the swig_type_initial array). Each entry in
9195 * a column is one of the swig_cast_info structures for that type.
9196 * The cast_initial array is actually an array of arrays, because each row has
9197 * a variable number of columns. So to actually build the cast linked list,
9198 * we find the array of casts associated with the type, and loop through it
9199 * adding the casts to the list. The one last trick we need to do is making
9200 * sure the type pointer in the swig_cast_info struct is correct.
0085ce49 9201 *
32fe5131
RD		 9202 * First off, we lookup the cast->type name to see if it is already loaded.
9203 * There are three cases to handle:
9204 * 1) If the cast->type has already been loaded AND the type we are adding
9205 * casting info to has not been loaded (it is in this module), THEN we
9206 * replace the cast->type pointer with the type pointer that has already
9207 * been loaded.
9208 * 2) If BOTH types (the one we are adding casting info to, and the
9209 * cast->type) are loaded, THEN the cast info has already been loaded by
9210 * the previous module so we just ignore it.
9211 * 3) Finally, if cast->type has not already been loaded, then we add that
9212 * swig_cast_info to the linked list (because the cast->type) pointer will
9213 * be correct.
0085ce49 9214 * ----------------------------------------------------------------------------- */
32fe5131
RD		 9215
9216#ifdef __cplusplus
9217extern "C" {
9218#if 0
9219} /* c-mode */
9220#endif
9221#endif
9222
9223#if 0
9224#define SWIGRUNTIME_DEBUG
9225#endif
9226
9227SWIGRUNTIME void
9228SWIG_InitializeModule(void *clientdata) {
0085ce49
RD		 9229 size_t i;
9230 swig_module_info *module_head;
9231 static int init_run = 0;
9232
9233 clientdata = clientdata;
9234
9235 if (init_run) return;
9236 init_run = 1;
9237
9238 /* Initialize the swig_module */
9239 swig_module.type_initial = swig_type_initial;
9240 swig_module.cast_initial = swig_cast_initial;
9241
9242 /* Try and load any already created modules */
9243 module_head = SWIG_GetModule(clientdata);
9244 if (module_head) {
9245 swig_module.next = module_head->next;
9246 module_head->next = &swig_module;
9247 } else {
9248 /* This is the first module loaded */
9249 swig_module.next = &swig_module;
9250 SWIG_SetModule(clientdata, &swig_module);
9251 }
9252
9253 /* Now work on filling in swig_module.types */
32fe5131 9254#ifdef SWIGRUNTIME_DEBUG
0085ce49 9255 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
32fe5131 9256#endif
0085ce49
RD		 9257 for (i = 0; i < swig_module.size; ++i) {
9258 swig_type_info *type = 0;
9259 swig_type_info *ret;
9260 swig_cast_info *cast;
9261
32fe5131 9262#ifdef SWIGRUNTIME_DEBUG
0085ce49 9263 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
32fe5131 9264#endif
0085ce49
RD		 9265
9266 /* if there is another module already loaded */
9267 if (swig_module.next != &swig_module) {
9268 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
9269 }
9270 if (type) {
9271 /* Overwrite clientdata field */
32fe5131 9272#ifdef SWIGRUNTIME_DEBUG
0085ce49 9273 printf("SWIG_InitializeModule: found type %s\n", type->name);
32fe5131 9274#endif
0085ce49
RD		 9275 if (swig_module.type_initial[i]->clientdata) {
9276 type->clientdata = swig_module.type_initial[i]->clientdata;
32fe5131 9277#ifdef SWIGRUNTIME_DEBUG
0085ce49 9278 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
32fe5131 9279#endif
0085ce49
RD		 9280 }
9281 } else {
9282 type = swig_module.type_initial[i];
9283 }
9284
9285 /* Insert casting types */
9286 cast = swig_module.cast_initial[i];
9287 while (cast->type) {
9288 /* Don't need to add information already in the list */
9289 ret = 0;
32fe5131 9290#ifdef SWIGRUNTIME_DEBUG
0085ce49 9291 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
32fe5131 9292#endif
0085ce49
RD		 9293 if (swig_module.next != &swig_module) {
9294 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
32fe5131 9295#ifdef SWIGRUNTIME_DEBUG
0085ce49 9296 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
32fe5131 9297#endif
0085ce49
RD		 9298 }
9299 if (ret) {
9300 if (type == swig_module.type_initial[i]) {
32fe5131 9301#ifdef SWIGRUNTIME_DEBUG
0085ce49 9302 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
32fe5131 9303#endif
0085ce49
RD		 9304 cast->type = ret;
9305 ret = 0;
9306 } else {
9307 /* Check for casting already in the list */
9308 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
32fe5131 9309#ifdef SWIGRUNTIME_DEBUG
0085ce49 9310 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
32fe5131 9311#endif
0085ce49
RD		 9312 if (!ocast) ret = 0;
9313 }
9314 }
9315
9316 if (!ret) {
32fe5131 9317#ifdef SWIGRUNTIME_DEBUG
0085ce49 9318 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
32fe5131 9319#endif
0085ce49
RD		 9320 if (type->cast) {
9321 type->cast->prev = cast;
9322 cast->next = type->cast;
32fe5131 9323 }
0085ce49
RD		 9324 type->cast = cast;
9325 }
9326 cast++;
32fe5131 9327 }
0085ce49
RD		 9328 /* Set entry in modules->types array equal to the type */
9329 swig_module.types[i] = type;
9330 }
9331 swig_module.types[i] = 0;
9332
32fe5131 9333#ifdef SWIGRUNTIME_DEBUG
0085ce49
RD		 9334 printf("**** SWIG_InitializeModule: Cast List ******\n");
9335 for (i = 0; i < swig_module.size; ++i) {
9336 int j = 0;
9337 swig_cast_info *cast = swig_module.cast_initial[i];
9338 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
9339 while (cast->type) {
9340 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
9341 cast++;
9342 ++j;
9343 }
9344 printf("---- Total casts: %d\n",j);
9345 }
9346 printf("**** SWIG_InitializeModule: Cast List ******\n");
32fe5131
RD		 9347#endif
9348}
9349
9350/* This function will propagate the clientdata field of type to
9351* any new swig_type_info structures that have been added into the list
9352* of equivalent types. It is like calling
9353* SWIG_TypeClientData(type, clientdata) a second time.
9354*/
9355SWIGRUNTIME void
9356SWIG_PropagateClientData(void) {
0085ce49
RD		 9357 size_t i;
9358 swig_cast_info *equiv;
9359 static int init_run = 0;
9360
9361 if (init_run) return;
9362 init_run = 1;
9363
9364 for (i = 0; i < swig_module.size; i++) {
9365 if (swig_module.types[i]->clientdata) {
9366 equiv = swig_module.types[i]->cast;
9367 while (equiv) {
9368 if (!equiv->converter) {
9369 if (equiv->type && !equiv->type->clientdata)
9370 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
32fe5131 9371 }
0085ce49
RD		 9372 equiv = equiv->next;
9373 }
32fe5131 9374 }
0085ce49 9375 }
32fe5131
RD		 9376}
9377
9378#ifdef __cplusplus
9379#if 0
9380{
0085ce49 9381 /* c-mode */
32fe5131
RD		 9382#endif
9383}
9384#endif
9385
2ef75293 9386
093d3ff1
RD		 9387
9388#ifdef __cplusplus
9389extern "C" {
9390#endif
0085ce49
RD		 9391
9392 /* Python-specific SWIG API */
093d3ff1
RD		 9393#define SWIG_newvarlink() SWIG_Python_newvarlink()
9394#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
9395#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
0085ce49
RD		 9396
9397 /* -----------------------------------------------------------------------------
9398 * global variable support code.
9399 * ----------------------------------------------------------------------------- */
9400
9401 typedef struct swig_globalvar {
9402 char *name; /* Name of global variable */
9403 PyObject *(*get_attr)(void); /* Return the current value */
9404 int (*set_attr)(PyObject *); /* Set the value */
9405 struct swig_globalvar *next;
9406 } swig_globalvar;
9407
9408 typedef struct swig_varlinkobject {
9409 PyObject_HEAD
9410 swig_globalvar *vars;
9411 } swig_varlinkobject;
9412
9413 SWIGINTERN PyObject *
9414 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
9415 return PyString_FromString("<Swig global variables>");
9416 }
9417
9418 SWIGINTERN PyObject *
9419 swig_varlink_str(swig_varlinkobject *v) {
9420 PyObject *str = PyString_FromString("(");
9421 swig_globalvar *var;
9422 for (var = v->vars; var; var=var->next) {
9423 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
9424 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
9425 }
9426 PyString_ConcatAndDel(&str,PyString_FromString(")"));
9427 return str;
9428 }
9429
9430 SWIGINTERN int
9431 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
9432 PyObject *str = swig_varlink_str(v);
9433 fprintf(fp,"Swig global variables ");
9434 fprintf(fp,"%s\n", PyString_AsString(str));
9435 Py_DECREF(str);
9436 return 0;
9437 }
9438
9439 SWIGINTERN void
9440 swig_varlink_dealloc(swig_varlinkobject *v) {
9441 swig_globalvar *var = v->vars;
9442 while (var) {
9443 swig_globalvar *n = var->next;
9444 free(var->name);
9445 free(var);
9446 var = n;
093d3ff1 9447 }
0085ce49
RD		 9448 }
9449
9450 SWIGINTERN PyObject *
9451 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
9452 PyObject *res = NULL;
9453 swig_globalvar *var = v->vars;
9454 while (var) {
9455 if (strcmp(var->name,n) == 0) {
9456 res = (*var->get_attr)();
9457 break;
9458 }
9459 var = var->next;
093d3ff1 9460 }
0085ce49
RD		 9461 if (res == NULL && !PyErr_Occurred()) {
9462 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
093d3ff1 9463 }
0085ce49
RD		 9464 return res;
9465 }
9466
9467 SWIGINTERN int
9468 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
9469 int res = 1;
9470 swig_globalvar *var = v->vars;
9471 while (var) {
9472 if (strcmp(var->name,n) == 0) {
9473 res = (*var->set_attr)(p);
9474 break;
9475 }
9476 var = var->next;
093d3ff1 9477 }
0085ce49
RD		 9478 if (res == 1 && !PyErr_Occurred()) {
9479 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
9480 }
9481 return res;
9482 }
9483
9484 SWIGINTERN PyTypeObject*
9485 swig_varlink_type(void) {
9486 static char varlink__doc__[] = "Swig var link object";
9487 static PyTypeObject varlink_type;
9488 static int type_init = 0;
9489 if (!type_init) {
9490 const PyTypeObject tmp
9491 = {
9492 PyObject_HEAD_INIT(NULL)
9493 0, /* Number of items in variable part (ob_size) */
9494 (char *)"swigvarlink", /* Type name (tp_name) */
9495 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
9496 0, /* Itemsize (tp_itemsize) */
9497 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
9498 (printfunc) swig_varlink_print, /* Print (tp_print) */
9499 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
9500 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
9501 0, /* tp_compare */
9502 (reprfunc) swig_varlink_repr, /* tp_repr */
9503 0, /* tp_as_number */
9504 0, /* tp_as_sequence */
9505 0, /* tp_as_mapping */
9506 0, /* tp_hash */
9507 0, /* tp_call */
9508 (reprfunc)swig_varlink_str, /* tp_str */
9509 0, /* tp_getattro */
9510 0, /* tp_setattro */
9511 0, /* tp_as_buffer */
9512 0, /* tp_flags */
9513 varlink__doc__, /* tp_doc */
9514 0, /* tp_traverse */
9515 0, /* tp_clear */
9516 0, /* tp_richcompare */
9517 0, /* tp_weaklistoffset */
093d3ff1 9518#if PY_VERSION_HEX >= 0x02020000
0085ce49 9519 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
093d3ff1
RD		 9520#endif
9521#if PY_VERSION_HEX >= 0x02030000
0085ce49 9522 0, /* tp_del */
093d3ff1
RD		 9523#endif
9524#ifdef COUNT_ALLOCS
0085ce49 9525 0,0,0,0 /* tp_alloc -> tp_next */
32fe5131 9526#endif
0085ce49
RD		 9527 };
9528 varlink_type = tmp;
9529 varlink_type.ob_type = &PyType_Type;
9530 type_init = 1;
093d3ff1 9531 }
0085ce49
RD		 9532 return &varlink_type;
9533 }
9534
9535 /* Create a variable linking object for use later */
9536 SWIGINTERN PyObject *
9537 SWIG_Python_newvarlink(void) {
9538 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
9539 if (result) {
9540 result->vars = 0;
9541 }
9542 return ((PyObject*) result);
9543 }
9544
9545 SWIGINTERN void
9546 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
9547 swig_varlinkobject *v = (swig_varlinkobject *) p;
9548 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
9549 if (gv) {
9550 size_t size = strlen(name)+1;
9551 gv->name = (char *)malloc(size);
9552 if (gv->name) {
9553 strncpy(gv->name,name,size);
9554 gv->get_attr = get_attr;
9555 gv->set_attr = set_attr;
9556 gv->next = v->vars;
9557 }
093d3ff1 9558 }
0085ce49
RD		 9559 v->vars = gv;
9560 }
9561
9562 SWIGINTERN PyObject *
9563 SWIG_globals() {
9564 static PyObject *_SWIG_globals = 0;
9565 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
9566 return _SWIG_globals;
9567 }
9568
9569 /* -----------------------------------------------------------------------------
9570 * constants/methods manipulation
9571 * ----------------------------------------------------------------------------- */
9572
9573 /* Install Constants */
9574 SWIGINTERN void
9575 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
9576 PyObject *obj = 0;
9577 size_t i;
9578 for (i = 0; constants[i].type; ++i) {
9579 switch(constants[i].type) {
9580 case SWIG_PY_POINTER:
9581 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
9582 break;
9583 case SWIG_PY_BINARY:
9584 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
9585 break;
9586 default:
9587 obj = 0;
9588 break;
9589 }
9590 if (obj) {
9591 PyDict_SetItemString(d, constants[i].name, obj);
9592 Py_DECREF(obj);
9593 }
093d3ff1 9594 }
0085ce49
RD		 9595 }
9596
9597 /* -----------------------------------------------------------------------------*/
9598 /* Fix SwigMethods to carry the callback ptrs when needed */
9599 /* -----------------------------------------------------------------------------*/
9600
9601 SWIGINTERN void
9602 SWIG_Python_FixMethods(PyMethodDef *methods,
093d3ff1
RD		 9603 swig_const_info *const_table,
9604 swig_type_info **types,
9605 swig_type_info **types_initial) {
0085ce49
RD		 9606 size_t i;
9607 for (i = 0; methods[i].ml_name; ++i) {
453fb36b 9608 const char *c = methods[i].ml_doc;
0085ce49
RD		 9609 if (c && (c = strstr(c, "swig_ptr: "))) {
9610 int j;
9611 swig_const_info *ci = 0;
453fb36b 9612 const char *name = c + 10;
0085ce49
RD		 9613 for (j = 0; const_table[j].type; ++j) {
9614 if (strncmp(const_table[j].name, name,
9615 strlen(const_table[j].name)) == 0) {
9616 ci = &(const_table[j]);
9617 break;
9618 }
9619 }
9620 if (ci) {
9621 size_t shift = (ci->ptype) - types;
9622 swig_type_info *ty = types_initial[shift];
9623 size_t ldoc = (c - methods[i].ml_doc);
9624 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
9625 char *ndoc = (char*)malloc(ldoc + lptr + 10);
9626 if (ndoc) {
9627 char *buff = ndoc;
9628 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
9629 if (ptr) {
9630 strncpy(buff, methods[i].ml_doc, ldoc);
9631 buff += ldoc;
9632 strncpy(buff, "swig_ptr: ", 10);
9633 buff += 10;
9634 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
9635 methods[i].ml_doc = ndoc;
093d3ff1 9636 }
0085ce49 9637 }
093d3ff1 9638 }
0085ce49 9639 }
093d3ff1 9640 }
0085ce49
RD		 9641 }
9642
093d3ff1
RD		 9643#ifdef __cplusplus
9644}
9645#endif
9646
9647/* -----------------------------------------------------------------------------*
9648 * Partial Init method
9649 * -----------------------------------------------------------------------------*/
9650
2ef75293
RD		 9651#ifdef __cplusplus
9652extern "C"
9653#endif
32fe5131 9654SWIGEXPORT void SWIG_init(void) {
0085ce49
RD		 9655 PyObject *m, *d;
9656
9657 /* Fix SwigMethods to carry the callback ptrs when needed */
9658 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
9659
9660 m = Py_InitModule((char *) SWIG_name, SwigMethods);
9661 d = PyModule_GetDict(m);
9662
9663 SWIG_InitializeModule(0);
9664 SWIG_InstallConstants(d,swig_const_table);
9665
9666
9667 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
9668 SWIG_addvarlink(SWIG_globals(),(char*)"UTF8String",UTF8String_get, UTF8String_set);
9669 SWIG_addvarlink(SWIG_globals(),(char*)"StyleString",StyleString_get, StyleString_set);
9670 SWIG_addvarlink(SWIG_globals(),(char*)"SizeString",SizeString_get, SizeString_set);
9671 SWIG_addvarlink(SWIG_globals(),(char*)"PosString",PosString_get, PosString_set);
9672 SWIG_addvarlink(SWIG_globals(),(char*)"BitmapString",BitmapString_get, BitmapString_set);
9673 SWIG_addvarlink(SWIG_globals(),(char*)"IconString",IconString_get, IconString_set);
9674 SWIG_addvarlink(SWIG_globals(),(char*)"FontString",FontString_get, FontString_set);
9675 SWIG_Python_SetConstant(d, "WX_XMLRES_CURRENT_VERSION_MAJOR",SWIG_From_int(static_cast< int >(WX_XMLRES_CURRENT_VERSION_MAJOR)));
9676 SWIG_Python_SetConstant(d, "WX_XMLRES_CURRENT_VERSION_MINOR",SWIG_From_int(static_cast< int >(WX_XMLRES_CURRENT_VERSION_MINOR)));
9677 SWIG_Python_SetConstant(d, "WX_XMLRES_CURRENT_VERSION_RELEASE",SWIG_From_int(static_cast< int >(WX_XMLRES_CURRENT_VERSION_RELEASE)));
9678 SWIG_Python_SetConstant(d, "WX_XMLRES_CURRENT_VERSION_REVISION",SWIG_From_int(static_cast< int >(WX_XMLRES_CURRENT_VERSION_REVISION)));
9679 SWIG_Python_SetConstant(d, "XRC_USE_LOCALE",SWIG_From_int(static_cast< int >(wxXRC_USE_LOCALE)));
9680 SWIG_Python_SetConstant(d, "XRC_NO_SUBCLASSING",SWIG_From_int(static_cast< int >(wxXRC_NO_SUBCLASSING)));
9681 SWIG_Python_SetConstant(d, "XRC_NO_RELOADING",SWIG_From_int(static_cast< int >(wxXRC_NO_RELOADING)));
9682 SWIG_Python_SetConstant(d, "XML_ELEMENT_NODE",SWIG_From_int(static_cast< int >(wxXML_ELEMENT_NODE)));
9683 SWIG_Python_SetConstant(d, "XML_ATTRIBUTE_NODE",SWIG_From_int(static_cast< int >(wxXML_ATTRIBUTE_NODE)));
9684 SWIG_Python_SetConstant(d, "XML_TEXT_NODE",SWIG_From_int(static_cast< int >(wxXML_TEXT_NODE)));
9685 SWIG_Python_SetConstant(d, "XML_CDATA_SECTION_NODE",SWIG_From_int(static_cast< int >(wxXML_CDATA_SECTION_NODE)));
9686 SWIG_Python_SetConstant(d, "XML_ENTITY_REF_NODE",SWIG_From_int(static_cast< int >(wxXML_ENTITY_REF_NODE)));
9687 SWIG_Python_SetConstant(d, "XML_ENTITY_NODE",SWIG_From_int(static_cast< int >(wxXML_ENTITY_NODE)));
9688 SWIG_Python_SetConstant(d, "XML_PI_NODE",SWIG_From_int(static_cast< int >(wxXML_PI_NODE)));
9689 SWIG_Python_SetConstant(d, "XML_COMMENT_NODE",SWIG_From_int(static_cast< int >(wxXML_COMMENT_NODE)));
9690 SWIG_Python_SetConstant(d, "XML_DOCUMENT_NODE",SWIG_From_int(static_cast< int >(wxXML_DOCUMENT_NODE)));
9691 SWIG_Python_SetConstant(d, "XML_DOCUMENT_TYPE_NODE",SWIG_From_int(static_cast< int >(wxXML_DOCUMENT_TYPE_NODE)));
9692 SWIG_Python_SetConstant(d, "XML_DOCUMENT_FRAG_NODE",SWIG_From_int(static_cast< int >(wxXML_DOCUMENT_FRAG_NODE)));
9693 SWIG_Python_SetConstant(d, "XML_NOTATION_NODE",SWIG_From_int(static_cast< int >(wxXML_NOTATION_NODE)));
9694 SWIG_Python_SetConstant(d, "XML_HTML_DOCUMENT_NODE",SWIG_From_int(static_cast< int >(wxXML_HTML_DOCUMENT_NODE)));
9695
9696
9697 wxXmlInitResourceModule();
9698 wxXmlResource::Get()->InitAllHandlers();
9699
9700
2ef75293
RD		 9701}
9702
wxWidgets (Impactor)