]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Removed obsolete files from richedit sample directory
[wxWidgets.git] / wxPython / src / msw / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.27
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_VERSION 0x010327
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
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; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /***********************************************************************
31 *
32 * This section contains generic SWIG labels for method/variable
33 * declarations/attributes, and other compiler dependent labels.
34 *
35 ************************************************************************/
36
37 /* template workaround for compilers that cannot correctly implement the C++ standard */
38 #ifndef SWIGTEMPLATEDISAMBIGUATOR
39 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
40 # define SWIGTEMPLATEDISAMBIGUATOR template
41 # else
42 # define SWIGTEMPLATEDISAMBIGUATOR
43 # endif
44 #endif
45
46 /* inline attribute */
47 #ifndef SWIGINLINE
48 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
49 # define SWIGINLINE inline
50 # else
51 # define SWIGINLINE
52 # endif
53 #endif
54
55 /* attribute recognised by some compilers to avoid 'unused' warnings */
56 #ifndef SWIGUNUSED
57 # if defined(__GNUC__) || defined(__ICC)
58 # define SWIGUNUSED __attribute__ ((unused))
59 # else
60 # define SWIGUNUSED
61 # endif
62 #endif
63
64 /* internal SWIG method */
65 #ifndef SWIGINTERN
66 # define SWIGINTERN static SWIGUNUSED
67 #endif
68
69 /* internal inline SWIG method */
70 #ifndef SWIGINTERNINLINE
71 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
72 #endif
73
74 /* exporting methods for Windows DLLs */
75 #ifndef SWIGEXPORT
76 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
77 # if defined(STATIC_LINKED)
78 # define SWIGEXPORT
79 # else
80 # define SWIGEXPORT __declspec(dllexport)
81 # endif
82 # else
83 # define SWIGEXPORT
84 # endif
85 #endif
86
87 /* calling conventions for Windows */
88 #ifndef SWIGSTDCALL
89 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
90 # define SWIGSTDCALL __stdcall
91 # else
92 # define SWIGSTDCALL
93 # endif
94 #endif
95
96
97
98 #include <Python.h>
99
100 /***********************************************************************
101 * swigrun.swg
102 *
103 * This file contains generic CAPI SWIG runtime support for pointer
104 * type checking.
105 *
106 ************************************************************************/
107
108 /* This should only be incremented when either the layout of swig_type_info changes,
109 or for whatever reason, the runtime changes incompatibly */
110 #define SWIG_RUNTIME_VERSION "2"
111
112 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
113 #ifdef SWIG_TYPE_TABLE
114 # define SWIG_QUOTE_STRING(x) #x
115 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
116 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
117 #else
118 # define SWIG_TYPE_TABLE_NAME
119 #endif
120
121 /*
122 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
123 creating a static or dynamic library from the swig runtime code.
124 In 99.9% of the cases, swig just needs to declare them as 'static'.
125
126 But only do this if is strictly necessary, ie, if you have problems
127 with your compiler or so.
128 */
129
130 #ifndef SWIGRUNTIME
131 # define SWIGRUNTIME SWIGINTERN
132 #endif
133
134 #ifndef SWIGRUNTIMEINLINE
135 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
136 #endif
137
138 #include <string.h>
139
140 #ifdef __cplusplus
141 extern "C" {
142 #endif
143
144 typedef void *(*swig_converter_func)(void *);
145 typedef struct swig_type_info *(*swig_dycast_func)(void **);
146
147 /* Structure to store inforomation on one type */
148 typedef struct swig_type_info {
149 const char *name; /* mangled name of this type */
150 const char *str; /* human readable name of this type */
151 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
152 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
153 void *clientdata; /* language specific type data */
154 } swig_type_info;
155
156 /* Structure to store a type and conversion function used for casting */
157 typedef struct swig_cast_info {
158 swig_type_info *type; /* pointer to type that is equivalent to this type */
159 swig_converter_func converter; /* function to cast the void pointers */
160 struct swig_cast_info *next; /* pointer to next cast in linked list */
161 struct swig_cast_info *prev; /* pointer to the previous cast */
162 } swig_cast_info;
163
164 /* Structure used to store module information
165 * Each module generates one structure like this, and the runtime collects
166 * all of these structures and stores them in a circularly linked list.*/
167 typedef struct swig_module_info {
168 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
169 size_t size; /* Number of types in this module */
170 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
171 swig_type_info **type_initial; /* Array of initially generated type structures */
172 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
173 void *clientdata; /* Language specific module data */
174 } swig_module_info;
175
176
177 /*
178 Compare two type names skipping the space characters, therefore
179 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
180
181 Return 0 when the two name types are equivalent, as in
182 strncmp, but skipping ' '.
183 */
184 SWIGRUNTIME int
185 SWIG_TypeNameComp(const char *f1, const char *l1,
186 const char *f2, const char *l2) {
187 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
188 while ((*f1 == ' ') && (f1 != l1)) ++f1;
189 while ((*f2 == ' ') && (f2 != l2)) ++f2;
190 if (*f1 != *f2) return (int)(*f1 - *f2);
191 }
192 return (l1 - f1) - (l2 - f2);
193 }
194
195 /*
196 Check type equivalence in a name list like <name1>|<name2>|...
197 Return 0 if not equal, 1 if equal
198 */
199 SWIGRUNTIME int
200 SWIG_TypeEquiv(const char *nb, const char *tb) {
201 int equiv = 0;
202 const char* te = tb + strlen(tb);
203 const char* ne = nb;
204 while (!equiv && *ne) {
205 for (nb = ne; *ne; ++ne) {
206 if (*ne == '|') break;
207 }
208 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
209 if (*ne) ++ne;
210 }
211 return equiv;
212 }
213
214 /*
215 Check type equivalence in a name list like <name1>|<name2>|...
216 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
217 */
218 SWIGRUNTIME int
219 SWIG_TypeCompare(const char *nb, const char *tb) {
220 int equiv = 0;
221 const char* te = tb + strlen(tb);
222 const char* ne = nb;
223 while (!equiv && *ne) {
224 for (nb = ne; *ne; ++ne) {
225 if (*ne == '|') break;
226 }
227 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
228 if (*ne) ++ne;
229 }
230 return equiv;
231 }
232
233
234 /* think of this as a c++ template<> or a scheme macro */
235 #define SWIG_TypeCheck_Template(comparison, ty) \
236 if (ty) { \
237 swig_cast_info *iter = ty->cast; \
238 while (iter) { \
239 if (comparison) { \
240 if (iter == ty->cast) return iter; \
241 /* Move iter to the top of the linked list */ \
242 iter->prev->next = iter->next; \
243 if (iter->next) \
244 iter->next->prev = iter->prev; \
245 iter->next = ty->cast; \
246 iter->prev = 0; \
247 if (ty->cast) ty->cast->prev = iter; \
248 ty->cast = iter; \
249 return iter; \
250 } \
251 iter = iter->next; \
252 } \
253 } \
254 return 0
255
256 /*
257 Check the typename
258 */
259 SWIGRUNTIME swig_cast_info *
260 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
261 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
262 }
263
264 /* Same as previous function, except strcmp is replaced with a pointer comparison */
265 SWIGRUNTIME swig_cast_info *
266 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
267 SWIG_TypeCheck_Template(iter->type == from, into);
268 }
269
270 /*
271 Cast a pointer up an inheritance hierarchy
272 */
273 SWIGRUNTIMEINLINE void *
274 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
275 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
276 }
277
278 /*
279 Dynamic pointer casting. Down an inheritance hierarchy
280 */
281 SWIGRUNTIME swig_type_info *
282 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
283 swig_type_info *lastty = ty;
284 if (!ty || !ty->dcast) return ty;
285 while (ty && (ty->dcast)) {
286 ty = (*ty->dcast)(ptr);
287 if (ty) lastty = ty;
288 }
289 return lastty;
290 }
291
292 /*
293 Return the name associated with this type
294 */
295 SWIGRUNTIMEINLINE const char *
296 SWIG_TypeName(const swig_type_info *ty) {
297 return ty->name;
298 }
299
300 /*
301 Return the pretty name associated with this type,
302 that is an unmangled type name in a form presentable to the user.
303 */
304 SWIGRUNTIME const char *
305 SWIG_TypePrettyName(const swig_type_info *type) {
306 /* The "str" field contains the equivalent pretty names of the
307 type, separated by vertical-bar characters. We choose
308 to print the last name, as it is often (?) the most
309 specific. */
310 if (type->str != NULL) {
311 const char *last_name = type->str;
312 const char *s;
313 for (s = type->str; *s; s++)
314 if (*s == '|') last_name = s+1;
315 return last_name;
316 }
317 else
318 return type->name;
319 }
320
321 /*
322 Set the clientdata field for a type
323 */
324 SWIGRUNTIME void
325 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
326 swig_cast_info *cast = ti->cast;
327 /* if (ti->clientdata == clientdata) return; */
328 ti->clientdata = clientdata;
329
330 while (cast) {
331 if (!cast->converter) {
332 swig_type_info *tc = cast->type;
333 if (!tc->clientdata) {
334 SWIG_TypeClientData(tc, clientdata);
335 }
336 }
337 cast = cast->next;
338 }
339 }
340
341 /*
342 Search for a swig_type_info structure only by mangled name
343 Search is a O(log #types)
344
345 We start searching at module start, and finish searching when start == end.
346 Note: if start == end at the beginning of the function, we go all the way around
347 the circular list.
348 */
349 SWIGRUNTIME swig_type_info *
350 SWIG_MangledTypeQueryModule(swig_module_info *start,
351 swig_module_info *end,
352 const char *name) {
353 swig_module_info *iter = start;
354 do {
355 if (iter->size) {
356 register size_t l = 0;
357 register size_t r = iter->size - 1;
358 do {
359 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
360 register size_t i = (l + r) >> 1;
361 const char *iname = iter->types[i]->name;
362 if (iname) {
363 register int compare = strcmp(name, iname);
364 if (compare == 0) {
365 return iter->types[i];
366 } else if (compare < 0) {
367 if (i) {
368 r = i - 1;
369 } else {
370 break;
371 }
372 } else if (compare > 0) {
373 l = i + 1;
374 }
375 } else {
376 break; /* should never happen */
377 }
378 } while (l <= r);
379 }
380 iter = iter->next;
381 } while (iter != end);
382 return 0;
383 }
384
385 /*
386 Search for a swig_type_info structure for either a mangled name or a human readable name.
387 It first searches the mangled names of the types, which is a O(log #types)
388 If a type is not found it then searches the human readable names, which is O(#types).
389
390 We start searching at module start, and finish searching when start == end.
391 Note: if start == end at the beginning of the function, we go all the way around
392 the circular list.
393 */
394 SWIGRUNTIME swig_type_info *
395 SWIG_TypeQueryModule(swig_module_info *start,
396 swig_module_info *end,
397 const char *name) {
398 /* STEP 1: Search the name field using binary search */
399 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
400 if (ret) {
401 return ret;
402 } else {
403 /* STEP 2: If the type hasn't been found, do a complete search
404 of the str field (the human readable name) */
405 swig_module_info *iter = start;
406 do {
407 register size_t i = 0;
408 for (; i < iter->size; ++i) {
409 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
410 return iter->types[i];
411 }
412 iter = iter->next;
413 } while (iter != end);
414 }
415
416 /* neither found a match */
417 return 0;
418 }
419
420
421 /*
422 Pack binary data into a string
423 */
424 SWIGRUNTIME char *
425 SWIG_PackData(char *c, void *ptr, size_t sz) {
426 static const char hex[17] = "0123456789abcdef";
427 register const unsigned char *u = (unsigned char *) ptr;
428 register const unsigned char *eu = u + sz;
429 for (; u != eu; ++u) {
430 register unsigned char uu = *u;
431 *(c++) = hex[(uu & 0xf0) >> 4];
432 *(c++) = hex[uu & 0xf];
433 }
434 return c;
435 }
436
437 /*
438 Unpack binary data from a string
439 */
440 SWIGRUNTIME const char *
441 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
442 register unsigned char *u = (unsigned char *) ptr;
443 register const unsigned char *eu = u + sz;
444 for (; u != eu; ++u) {
445 register char d = *(c++);
446 register unsigned char uu = 0;
447 if ((d >= '0') && (d <= '9'))
448 uu = ((d - '0') << 4);
449 else if ((d >= 'a') && (d <= 'f'))
450 uu = ((d - ('a'-10)) << 4);
451 else
452 return (char *) 0;
453 d = *(c++);
454 if ((d >= '0') && (d <= '9'))
455 uu |= (d - '0');
456 else if ((d >= 'a') && (d <= 'f'))
457 uu |= (d - ('a'-10));
458 else
459 return (char *) 0;
460 *u = uu;
461 }
462 return c;
463 }
464
465 /*
466 Pack 'void *' into a string buffer.
467 */
468 SWIGRUNTIME char *
469 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
470 char *r = buff;
471 if ((2*sizeof(void *) + 2) > bsz) return 0;
472 *(r++) = '_';
473 r = SWIG_PackData(r,&ptr,sizeof(void *));
474 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
475 strcpy(r,name);
476 return buff;
477 }
478
479 SWIGRUNTIME const char *
480 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
481 if (*c != '_') {
482 if (strcmp(c,"NULL") == 0) {
483 *ptr = (void *) 0;
484 return name;
485 } else {
486 return 0;
487 }
488 }
489 return SWIG_UnpackData(++c,ptr,sizeof(void *));
490 }
491
492 SWIGRUNTIME char *
493 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
494 char *r = buff;
495 size_t lname = (name ? strlen(name) : 0);
496 if ((2*sz + 2 + lname) > bsz) return 0;
497 *(r++) = '_';
498 r = SWIG_PackData(r,ptr,sz);
499 if (lname) {
500 strncpy(r,name,lname+1);
501 } else {
502 *r = 0;
503 }
504 return buff;
505 }
506
507 SWIGRUNTIME const char *
508 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
509 if (*c != '_') {
510 if (strcmp(c,"NULL") == 0) {
511 memset(ptr,0,sz);
512 return name;
513 } else {
514 return 0;
515 }
516 }
517 return SWIG_UnpackData(++c,ptr,sz);
518 }
519
520 #ifdef __cplusplus
521 }
522 #endif
523
524 /* -----------------------------------------------------------------------------
525 * SWIG API. Portion that goes into the runtime
526 * ----------------------------------------------------------------------------- */
527
528 #ifdef __cplusplus
529 extern "C" {
530 #endif
531
532 /* -----------------------------------------------------------------------------
533 * for internal method declarations
534 * ----------------------------------------------------------------------------- */
535
536 #ifndef SWIGINTERN
537 # define SWIGINTERN static SWIGUNUSED
538 #endif
539
540 #ifndef SWIGINTERNINLINE
541 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
542 #endif
543
544 /*
545 Exception handling in wrappers
546 */
547 #define SWIG_fail goto fail
548 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
549 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
550 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
551 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
552 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
553
554 /*
555 Contract support
556 */
557 #define SWIG_contract_assert(expr, msg) \
558 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
559
560 /* -----------------------------------------------------------------------------
561 * Constant declarations
562 * ----------------------------------------------------------------------------- */
563
564 /* Constant Types */
565 #define SWIG_PY_INT 1
566 #define SWIG_PY_FLOAT 2
567 #define SWIG_PY_STRING 3
568 #define SWIG_PY_POINTER 4
569 #define SWIG_PY_BINARY 5
570
571 /* Constant information structure */
572 typedef struct swig_const_info {
573 int type;
574 char *name;
575 long lvalue;
576 double dvalue;
577 void *pvalue;
578 swig_type_info **ptype;
579 } swig_const_info;
580
581
582 /* -----------------------------------------------------------------------------
583 * Alloc. memory flags
584 * ----------------------------------------------------------------------------- */
585 #define SWIG_OLDOBJ 1
586 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
587 #define SWIG_PYSTR SWIG_NEWOBJ + 1
588
589 #ifdef __cplusplus
590 }
591 #endif
592
593
594 /***********************************************************************
595 * pyrun.swg
596 *
597 * This file contains the runtime support for Python modules
598 * and includes code for managing global variables and pointer
599 * type checking.
600 *
601 * Author : David Beazley (beazley@cs.uchicago.edu)
602 ************************************************************************/
603
604 /* Common SWIG API */
605 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
606 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
607 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
608
609
610 /* Python-specific SWIG API */
611 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
612 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
613
614 /* Runtime API */
615 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
616 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
617
618 /* -----------------------------------------------------------------------------
619 * Pointer declarations
620 * ----------------------------------------------------------------------------- */
621 /*
622 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
623 C/C++ pointers in the python side. Very useful for debugging, but
624 not always safe.
625 */
626 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
627 # define SWIG_COBJECT_TYPES
628 #endif
629
630 /* Flags for pointer conversion */
631 #define SWIG_POINTER_EXCEPTION 0x1
632 #define SWIG_POINTER_DISOWN 0x2
633
634
635 /* Add PyOS_snprintf for old Pythons */
636 #if PY_VERSION_HEX < 0x02020000
637 #define PyOS_snprintf snprintf
638 #endif
639
640 #ifdef __cplusplus
641 extern "C" {
642 #endif
643
644 /* -----------------------------------------------------------------------------
645 * Create a new pointer string
646 * ----------------------------------------------------------------------------- */
647 #ifndef SWIG_BUFFER_SIZE
648 #define SWIG_BUFFER_SIZE 1024
649 #endif
650
651 /* A crude PyString_FromFormat implementation for old Pythons */
652 #if PY_VERSION_HEX < 0x02020000
653 static PyObject *
654 PyString_FromFormat(const char *fmt, ...) {
655 va_list ap;
656 char buf[SWIG_BUFFER_SIZE * 2];
657 int res;
658 va_start(ap, fmt);
659 res = vsnprintf(buf, sizeof(buf), fmt, ap);
660 va_end(ap);
661 return (res < 0 || res >= sizeof(buf)) ? 0 : PyString_FromString(buf);
662 }
663 #endif
664
665 #if PY_VERSION_HEX < 0x01060000
666 #define PyObject_Del(op) PyMem_DEL((op))
667 #endif
668
669 #if defined(SWIG_COBJECT_TYPES)
670 #if !defined(SWIG_COBJECT_PYTHON)
671 /* -----------------------------------------------------------------------------
672 * Implements a simple Swig Object type, and use it instead of PyCObject
673 * ----------------------------------------------------------------------------- */
674
675 typedef struct {
676 PyObject_HEAD
677 void *ptr;
678 const char *desc;
679 } PySwigObject;
680
681 /* Declarations for objects of type PySwigObject */
682
683 SWIGRUNTIME int
684 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
685 {
686 char result[SWIG_BUFFER_SIZE];
687 flags = flags;
688 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
689 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
690 return 0;
691 } else {
692 return 1;
693 }
694 }
695
696 SWIGRUNTIME PyObject *
697 PySwigObject_repr(PySwigObject *v)
698 {
699 char result[SWIG_BUFFER_SIZE];
700 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
701 PyString_FromFormat("<Swig Object at %s>", result) : 0;
702 }
703
704 SWIGRUNTIME PyObject *
705 PySwigObject_str(PySwigObject *v)
706 {
707 char result[SWIG_BUFFER_SIZE];
708 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
709 PyString_FromString(result) : 0;
710 }
711
712 SWIGRUNTIME PyObject *
713 PySwigObject_long(PySwigObject *v)
714 {
715 return PyLong_FromVoidPtr(v->ptr);
716 }
717
718 SWIGRUNTIME PyObject *
719 PySwigObject_format(const char* fmt, PySwigObject *v)
720 {
721 PyObject *res = NULL;
722 PyObject *args = PyTuple_New(1);
723 if (args && (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0)) {
724 PyObject *ofmt = PyString_FromString(fmt);
725 if (ofmt) {
726 res = PyString_Format(ofmt,args);
727 Py_DECREF(ofmt);
728 }
729 Py_DECREF(args);
730 }
731 return res;
732 }
733
734 SWIGRUNTIME PyObject *
735 PySwigObject_oct(PySwigObject *v)
736 {
737 return PySwigObject_format("%o",v);
738 }
739
740 SWIGRUNTIME PyObject *
741 PySwigObject_hex(PySwigObject *v)
742 {
743 return PySwigObject_format("%x",v);
744 }
745
746 SWIGRUNTIME int
747 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
748 {
749 int c = strcmp(v->desc, w->desc);
750 if (c) {
751 return (c > 0) ? 1 : -1;
752 } else {
753 void *i = v->ptr;
754 void *j = w->ptr;
755 return (i < j) ? -1 : ((i > j) ? 1 : 0);
756 }
757 }
758
759 SWIGRUNTIME void
760 PySwigObject_dealloc(PySwigObject *self)
761 {
762 PyObject_Del(self);
763 }
764
765 SWIGRUNTIME PyTypeObject*
766 PySwigObject_type(void) {
767 static char pyswigobject_type__doc__[] =
768 "Swig object carries a C/C++ instance pointer";
769
770 static PyNumberMethods PySwigObject_as_number = {
771 (binaryfunc)0, /*nb_add*/
772 (binaryfunc)0, /*nb_subtract*/
773 (binaryfunc)0, /*nb_multiply*/
774 (binaryfunc)0, /*nb_divide*/
775 (binaryfunc)0, /*nb_remainder*/
776 (binaryfunc)0, /*nb_divmod*/
777 (ternaryfunc)0,/*nb_power*/
778 (unaryfunc)0, /*nb_negative*/
779 (unaryfunc)0, /*nb_positive*/
780 (unaryfunc)0, /*nb_absolute*/
781 (inquiry)0, /*nb_nonzero*/
782 0, /*nb_invert*/
783 0, /*nb_lshift*/
784 0, /*nb_rshift*/
785 0, /*nb_and*/
786 0, /*nb_xor*/
787 0, /*nb_or*/
788 (coercion)0, /*nb_coerce*/
789 (unaryfunc)PySwigObject_long, /*nb_int*/
790 (unaryfunc)PySwigObject_long, /*nb_long*/
791 (unaryfunc)0, /*nb_float*/
792 (unaryfunc)PySwigObject_oct, /*nb_oct*/
793 (unaryfunc)PySwigObject_hex, /*nb_hex*/
794 #if PY_VERSION_HEX >= 0x02020000
795 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
796 #elif PY_VERSION_HEX >= 0x02000000
797 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
798 #endif
799 };
800
801 static PyTypeObject pyswigobject_type
802 #if !defined(__cplusplus)
803 ;
804 static int type_init = 0;
805 if (!type_init) {
806 PyTypeObject tmp
807 #endif
808 = {
809 PyObject_HEAD_INIT(&PyType_Type)
810 0, /*ob_size*/
811 (char *)"PySwigObject", /*tp_name*/
812 sizeof(PySwigObject), /*tp_basicsize*/
813 0, /*tp_itemsize*/
814 /* methods */
815 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
816 (printfunc)PySwigObject_print, /*tp_print*/
817 (getattrfunc)0, /*tp_getattr*/
818 (setattrfunc)0, /*tp_setattr*/
819 (cmpfunc)PySwigObject_compare, /*tp_compare*/
820 (reprfunc)PySwigObject_repr, /*tp_repr*/
821 &PySwigObject_as_number, /*tp_as_number*/
822 0, /*tp_as_sequence*/
823 0, /*tp_as_mapping*/
824 (hashfunc)0, /*tp_hash*/
825 (ternaryfunc)0, /*tp_call*/
826 (reprfunc)PySwigObject_str, /*tp_str*/
827 /* Space for future expansion */
828 0,0,0,0,
829 pyswigobject_type__doc__, /* Documentation string */
830 #if PY_VERSION_HEX >= 0x02000000
831 0, /* tp_traverse */
832 0, /* tp_clear */
833 #endif
834 #if PY_VERSION_HEX >= 0x02010000
835 0, /* tp_richcompare */
836 0, /* tp_weaklistoffset */
837 #endif
838 #if PY_VERSION_HEX >= 0x02020000
839 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
840 #endif
841 #if PY_VERSION_HEX >= 0x02030000
842 0, /* tp_del */
843 #endif
844 #ifdef COUNT_ALLOCS
845 0,0,0,0 /* tp_alloc -> tp_next */
846 #endif
847 };
848 #if !defined(__cplusplus)
849 pyswigobject_type = tmp;
850 type_init = 1;
851 }
852 #endif
853 return &pyswigobject_type;
854 }
855
856 SWIGRUNTIME PyObject *
857 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
858 {
859 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_type());
860 if (self) {
861 self->ptr = ptr;
862 self->desc = desc;
863 }
864 return (PyObject *)self;
865 }
866
867 SWIGRUNTIMEINLINE void *
868 PySwigObject_AsVoidPtr(PyObject *self)
869 {
870 return ((PySwigObject *)self)->ptr;
871 }
872
873 SWIGRUNTIMEINLINE const char *
874 PySwigObject_GetDesc(PyObject *self)
875 {
876 return ((PySwigObject *)self)->desc;
877 }
878
879 SWIGRUNTIMEINLINE int
880 PySwigObject_Check(PyObject *op) {
881 return ((op)->ob_type == PySwigObject_type())
882 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
883 }
884
885 /* -----------------------------------------------------------------------------
886 * Implements a simple Swig Packed type, and use it instead of string
887 * ----------------------------------------------------------------------------- */
888
889 typedef struct {
890 PyObject_HEAD
891 void *pack;
892 const char *desc;
893 size_t size;
894 } PySwigPacked;
895
896 SWIGRUNTIME int
897 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
898 {
899 char result[SWIG_BUFFER_SIZE];
900 flags = flags;
901 fputs("<Swig Packed ", fp);
902 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
903 fputs("at ", fp);
904 fputs(result, fp);
905 }
906 fputs(v->desc,fp);
907 fputs(">", fp);
908 return 0;
909 }
910
911 SWIGRUNTIME PyObject *
912 PySwigPacked_repr(PySwigPacked *v)
913 {
914 char result[SWIG_BUFFER_SIZE];
915 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
916 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
917 } else {
918 return PyString_FromFormat("<Swig Packed %s>", v->desc);
919 }
920 }
921
922 SWIGRUNTIME PyObject *
923 PySwigPacked_str(PySwigPacked *v)
924 {
925 char result[SWIG_BUFFER_SIZE];
926 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
927 return PyString_FromFormat("%s%s", result, v->desc);
928 } else {
929 return PyString_FromString(v->desc);
930 }
931 }
932
933 SWIGRUNTIME int
934 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
935 {
936 int c = strcmp(v->desc, w->desc);
937 if (c) {
938 return (c > 0) ? 1 : -1;
939 } else {
940 size_t i = v->size;
941 size_t j = w->size;
942 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
943 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
944 }
945 }
946
947 SWIGRUNTIME void
948 PySwigPacked_dealloc(PySwigPacked *self)
949 {
950 free(self->pack);
951 PyObject_Del(self);
952 }
953
954 SWIGRUNTIME PyTypeObject*
955 PySwigPacked_type(void) {
956 static char pyswigpacked_type__doc__[] =
957 "Swig object carries a C/C++ instance pointer";
958 static PyTypeObject pyswigpacked_type
959 #if !defined(__cplusplus)
960 ;
961 static int type_init = 0;
962 if (!type_init) {
963 PyTypeObject tmp
964 #endif
965 = {
966 PyObject_HEAD_INIT(&PyType_Type)
967 0, /*ob_size*/
968 (char *)"PySwigPacked", /*tp_name*/
969 sizeof(PySwigPacked), /*tp_basicsize*/
970 0, /*tp_itemsize*/
971 /* methods */
972 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
973 (printfunc)PySwigPacked_print, /*tp_print*/
974 (getattrfunc)0, /*tp_getattr*/
975 (setattrfunc)0, /*tp_setattr*/
976 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
977 (reprfunc)PySwigPacked_repr, /*tp_repr*/
978 0, /*tp_as_number*/
979 0, /*tp_as_sequence*/
980 0, /*tp_as_mapping*/
981 (hashfunc)0, /*tp_hash*/
982 (ternaryfunc)0, /*tp_call*/
983 (reprfunc)PySwigPacked_str, /*tp_str*/
984 /* Space for future expansion */
985 0,0,0,0,
986 pyswigpacked_type__doc__, /* Documentation string */
987 #if PY_VERSION_HEX >= 0x02000000
988 0, /* tp_traverse */
989 0, /* tp_clear */
990 #endif
991 #if PY_VERSION_HEX >= 0x02010000
992 0, /* tp_richcompare */
993 0, /* tp_weaklistoffset */
994 #endif
995 #if PY_VERSION_HEX >= 0x02020000
996 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
997 #endif
998 #if PY_VERSION_HEX >= 0x02030000
999 0, /* tp_del */
1000 #endif
1001 #ifdef COUNT_ALLOCS
1002 0,0,0,0 /* tp_alloc -> tp_next */
1003 #endif
1004 };
1005 #if !defined(__cplusplus)
1006 pyswigpacked_type = tmp;
1007 type_init = 1;
1008 }
1009 #endif
1010 return &pyswigpacked_type;
1011 }
1012
1013 SWIGRUNTIME PyObject *
1014 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
1015 {
1016 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1017 if (self == NULL) {
1018 return NULL;
1019 } else {
1020 void *pack = malloc(size);
1021 if (pack) {
1022 memcpy(pack, ptr, size);
1023 self->pack = pack;
1024 self->desc = desc;
1025 self->size = size;
1026 return (PyObject *) self;
1027 }
1028 return NULL;
1029 }
1030 }
1031
1032 SWIGRUNTIMEINLINE const char *
1033 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1034 {
1035 PySwigPacked *self = (PySwigPacked *)obj;
1036 if (self->size != size) return 0;
1037 memcpy(ptr, self->pack, size);
1038 return self->desc;
1039 }
1040
1041 SWIGRUNTIMEINLINE const char *
1042 PySwigPacked_GetDesc(PyObject *self)
1043 {
1044 return ((PySwigPacked *)self)->desc;
1045 }
1046
1047 SWIGRUNTIMEINLINE int
1048 PySwigPacked_Check(PyObject *op) {
1049 return ((op)->ob_type == PySwigPacked_type())
1050 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1051 }
1052
1053 #else
1054 /* -----------------------------------------------------------------------------
1055 * Use the old Python PyCObject instead of PySwigObject
1056 * ----------------------------------------------------------------------------- */
1057
1058 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1059 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1060 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1061 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1062
1063 #endif
1064
1065 #endif
1066
1067 /* -----------------------------------------------------------------------------
1068 * errors manipulation
1069 * ----------------------------------------------------------------------------- */
1070
1071 SWIGRUNTIME void
1072 SWIG_Python_TypeError(const char *type, PyObject *obj)
1073 {
1074 if (type) {
1075 #if defined(SWIG_COBJECT_TYPES)
1076 if (obj && PySwigObject_Check(obj)) {
1077 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1078 if (otype) {
1079 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1080 type, otype);
1081 return;
1082 }
1083 } else
1084 #endif
1085 {
1086 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1087 if (otype) {
1088 PyObject *str = PyObject_Str(obj);
1089 const char *cstr = str ? PyString_AsString(str) : 0;
1090 if (cstr) {
1091 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1092 type, otype, cstr);
1093 } else {
1094 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1095 type, otype);
1096 }
1097 Py_XDECREF(str);
1098 return;
1099 }
1100 }
1101 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1102 } else {
1103 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1104 }
1105 }
1106
1107 SWIGRUNTIMEINLINE void
1108 SWIG_Python_NullRef(const char *type)
1109 {
1110 if (type) {
1111 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1112 } else {
1113 PyErr_Format(PyExc_TypeError, "null reference was received");
1114 }
1115 }
1116
1117 SWIGRUNTIME int
1118 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1119 {
1120 if (PyErr_Occurred()) {
1121 PyObject *type = 0;
1122 PyObject *value = 0;
1123 PyObject *traceback = 0;
1124 PyErr_Fetch(&type, &value, &traceback);
1125 if (value) {
1126 PyObject *old_str = PyObject_Str(value);
1127 Py_XINCREF(type);
1128 PyErr_Clear();
1129 if (infront) {
1130 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1131 } else {
1132 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1133 }
1134 Py_DECREF(old_str);
1135 }
1136 return 1;
1137 } else {
1138 return 0;
1139 }
1140 }
1141
1142 SWIGRUNTIME int
1143 SWIG_Python_ArgFail(int argnum)
1144 {
1145 if (PyErr_Occurred()) {
1146 /* add information about failing argument */
1147 char mesg[256];
1148 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
1149 return SWIG_Python_AddErrMesg(mesg, 1);
1150 } else {
1151 return 0;
1152 }
1153 }
1154
1155
1156 /* -----------------------------------------------------------------------------
1157 * pointers/data manipulation
1158 * ----------------------------------------------------------------------------- */
1159
1160 /* Convert a pointer value */
1161 SWIGRUNTIME int
1162 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1163 swig_cast_info *tc;
1164 const char *c = 0;
1165 static PyObject *SWIG_this = 0;
1166 int newref = 0;
1167 PyObject *pyobj = 0;
1168 void *vptr;
1169
1170 if (!obj) return 0;
1171 if (obj == Py_None) {
1172 *ptr = 0;
1173 return 0;
1174 }
1175
1176 #ifdef SWIG_COBJECT_TYPES
1177 if (!(PySwigObject_Check(obj))) {
1178 if (!SWIG_this)
1179 SWIG_this = PyString_FromString("this");
1180 pyobj = obj;
1181 obj = PyObject_GetAttr(obj,SWIG_this);
1182 newref = 1;
1183 if (!obj) goto type_error;
1184 if (!PySwigObject_Check(obj)) {
1185 Py_DECREF(obj);
1186 goto type_error;
1187 }
1188 }
1189 vptr = PySwigObject_AsVoidPtr(obj);
1190 c = (const char *) PySwigObject_GetDesc(obj);
1191 if (newref) { Py_DECREF(obj); }
1192 goto type_check;
1193 #else
1194 if (!(PyString_Check(obj))) {
1195 if (!SWIG_this)
1196 SWIG_this = PyString_FromString("this");
1197 pyobj = obj;
1198 obj = PyObject_GetAttr(obj,SWIG_this);
1199 newref = 1;
1200 if (!obj) goto type_error;
1201 if (!PyString_Check(obj)) {
1202 Py_DECREF(obj);
1203 goto type_error;
1204 }
1205 }
1206 c = PyString_AsString(obj);
1207 /* Pointer values must start with leading underscore */
1208 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1209 if (newref) { Py_DECREF(obj); }
1210 if (!c) goto type_error;
1211 #endif
1212
1213 type_check:
1214 if (ty) {
1215 tc = SWIG_TypeCheck(c,ty);
1216 if (!tc) goto type_error;
1217 *ptr = SWIG_TypeCast(tc,vptr);
1218 } else {
1219 *ptr = vptr;
1220 }
1221 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1222 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1223 }
1224 return 0;
1225
1226 type_error:
1227 PyErr_Clear();
1228 if (pyobj && !obj) {
1229 obj = pyobj;
1230 if (PyCFunction_Check(obj)) {
1231 /* here we get the method pointer for callbacks */
1232 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1233 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1234 if (c) {
1235 c = ty ? SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name) : 0;
1236 if (!c) goto type_error;
1237 goto type_check;
1238 }
1239 }
1240 }
1241 if (flags & SWIG_POINTER_EXCEPTION) {
1242 if (ty) {
1243 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1244 } else {
1245 SWIG_Python_TypeError("C/C++ pointer", obj);
1246 }
1247 }
1248 return -1;
1249 }
1250
1251 /* Convert a pointer value, signal an exception on a type mismatch */
1252 SWIGRUNTIME void *
1253 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1254 void *result;
1255 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1256 PyErr_Clear();
1257 if (flags & SWIG_POINTER_EXCEPTION) {
1258 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1259 SWIG_Python_ArgFail(argnum);
1260 }
1261 }
1262 return result;
1263 }
1264
1265 /* Convert a packed value value */
1266 SWIGRUNTIME int
1267 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1268 swig_cast_info *tc;
1269 const char *c = 0;
1270
1271 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1272 c = PySwigPacked_UnpackData(obj, ptr, sz);
1273 #else
1274 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1275 c = PyString_AsString(obj);
1276 /* Pointer values must start with leading underscore */
1277 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1278 #endif
1279 if (!c) goto type_error;
1280 if (ty) {
1281 tc = SWIG_TypeCheck(c,ty);
1282 if (!tc) goto type_error;
1283 }
1284 return 0;
1285
1286 type_error:
1287 PyErr_Clear();
1288 if (flags & SWIG_POINTER_EXCEPTION) {
1289 if (ty) {
1290 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1291 } else {
1292 SWIG_Python_TypeError("C/C++ packed data", obj);
1293 }
1294 }
1295 return -1;
1296 }
1297
1298 /* Create a new array object */
1299 SWIGRUNTIME PyObject *
1300 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1301 PyObject *robj = 0;
1302 if (!type) {
1303 if (!PyErr_Occurred()) {
1304 PyErr_Format(PyExc_TypeError, "Swig: null type passed to NewPointerObj");
1305 }
1306 return robj;
1307 }
1308 if (!ptr) {
1309 Py_INCREF(Py_None);
1310 return Py_None;
1311 }
1312 #ifdef SWIG_COBJECT_TYPES
1313 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1314 #else
1315 {
1316 char result[SWIG_BUFFER_SIZE];
1317 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1318 PyString_FromString(result) : 0;
1319 }
1320 #endif
1321 if (!robj || (robj == Py_None)) return robj;
1322 if (type->clientdata) {
1323 PyObject *inst;
1324 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1325 Py_DECREF(robj);
1326 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1327 Py_DECREF(args);
1328 if (inst) {
1329 if (own) {
1330 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1331 }
1332 robj = inst;
1333 }
1334 }
1335 return robj;
1336 }
1337
1338 SWIGRUNTIME PyObject *
1339 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1340 PyObject *robj = 0;
1341 if (!ptr) {
1342 Py_INCREF(Py_None);
1343 return Py_None;
1344 }
1345 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1346 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1347 #else
1348 {
1349 char result[SWIG_BUFFER_SIZE];
1350 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1351 PyString_FromString(result) : 0;
1352 }
1353 #endif
1354 return robj;
1355 }
1356
1357 /* -----------------------------------------------------------------------------*
1358 * Get type list
1359 * -----------------------------------------------------------------------------*/
1360
1361 #ifdef SWIG_LINK_RUNTIME
1362 void *SWIG_ReturnGlobalTypeList(void *);
1363 #endif
1364
1365 SWIGRUNTIME swig_module_info *
1366 SWIG_Python_GetModule(void) {
1367 static void *type_pointer = (void *)0;
1368 /* first check if module already created */
1369 if (!type_pointer) {
1370 #ifdef SWIG_LINK_RUNTIME
1371 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1372 #else
1373 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1374 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1375 if (PyErr_Occurred()) {
1376 PyErr_Clear();
1377 type_pointer = (void *)0;
1378 }
1379 #endif
1380 }
1381 return (swig_module_info *) type_pointer;
1382 }
1383
1384 #if PY_MAJOR_VERSION < 2
1385 /* PyModule_AddObject function was introduced in Python 2.0. The following function
1386 is copied out of Python/modsupport.c in python version 2.3.4 */
1387 SWIGINTERN int
1388 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
1389 {
1390 PyObject *dict;
1391 if (!PyModule_Check(m)) {
1392 PyErr_SetString(PyExc_TypeError,
1393 "PyModule_AddObject() needs module as first arg");
1394 return -1;
1395 }
1396 if (!o) {
1397 PyErr_SetString(PyExc_TypeError,
1398 "PyModule_AddObject() needs non-NULL value");
1399 return -1;
1400 }
1401
1402 dict = PyModule_GetDict(m);
1403 if (dict == NULL) {
1404 /* Internal error -- modules must have a dict! */
1405 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
1406 PyModule_GetName(m));
1407 return -1;
1408 }
1409 if (PyDict_SetItemString(dict, name, o))
1410 return -1;
1411 Py_DECREF(o);
1412 return 0;
1413 }
1414 #endif
1415
1416 SWIGRUNTIME void
1417 SWIG_Python_SetModule(swig_module_info *swig_module) {
1418 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
1419
1420 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1421 swig_empty_runtime_method_table);
1422 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, NULL);
1423 if (pointer && module) {
1424 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
1425 }
1426 }
1427
1428 #ifdef __cplusplus
1429 }
1430 #endif
1431
1432
1433 /* -------- TYPES TABLE (BEGIN) -------- */
1434
1435 #define SWIGTYPE_p_char swig_types[0]
1436 #define SWIGTYPE_p_form_ops_t swig_types[1]
1437 #define SWIGTYPE_p_int swig_types[2]
1438 #define SWIGTYPE_p_unsigned_char swig_types[3]
1439 #define SWIGTYPE_p_unsigned_int swig_types[4]
1440 #define SWIGTYPE_p_unsigned_long swig_types[5]
1441 #define SWIGTYPE_p_void swig_types[6]
1442 #define SWIGTYPE_p_wxANIHandler swig_types[7]
1443 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
1444 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
1445 #define SWIGTYPE_p_wxArrayString swig_types[10]
1446 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
1447 #define SWIGTYPE_p_wxBitmap swig_types[12]
1448 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
1449 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
1450 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
1451 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
1452 #define SWIGTYPE_p_wxCURHandler swig_types[17]
1453 #define SWIGTYPE_p_wxCaret swig_types[18]
1454 #define SWIGTYPE_p_wxChar swig_types[19]
1455 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
1456 #define SWIGTYPE_p_wxClipboard swig_types[21]
1457 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
1458 #define SWIGTYPE_p_wxCloseEvent swig_types[23]
1459 #define SWIGTYPE_p_wxColour swig_types[24]
1460 #define SWIGTYPE_p_wxCommandEvent swig_types[25]
1461 #define SWIGTYPE_p_wxConfig swig_types[26]
1462 #define SWIGTYPE_p_wxConfigBase swig_types[27]
1463 #define SWIGTYPE_p_wxConfigPathChanger swig_types[28]
1464 #define SWIGTYPE_p_wxContextMenuEvent swig_types[29]
1465 #define SWIGTYPE_p_wxControl swig_types[30]
1466 #define SWIGTYPE_p_wxControlWithItems swig_types[31]
1467 #define SWIGTYPE_p_wxCursor swig_types[32]
1468 #define SWIGTYPE_p_wxCustomDataObject swig_types[33]
1469 #define SWIGTYPE_p_wxDC swig_types[34]
1470 #define SWIGTYPE_p_wxDataFormat swig_types[35]
1471 #define SWIGTYPE_p_wxDataObject swig_types[36]
1472 #define SWIGTYPE_p_wxDataObjectComposite swig_types[37]
1473 #define SWIGTYPE_p_wxDataObjectSimple swig_types[38]
1474 #define SWIGTYPE_p_wxDateEvent swig_types[39]
1475 #define SWIGTYPE_p_wxDateSpan swig_types[40]
1476 #define SWIGTYPE_p_wxDateTime swig_types[41]
1477 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[42]
1478 #define SWIGTYPE_p_wxDisplay swig_types[43]
1479 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[44]
1480 #define SWIGTYPE_p_wxDropFilesEvent swig_types[45]
1481 #define SWIGTYPE_p_wxDuplexMode swig_types[46]
1482 #define SWIGTYPE_p_wxEraseEvent swig_types[47]
1483 #define SWIGTYPE_p_wxEvent swig_types[48]
1484 #define SWIGTYPE_p_wxEvtHandler swig_types[49]
1485 #define SWIGTYPE_p_wxFSFile swig_types[50]
1486 #define SWIGTYPE_p_wxFileConfig swig_types[51]
1487 #define SWIGTYPE_p_wxFileDataObject swig_types[52]
1488 #define SWIGTYPE_p_wxFileHistory swig_types[53]
1489 #define SWIGTYPE_p_wxFileSystem swig_types[54]
1490 #define SWIGTYPE_p_wxFileType swig_types[55]
1491 #define SWIGTYPE_p_wxFileTypeInfo swig_types[56]
1492 #define SWIGTYPE_p_wxFlexGridSizer swig_types[57]
1493 #define SWIGTYPE_p_wxFocusEvent swig_types[58]
1494 #define SWIGTYPE_p_wxFont swig_types[59]
1495 #define SWIGTYPE_p_wxFrame swig_types[60]
1496 #define SWIGTYPE_p_wxGBSizerItem swig_types[61]
1497 #define SWIGTYPE_p_wxGIFHandler swig_types[62]
1498 #define SWIGTYPE_p_wxGridBagSizer swig_types[63]
1499 #define SWIGTYPE_p_wxGridSizer swig_types[64]
1500 #define SWIGTYPE_p_wxICOHandler swig_types[65]
1501 #define SWIGTYPE_p_wxIcon swig_types[66]
1502 #define SWIGTYPE_p_wxIconizeEvent swig_types[67]
1503 #define SWIGTYPE_p_wxIdleEvent swig_types[68]
1504 #define SWIGTYPE_p_wxImage swig_types[69]
1505 #define SWIGTYPE_p_wxImageHandler swig_types[70]
1506 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[71]
1507 #define SWIGTYPE_p_wxInitDialogEvent swig_types[72]
1508 #define SWIGTYPE_p_wxJPEGHandler swig_types[73]
1509 #define SWIGTYPE_p_wxJoystick swig_types[74]
1510 #define SWIGTYPE_p_wxJoystickEvent swig_types[75]
1511 #define SWIGTYPE_p_wxKeyEvent swig_types[76]
1512 #define SWIGTYPE_p_wxKillError swig_types[77]
1513 #define SWIGTYPE_p_wxLayoutConstraints swig_types[78]
1514 #define SWIGTYPE_p_wxLog swig_types[79]
1515 #define SWIGTYPE_p_wxLogBuffer swig_types[80]
1516 #define SWIGTYPE_p_wxLogChain swig_types[81]
1517 #define SWIGTYPE_p_wxLogGui swig_types[82]
1518 #define SWIGTYPE_p_wxLogNull swig_types[83]
1519 #define SWIGTYPE_p_wxLogStderr swig_types[84]
1520 #define SWIGTYPE_p_wxLogTextCtrl swig_types[85]
1521 #define SWIGTYPE_p_wxLogWindow swig_types[86]
1522 #define SWIGTYPE_p_wxMaximizeEvent swig_types[87]
1523 #define SWIGTYPE_p_wxMemorySize swig_types[88]
1524 #define SWIGTYPE_p_wxMenu swig_types[89]
1525 #define SWIGTYPE_p_wxMenuBar swig_types[90]
1526 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
1527 #define SWIGTYPE_p_wxMenuItem swig_types[92]
1528 #define SWIGTYPE_p_wxMetafile swig_types[93]
1529 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
1530 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
1531 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
1532 #define SWIGTYPE_p_wxMouseEvent swig_types[97]
1533 #define SWIGTYPE_p_wxMouseState swig_types[98]
1534 #define SWIGTYPE_p_wxMoveEvent swig_types[99]
1535 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[100]
1536 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
1537 #define SWIGTYPE_p_wxNcPaintEvent swig_types[102]
1538 #define SWIGTYPE_p_wxNotifyEvent swig_types[103]
1539 #define SWIGTYPE_p_wxObject swig_types[104]
1540 #define SWIGTYPE_p_wxOutputStream swig_types[105]
1541 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
1542 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
1543 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
1544 #define SWIGTYPE_p_wxPaintEvent swig_types[109]
1545 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[110]
1546 #define SWIGTYPE_p_wxPaperSize swig_types[111]
1547 #define SWIGTYPE_p_wxPoint swig_types[112]
1548 #define SWIGTYPE_p_wxProcessEvent swig_types[113]
1549 #define SWIGTYPE_p_wxPyApp swig_types[114]
1550 #define SWIGTYPE_p_wxPyArtProvider swig_types[115]
1551 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[116]
1552 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
1553 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[118]
1554 #define SWIGTYPE_p_wxPyDropSource swig_types[119]
1555 #define SWIGTYPE_p_wxPyDropTarget swig_types[120]
1556 #define SWIGTYPE_p_wxPyEvent swig_types[121]
1557 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[122]
1558 #define SWIGTYPE_p_wxPyImageHandler swig_types[123]
1559 #define SWIGTYPE_p_wxPyLog swig_types[124]
1560 #define SWIGTYPE_p_wxPyProcess swig_types[125]
1561 #define SWIGTYPE_p_wxPySizer swig_types[126]
1562 #define SWIGTYPE_p_wxPyTextDataObject swig_types[127]
1563 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[128]
1564 #define SWIGTYPE_p_wxPyTimer swig_types[129]
1565 #define SWIGTYPE_p_wxPyTipProvider swig_types[130]
1566 #define SWIGTYPE_p_wxPyValidator swig_types[131]
1567 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[132]
1568 #define SWIGTYPE_p_wxRect swig_types[133]
1569 #define SWIGTYPE_p_wxScrollEvent swig_types[134]
1570 #define SWIGTYPE_p_wxScrollWinEvent swig_types[135]
1571 #define SWIGTYPE_p_wxSetCursorEvent swig_types[136]
1572 #define SWIGTYPE_p_wxShowEvent swig_types[137]
1573 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[138]
1574 #define SWIGTYPE_p_wxSize swig_types[139]
1575 #define SWIGTYPE_p_wxSizeEvent swig_types[140]
1576 #define SWIGTYPE_p_wxSizer swig_types[141]
1577 #define SWIGTYPE_p_wxSizerItem swig_types[142]
1578 #define SWIGTYPE_p_wxSound swig_types[143]
1579 #define SWIGTYPE_p_wxStandardPaths swig_types[144]
1580 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[145]
1581 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[146]
1582 #define SWIGTYPE_p_wxStopWatch swig_types[147]
1583 #define SWIGTYPE_p_wxString swig_types[148]
1584 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[149]
1585 #define SWIGTYPE_p_wxSystemOptions swig_types[150]
1586 #define SWIGTYPE_p_wxSystemSettings swig_types[151]
1587 #define SWIGTYPE_p_wxTIFFHandler swig_types[152]
1588 #define SWIGTYPE_p_wxTextCtrl swig_types[153]
1589 #define SWIGTYPE_p_wxTextDataObject swig_types[154]
1590 #define SWIGTYPE_p_wxTimeSpan swig_types[155]
1591 #define SWIGTYPE_p_wxTimer swig_types[156]
1592 #define SWIGTYPE_p_wxTimerEvent swig_types[157]
1593 #define SWIGTYPE_p_wxTimerRunner swig_types[158]
1594 #define SWIGTYPE_p_wxTipProvider swig_types[159]
1595 #define SWIGTYPE_p_wxToolTip swig_types[160]
1596 #define SWIGTYPE_p_wxURLDataObject swig_types[161]
1597 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[162]
1598 #define SWIGTYPE_p_wxValidator swig_types[163]
1599 #define SWIGTYPE_p_wxVideoMode swig_types[164]
1600 #define SWIGTYPE_p_wxWindow swig_types[165]
1601 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[166]
1602 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[167]
1603 #define SWIGTYPE_p_wxWindowDisabler swig_types[168]
1604 #define SWIGTYPE_p_wxXPMHandler swig_types[169]
1605 #define SWIGTYPE_ptrdiff_t swig_types[170]
1606 #define SWIGTYPE_std__ptrdiff_t swig_types[171]
1607 #define SWIGTYPE_unsigned_int swig_types[172]
1608 static swig_type_info *swig_types[174];
1609 static swig_module_info swig_module = {swig_types, 173, 0, 0, 0, 0};
1610 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1611 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1612
1613 /* -------- TYPES TABLE (END) -------- */
1614
1615
1616 /*-----------------------------------------------
1617 @(target):= _misc_.so
1618 ------------------------------------------------*/
1619 #define SWIG_init init_misc_
1620
1621 #define SWIG_name "_misc_"
1622
1623 #include "wx/wxPython/wxPython.h"
1624 #include "wx/wxPython/pyclasses.h"
1625 #include "wx/wxPython/pyistream.h"
1626
1627 static const wxString wxPyEmptyString(wxEmptyString);
1628
1629
1630
1631 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
1632 #define SWIG_From_int PyInt_FromLong
1633 /*@@*/
1634
1635
1636 #include <limits.h>
1637
1638
1639 SWIGINTERN int
1640 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1641 const char *errmsg)
1642 {
1643 if (value < min_value) {
1644 if (errmsg) {
1645 PyErr_Format(PyExc_OverflowError,
1646 "value %ld is less than '%s' minimum %ld",
1647 value, errmsg, min_value);
1648 }
1649 return 0;
1650 } else if (value > max_value) {
1651 if (errmsg) {
1652 PyErr_Format(PyExc_OverflowError,
1653 "value %ld is greater than '%s' maximum %ld",
1654 value, errmsg, max_value);
1655 }
1656 return 0;
1657 }
1658 return 1;
1659 }
1660
1661
1662 SWIGINTERN int
1663 SWIG_AsVal_long(PyObject* obj, long* val)
1664 {
1665 if (PyNumber_Check(obj)) {
1666 if (val) *val = PyInt_AsLong(obj);
1667 return 1;
1668 }
1669 else {
1670 SWIG_Python_TypeError("number", obj);
1671 }
1672 return 0;
1673 }
1674
1675
1676 #if INT_MAX != LONG_MAX
1677 SWIGINTERN int
1678 SWIG_AsVal_int(PyObject *obj, int *val)
1679 {
1680 const char* errmsg = val ? "int" : (char*)0;
1681 long v;
1682 if (SWIG_AsVal_long(obj, &v)) {
1683 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1684 if (val) *val = static_cast<int >(v);
1685 return 1;
1686 } else {
1687 return 0;
1688 }
1689 } else {
1690 PyErr_Clear();
1691 }
1692 if (val) {
1693 SWIG_type_error(errmsg, obj);
1694 }
1695 return 0;
1696 }
1697 #else
1698 SWIGINTERNINLINE int
1699 SWIG_AsVal_int(PyObject *obj, int *val)
1700 {
1701 return SWIG_AsVal_long(obj,(long*)val);
1702 }
1703 #endif
1704
1705
1706 SWIGINTERNINLINE int
1707 SWIG_As_int(PyObject* obj)
1708 {
1709 int v;
1710 if (!SWIG_AsVal_int(obj, &v)) {
1711 /*
1712 this is needed to make valgrind/purify happier.
1713 */
1714 memset((void*)&v, 0, sizeof(int));
1715 }
1716 return v;
1717 }
1718
1719
1720 SWIGINTERNINLINE int
1721 SWIG_Check_int(PyObject* obj)
1722 {
1723 return SWIG_AsVal_int(obj, (int*)0);
1724 }
1725
1726 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1727
1728 #include <wx/stockitem.h>
1729
1730 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1731 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1732 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1733
1734 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
1735 #define SWIG_From_long PyInt_FromLong
1736 /*@@*/
1737
1738
1739 SWIGINTERNINLINE long
1740 SWIG_As_long(PyObject* obj)
1741 {
1742 long v;
1743 if (!SWIG_AsVal_long(obj, &v)) {
1744 /*
1745 this is needed to make valgrind/purify happier.
1746 */
1747 memset((void*)&v, 0, sizeof(long));
1748 }
1749 return v;
1750 }
1751
1752
1753 SWIGINTERNINLINE int
1754 SWIG_Check_long(PyObject* obj)
1755 {
1756 return SWIG_AsVal_long(obj, (long*)0);
1757 }
1758
1759
1760 SWIGINTERN int
1761 SWIG_AsVal_bool(PyObject *obj, bool *val)
1762 {
1763 if (obj == Py_True) {
1764 if (val) *val = true;
1765 return 1;
1766 }
1767 if (obj == Py_False) {
1768 if (val) *val = false;
1769 return 1;
1770 }
1771 int res = 0;
1772 if (SWIG_AsVal_int(obj, &res)) {
1773 if (val) *val = res ? true : false;
1774 return 1;
1775 } else {
1776 PyErr_Clear();
1777 }
1778 if (val) {
1779 SWIG_type_error("bool", obj);
1780 }
1781 return 0;
1782 }
1783
1784
1785 SWIGINTERNINLINE bool
1786 SWIG_As_bool(PyObject* obj)
1787 {
1788 bool v;
1789 if (!SWIG_AsVal_bool(obj, &v)) {
1790 /*
1791 this is needed to make valgrind/purify happier.
1792 */
1793 memset((void*)&v, 0, sizeof(bool));
1794 }
1795 return v;
1796 }
1797
1798
1799 SWIGINTERNINLINE int
1800 SWIG_Check_bool(PyObject* obj)
1801 {
1802 return SWIG_AsVal_bool(obj, (bool*)0);
1803 }
1804
1805
1806 static PyObject* t_output_helper(PyObject* result, PyObject* obj)
1807 {
1808 PyObject* o2;
1809 PyObject* o3;
1810 if (!result) {
1811 result = obj;
1812 } else if (result == Py_None) {
1813 Py_DECREF(result);
1814 result = obj;
1815 } else {
1816 if (!PyTuple_Check(result)) {
1817 o2 = result;
1818 result = PyTuple_New(1);
1819 PyTuple_SET_ITEM(result, 0, o2);
1820 }
1821 o3 = PyTuple_New(1);
1822 PyTuple_SetItem(o3, 0, obj);
1823 o2 = result;
1824 result = PySequence_Concat(o2, o3);
1825 Py_DECREF(o2);
1826 Py_DECREF(o3);
1827 }
1828 return result;
1829 }
1830
1831
1832
1833 SWIGINTERN int
1834 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1835 {
1836 long v = 0;
1837 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1838 SWIG_Python_TypeError("unsigned number", obj);
1839 }
1840 else if (val)
1841 *val = (unsigned long)v;
1842 return 1;
1843 }
1844
1845
1846 SWIGINTERNINLINE unsigned long
1847 SWIG_As_unsigned_SS_long(PyObject* obj)
1848 {
1849 unsigned long v;
1850 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1851 /*
1852 this is needed to make valgrind/purify happier.
1853 */
1854 memset((void*)&v, 0, sizeof(unsigned long));
1855 }
1856 return v;
1857 }
1858
1859
1860 SWIGINTERNINLINE int
1861 SWIG_Check_unsigned_SS_long(PyObject* obj)
1862 {
1863 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1864 }
1865
1866
1867 SWIGINTERNINLINE PyObject*
1868 SWIG_From_unsigned_SS_long(unsigned long value)
1869 {
1870 return (value > LONG_MAX) ?
1871 PyLong_FromUnsignedLong(value)
1872 : PyInt_FromLong(static_cast<long >(value));
1873 }
1874
1875
1876 void* wxGetXDisplay()
1877 {
1878 #ifdef __WXGTK__
1879 return wxGetDisplay();
1880 #else
1881 return NULL;
1882 #endif
1883 }
1884
1885
1886 wxWindow* FindWindowAtPointer() {
1887 wxPoint unused;
1888 return wxFindWindowAtPointer(unused);
1889 }
1890
1891
1892 bool wxThread_IsMain() {
1893 #ifdef WXP_WITH_THREAD
1894 return wxThread::IsMain();
1895 #else
1896 return true;
1897 #endif
1898 }
1899
1900 static void wxCaret_Destroy(wxCaret *self){
1901 delete self;
1902 }
1903
1904 #include <wx/snglinst.h>
1905
1906
1907 #ifdef __WXMSW__
1908 #include <wx/msw/private.h>
1909 #include <wx/dynload.h>
1910 #endif
1911
1912
1913
1914 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1915 #if 0
1916 , int method
1917 #endif
1918 )
1919 {
1920 #ifdef __WXMSW__
1921 #if 0
1922 switch (method)
1923 {
1924 case 1:
1925 // This one only partially works. Appears to be an undocumented
1926 // "standard" convention that not all widgets adhear to. For
1927 // example, for some widgets backgrounds or non-client areas may
1928 // not be painted.
1929 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1930 break;
1931
1932 case 2:
1933 #endif
1934 // This one works much better, nearly all widgets and their
1935 // children are captured correctly[**]. Prior to the big
1936 // background erase changes that Vadim did in 2004-2005 this
1937 // method failed badly on XP with Themes activated, most native
1938 // widgets draw only partially, if at all. Without themes it
1939 // worked just like on Win2k. After those changes this method
1940 // works very well.
1941 //
1942 // ** For example the radio buttons in a wxRadioBox are not its
1943 // children by default, but you can capture it via the panel
1944 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1945 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1946 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1947 PRF_ERASEBKGND | PRF_OWNED );
1948 return true;
1949 #if 0
1950 break;
1951
1952 case 3:
1953 // This one is only defined in the latest SDK and is only
1954 // available on XP. MSDN says it is similar to sending WM_PRINT
1955 // so I expect that it will work similar to the above. Since it
1956 // is avaialble only on XP, it can't be compiled like this and
1957 // will have to be loaded dynamically.
1958 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1959
1960 // fall through
1961
1962 case 4:
1963 // Use PrintWindow if available, or fallback to WM_PRINT
1964 // otherwise. Unfortunately using PrintWindow is even worse than
1965 // WM_PRINT. For most native widgets nothing is drawn to the dc
1966 // at all, with or without Themes.
1967 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1968 static bool s_triedToLoad = false;
1969 static PrintWindow_t pfnPrintWindow = NULL;
1970 if ( !s_triedToLoad )
1971 {
1972
1973 s_triedToLoad = true;
1974 wxDynamicLibrary dllUser32(_T("user32.dll"));
1975 if ( dllUser32.IsLoaded() )
1976 {
1977 wxLogNull nolog; // Don't report errors here
1978 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1979 }
1980 }
1981 if (pfnPrintWindow)
1982 {
1983 //printf("Using PrintWindow\n");
1984 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1985 }
1986 else
1987 {
1988 //printf("Using WM_PRINT\n");
1989 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1990 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1991 PRF_ERASEBKGND | PRF_OWNED );
1992 }
1993 }
1994 #endif // 0
1995 #else
1996 return false;
1997 #endif // __WXMSW__
1998 }
1999
2000
2001
2002 #include <wx/tipdlg.h>
2003
2004
2005 class wxPyTipProvider : public wxTipProvider {
2006 public:
2007 wxPyTipProvider(size_t currentTip)
2008 : wxTipProvider(currentTip) {}
2009
2010 DEC_PYCALLBACK_STRING__pure(GetTip);
2011 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2012 PYPRIVATE;
2013 };
2014
2015 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2016 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2017
2018
2019 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
2020
2021 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
2022
2023 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
2024 : wxTimer(owner, id)
2025 {
2026 if (owner == NULL) SetOwner(this);
2027 }
2028
2029
2030 void wxPyTimer::Notify() {
2031 bool found;
2032 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2033 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
2034 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
2035 wxPyEndBlockThreads(blocked);
2036 if (! found)
2037 wxTimer::Notify();
2038 }
2039 void wxPyTimer::base_Notify() {
2040 wxTimer::Notify();
2041 }
2042
2043
2044
2045 SWIGINTERN PyObject *
2046 SWIG_FromCharPtr(const char* cptr)
2047 {
2048 if (cptr) {
2049 size_t size = strlen(cptr);
2050 if (size > INT_MAX) {
2051 return SWIG_NewPointerObj(const_cast<char* >(cptr),
2052 SWIG_TypeQuery("char *"), 0);
2053 } else {
2054 if (size != 0) {
2055 return PyString_FromStringAndSize(cptr, size);
2056 } else {
2057 return PyString_FromString(cptr);
2058 }
2059 }
2060 }
2061 Py_INCREF(Py_None);
2062 return Py_None;
2063 }
2064
2065
2066 SWIGINTERNINLINE int
2067 SWIG_CheckUnsignedLongInRange(unsigned long value,
2068 unsigned long max_value,
2069 const char *errmsg)
2070 {
2071 if (value > max_value) {
2072 if (errmsg) {
2073 PyErr_Format(PyExc_OverflowError,
2074 "value %lu is greater than '%s' minimum %lu",
2075 value, errmsg, max_value);
2076 }
2077 return 0;
2078 }
2079 return 1;
2080 }
2081
2082
2083 #if UINT_MAX != ULONG_MAX
2084 SWIGINTERN int
2085 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2086 {
2087 const char* errmsg = val ? "unsigned int" : (char*)0;
2088 unsigned long v;
2089 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2090 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2091 if (val) *val = static_cast<unsigned int >(v);
2092 return 1;
2093 }
2094 } else {
2095 PyErr_Clear();
2096 }
2097 if (val) {
2098 SWIG_type_error(errmsg, obj);
2099 }
2100 return 0;
2101 }
2102 #else
2103 SWIGINTERNINLINE unsigned int
2104 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2105 {
2106 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2107 }
2108 #endif
2109
2110
2111 SWIGINTERNINLINE unsigned int
2112 SWIG_As_unsigned_SS_int(PyObject* obj)
2113 {
2114 unsigned int v;
2115 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2116 /*
2117 this is needed to make valgrind/purify happier.
2118 */
2119 memset((void*)&v, 0, sizeof(unsigned int));
2120 }
2121 return v;
2122 }
2123
2124
2125 SWIGINTERNINLINE int
2126 SWIG_Check_unsigned_SS_int(PyObject* obj)
2127 {
2128 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2129 }
2130
2131 static wxString wxLog_TimeStamp(){
2132 wxString msg;
2133 wxLog::TimeStamp(&msg);
2134 return msg;
2135 }
2136 static void wxLog_Destroy(wxLog *self){ delete self; }
2137 // Make some wrappers that double any % signs so they are 'escaped'
2138 void wxPyLogFatalError(const wxString& msg)
2139 {
2140 wxString m(msg);
2141 m.Replace(wxT("%"), wxT("%%"));
2142 wxLogFatalError(m);
2143 }
2144
2145 void wxPyLogError(const wxString& msg)
2146 {
2147 wxString m(msg);
2148 m.Replace(wxT("%"), wxT("%%"));
2149 wxLogError(m);
2150 }
2151
2152 void wxPyLogWarning(const wxString& msg)
2153 {
2154 wxString m(msg);
2155 m.Replace(wxT("%"), wxT("%%"));
2156 wxLogWarning(m);
2157 }
2158
2159 void wxPyLogMessage(const wxString& msg)
2160 {
2161 wxString m(msg);
2162 m.Replace(wxT("%"), wxT("%%"));
2163 wxLogMessage(m);
2164 }
2165
2166 void wxPyLogInfo(const wxString& msg)
2167 {
2168 wxString m(msg);
2169 m.Replace(wxT("%"), wxT("%%"));
2170 wxLogInfo(m);
2171 }
2172
2173 void wxPyLogDebug(const wxString& msg)
2174 {
2175 wxString m(msg);
2176 m.Replace(wxT("%"), wxT("%%"));
2177 wxLogDebug(m);
2178 }
2179
2180 void wxPyLogVerbose(const wxString& msg)
2181 {
2182 wxString m(msg);
2183 m.Replace(wxT("%"), wxT("%%"));
2184 wxLogVerbose(m);
2185 }
2186
2187 void wxPyLogStatus(const wxString& msg)
2188 {
2189 wxString m(msg);
2190 m.Replace(wxT("%"), wxT("%%"));
2191 wxLogStatus(m);
2192 }
2193
2194 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2195 {
2196 wxString m(msg);
2197 m.Replace(wxT("%"), wxT("%%"));
2198 wxLogStatus(pFrame, m);
2199 }
2200
2201 void wxPyLogSysError(const wxString& msg)
2202 {
2203 wxString m(msg);
2204 m.Replace(wxT("%"), wxT("%%"));
2205 wxLogSysError(m);
2206 }
2207
2208 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2209 {
2210 wxString m(msg);
2211 m.Replace(wxT("%"), wxT("%%"));
2212 wxLogGeneric(level, m);
2213 }
2214
2215 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2216 {
2217 wxString m(msg);
2218 m.Replace(wxT("%"), wxT("%%"));
2219 wxLogTrace(mask, m);
2220 }
2221
2222 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2223 {
2224 wxString m(msg);
2225 m.Replace(wxT("%"), wxT("%%"));
2226 wxLogTrace(mask, m);
2227 }
2228
2229
2230
2231 // A wxLog class that can be derived from in wxPython
2232 class wxPyLog : public wxLog {
2233 public:
2234 wxPyLog() : wxLog() {}
2235
2236 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2237 bool found;
2238 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2239 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2240 PyObject* s = wx2PyString(szString);
2241 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2242 Py_DECREF(s);
2243 }
2244 wxPyEndBlockThreads(blocked);
2245 if (! found)
2246 wxLog::DoLog(level, szString, t);
2247 }
2248
2249 virtual void DoLogString(const wxChar *szString, time_t t) {
2250 bool found;
2251 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2252 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2253 PyObject* s = wx2PyString(szString);
2254 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2255 Py_DECREF(s);
2256 }
2257 wxPyEndBlockThreads(blocked);
2258 if (! found)
2259 wxLog::DoLogString(szString, t);
2260 }
2261
2262 PYPRIVATE;
2263 };
2264
2265
2266
2267
2268 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2269
2270
2271 #include <wx/joystick.h>
2272
2273
2274 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2275 // A C++ stub class for wxJoystick for platforms that don't have it.
2276 class wxJoystick : public wxObject {
2277 public:
2278 wxJoystick(int joystick = wxJOYSTICK1) {
2279 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2280 PyErr_SetString(PyExc_NotImplementedError,
2281 "wxJoystick is not available on this platform.");
2282 wxPyEndBlockThreads(blocked);
2283 }
2284 wxPoint GetPosition() { return wxPoint(-1,-1); }
2285 int GetZPosition() { return -1; }
2286 int GetButtonState() { return -1; }
2287 int GetPOVPosition() { return -1; }
2288 int GetPOVCTSPosition() { return -1; }
2289 int GetRudderPosition() { return -1; }
2290 int GetUPosition() { return -1; }
2291 int GetVPosition() { return -1; }
2292 int GetMovementThreshold() { return -1; }
2293 void SetMovementThreshold(int threshold) {}
2294
2295 bool IsOk(void) { return false; }
2296 int GetNumberJoysticks() { return -1; }
2297 int GetManufacturerId() { return -1; }
2298 int GetProductId() { return -1; }
2299 wxString GetProductName() { return wxEmptyString; }
2300 int GetXMin() { return -1; }
2301 int GetYMin() { return -1; }
2302 int GetZMin() { return -1; }
2303 int GetXMax() { return -1; }
2304 int GetYMax() { return -1; }
2305 int GetZMax() { return -1; }
2306 int GetNumberButtons() { return -1; }
2307 int GetNumberAxes() { return -1; }
2308 int GetMaxButtons() { return -1; }
2309 int GetMaxAxes() { return -1; }
2310 int GetPollingMin() { return -1; }
2311 int GetPollingMax() { return -1; }
2312 int GetRudderMin() { return -1; }
2313 int GetRudderMax() { return -1; }
2314 int GetUMin() { return -1; }
2315 int GetUMax() { return -1; }
2316 int GetVMin() { return -1; }
2317 int GetVMax() { return -1; }
2318
2319 bool HasRudder() { return false; }
2320 bool HasZ() { return false; }
2321 bool HasU() { return false; }
2322 bool HasV() { return false; }
2323 bool HasPOV() { return false; }
2324 bool HasPOV4Dir() { return false; }
2325 bool HasPOVCTS() { return false; }
2326
2327 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2328 bool ReleaseCapture() { return false; }
2329 };
2330 #endif
2331
2332
2333 #include <wx/sound.h>
2334
2335
2336 #if !wxUSE_SOUND
2337 // A C++ stub class for wxWave for platforms that don't have it.
2338 class wxSound : public wxObject
2339 {
2340 public:
2341 wxSound() {
2342 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2343 PyErr_SetString(PyExc_NotImplementedError,
2344 "wxSound is not available on this platform.");
2345 wxPyEndBlockThreads(blocked);
2346 }
2347 wxSound(const wxString&/*, bool*/) {
2348 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2349 PyErr_SetString(PyExc_NotImplementedError,
2350 "wxSound is not available on this platform.");
2351 wxPyEndBlockThreads(blocked);
2352 }
2353 wxSound(int, const wxByte*) {
2354 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2355 PyErr_SetString(PyExc_NotImplementedError,
2356 "wxSound is not available on this platform.");
2357 wxPyEndBlockThreads(blocked);
2358 }
2359
2360 ~wxSound() {};
2361
2362 bool Create(const wxString&/*, bool*/) { return false; }
2363 bool Create(int, const wxByte*) { return false; };
2364 bool IsOk() { return false; };
2365 bool Play(unsigned) const { return false; }
2366 static bool Play(const wxString&, unsigned) { return false; }
2367 static void Stop() {}
2368 };
2369
2370 #endif
2371
2372 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2373 if (fileName.Length() == 0)
2374 return new wxSound;
2375 else
2376 return new wxSound(fileName);
2377 }
2378 static wxSound *new_wxSound(PyObject *data){
2379 unsigned char* buffer; int size;
2380 wxSound *sound = NULL;
2381
2382 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2383 if (!PyArg_Parse(data, "t#", &buffer, &size))
2384 goto done;
2385 sound = new wxSound(size, buffer);
2386 done:
2387 wxPyEndBlockThreads(blocked);
2388 return sound;
2389 }
2390 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2391 #ifndef __WXMAC__
2392 unsigned char* buffer;
2393 int size;
2394 bool rv = false;
2395
2396 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2397 if (!PyArg_Parse(data, "t#", &buffer, &size))
2398 goto done;
2399 rv = self->Create(size, buffer);
2400 done:
2401 wxPyEndBlockThreads(blocked);
2402 return rv;
2403 #else
2404 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2405 PyErr_SetString(PyExc_NotImplementedError,
2406 "Create from data is not available on this platform.");
2407 wxPyEndBlockThreads(blocked);
2408 return false;
2409 #endif
2410 }
2411
2412 #include <wx/mimetype.h>
2413
2414 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2415 wxString str;
2416 if (self->GetMimeType(&str))
2417 return wx2PyString(str);
2418 else
2419 RETURN_NONE();
2420 }
2421 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2422 wxArrayString arr;
2423 if (self->GetMimeTypes(arr))
2424 return wxArrayString2PyList_helper(arr);
2425 else
2426 RETURN_NONE();
2427 }
2428 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2429 wxArrayString arr;
2430 if (self->GetExtensions(arr))
2431 return wxArrayString2PyList_helper(arr);
2432 else
2433 RETURN_NONE();
2434 }
2435 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2436 wxIconLocation loc;
2437 if (self->GetIcon(&loc))
2438 return new wxIcon(loc);
2439 else
2440 return NULL;
2441 }
2442 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2443 wxIconLocation loc;
2444 if (self->GetIcon(&loc)) {
2445 wxString iconFile = loc.GetFileName();
2446 int iconIndex = -1;
2447
2448 iconIndex = loc.GetIndex();
2449
2450 // Make a tuple and put the values in it
2451 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2452 PyObject* tuple = PyTuple_New(3);
2453 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2454 wxT("wxIcon"), true));
2455 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2456 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2457 wxPyEndBlockThreads(blocked);
2458 return tuple;
2459 }
2460 else
2461 RETURN_NONE();
2462 }
2463 static PyObject *wxFileType_GetDescription(wxFileType *self){
2464 wxString str;
2465 if (self->GetDescription(&str))
2466 return wx2PyString(str);
2467 else
2468 RETURN_NONE();
2469 }
2470 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2471 wxString str;
2472 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2473 return wx2PyString(str);
2474 else
2475 RETURN_NONE();
2476 }
2477 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2478 wxString str;
2479 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2480 return wx2PyString(str);
2481 else
2482 RETURN_NONE();
2483 }
2484 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2485 wxArrayString verbs;
2486 wxArrayString commands;
2487 if (self->GetAllCommands(&verbs, &commands,
2488 wxFileType::MessageParameters(filename, mimetype))) {
2489 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2490 PyObject* tuple = PyTuple_New(2);
2491 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2492 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2493 wxPyEndBlockThreads(blocked);
2494 return tuple;
2495 }
2496 else
2497 RETURN_NONE();
2498 }
2499 static wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2500 return wxFileType::ExpandCommand(command,
2501 wxFileType::MessageParameters(filename, mimetype));
2502 }
2503 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2504 wxArrayString arr;
2505 self->EnumAllFileTypes(arr);
2506 return wxArrayString2PyList_helper(arr);
2507 }
2508
2509 #include <wx/artprov.h>
2510
2511 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2512 static const wxString wxPyART_MENU(wxART_MENU);
2513 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2514 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2515 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2516 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2517 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2518 static const wxString wxPyART_OTHER(wxART_OTHER);
2519 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2520 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2521 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2522 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2523 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2524 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2525 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2526 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2527 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2528 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2529 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2530 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2531 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2532 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2533 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2534 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2535 static const wxString wxPyART_PRINT(wxART_PRINT);
2536 static const wxString wxPyART_HELP(wxART_HELP);
2537 static const wxString wxPyART_TIP(wxART_TIP);
2538 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2539 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2540 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2541 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2542 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2543 static const wxString wxPyART_CDROM(wxART_CDROM);
2544 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2545 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2546 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2547 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2548 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2549 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2550 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2551 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2552 static const wxString wxPyART_ERROR(wxART_ERROR);
2553 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2554 static const wxString wxPyART_WARNING(wxART_WARNING);
2555 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2556 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2557 static const wxString wxPyART_COPY(wxART_COPY);
2558 static const wxString wxPyART_CUT(wxART_CUT);
2559 static const wxString wxPyART_PASTE(wxART_PASTE);
2560 static const wxString wxPyART_DELETE(wxART_DELETE);
2561 static const wxString wxPyART_NEW(wxART_NEW);
2562 static const wxString wxPyART_UNDO(wxART_UNDO);
2563 static const wxString wxPyART_REDO(wxART_REDO);
2564 static const wxString wxPyART_QUIT(wxART_QUIT);
2565 static const wxString wxPyART_FIND(wxART_FIND);
2566 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2567 // Python aware wxArtProvider
2568 class wxPyArtProvider : public wxArtProvider {
2569 public:
2570
2571 virtual wxBitmap CreateBitmap(const wxArtID& id,
2572 const wxArtClient& client,
2573 const wxSize& size) {
2574 wxBitmap rval = wxNullBitmap;
2575 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2576 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2577 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2578 PyObject* ro;
2579 wxBitmap* ptr;
2580 PyObject* s1, *s2;
2581 s1 = wx2PyString(id);
2582 s2 = wx2PyString(client);
2583 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2584 Py_DECREF(so);
2585 Py_DECREF(s1);
2586 Py_DECREF(s2);
2587 if (ro) {
2588 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2589 rval = *ptr;
2590 Py_DECREF(ro);
2591 }
2592 }
2593 wxPyEndBlockThreads(blocked);
2594 return rval;
2595 }
2596
2597 PYPRIVATE;
2598 };
2599
2600 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2601
2602
2603
2604 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2605 PyObject* ret = PyTuple_New(3);
2606 if (ret) {
2607 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2608 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2609 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2610 }
2611 return ret;
2612 }
2613
2614 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2615 bool cont;
2616 long index = 0;
2617 wxString value;
2618
2619 cont = self->GetFirstGroup(value, index);
2620 return __EnumerationHelper(cont, value, index);
2621 }
2622 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2623 bool cont;
2624 wxString value;
2625
2626 cont = self->GetNextGroup(value, index);
2627 return __EnumerationHelper(cont, value, index);
2628 }
2629 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2630 bool cont;
2631 long index = 0;
2632 wxString value;
2633
2634 cont = self->GetFirstEntry(value, index);
2635 return __EnumerationHelper(cont, value, index);
2636 }
2637 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2638 bool cont;
2639 wxString value;
2640
2641 cont = self->GetNextEntry(value, index);
2642 return __EnumerationHelper(cont, value, index);
2643 }
2644 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2645 long rv;
2646 self->Read(key, &rv, defaultVal);
2647 return rv;
2648 }
2649
2650 SWIGINTERN int
2651 SWIG_AsVal_double(PyObject *obj, double* val)
2652 {
2653 if (PyNumber_Check(obj)) {
2654 if (val) *val = PyFloat_AsDouble(obj);
2655 return 1;
2656 }
2657 else {
2658 SWIG_Python_TypeError("number", obj);
2659 }
2660 return 0;
2661 }
2662
2663
2664 SWIGINTERNINLINE double
2665 SWIG_As_double(PyObject* obj)
2666 {
2667 double v;
2668 if (!SWIG_AsVal_double(obj, &v)) {
2669 /*
2670 this is needed to make valgrind/purify happier.
2671 */
2672 memset((void*)&v, 0, sizeof(double));
2673 }
2674 return v;
2675 }
2676
2677
2678 SWIGINTERNINLINE int
2679 SWIG_Check_double(PyObject* obj)
2680 {
2681 return SWIG_AsVal_double(obj, (double*)0);
2682 }
2683
2684 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2685 double rv;
2686 self->Read(key, &rv, defaultVal);
2687 return rv;
2688 }
2689
2690 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2691 #define SWIG_From_double PyFloat_FromDouble
2692 /*@@*/
2693
2694 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2695 bool rv;
2696 self->Read(key, &rv, defaultVal);
2697 return rv;
2698 }
2699
2700 #include <wx/datetime.h>
2701
2702 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2703 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2704
2705 #define LOCAL_TZ wxDateTime::Local
2706
2707 static PyObject *wxDateTime_GetAmPmStrings(){
2708 wxString am;
2709 wxString pm;
2710 wxDateTime::GetAmPmStrings(&am, &pm);
2711 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2712 PyObject* tup = PyTuple_New(2);
2713 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2714 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2715 wxPyEndBlockThreads(blocked);
2716 return tup;
2717 }
2718
2719 #if UINT_MAX < LONG_MAX
2720 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2721 #define SWIG_From_unsigned_SS_int SWIG_From_long
2722 /*@@*/
2723 #else
2724 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2725 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2726 /*@@*/
2727 #endif
2728
2729 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2730 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2731 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2732 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2733 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2734 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2735 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2736 return (*self < *other);
2737 }
2738 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2739 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2740 return (*self <= *other);
2741 }
2742 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2743 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2744 return (*self > *other);
2745 }
2746 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2747 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2748 return (*self >= *other);
2749 }
2750 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2751 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2752 return (*self == *other);
2753 }
2754 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2755 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2756 return (*self != *other);
2757 }
2758 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2759 const wxChar* rv;
2760 const wxChar* _date = date;
2761 rv = self->ParseRfc822Date(_date);
2762 if (rv == NULL) return -1;
2763 return rv - _date;
2764 }
2765 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2766 const wxChar* rv;
2767 const wxChar* _date = date;
2768 rv = self->ParseFormat(_date, format, dateDef);
2769 if (rv == NULL) return -1;
2770 return rv - _date;
2771 }
2772 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2773 const wxChar* rv;
2774 const wxChar* _datetime = datetime;
2775 rv = self->ParseDateTime(_datetime);
2776 if (rv == NULL) return -1;
2777 return rv - _datetime;
2778 }
2779 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2780 const wxChar* rv;
2781 const wxChar* _date = date;
2782 rv = self->ParseDate(_date);
2783 if (rv == NULL) return -1;
2784 return rv - _date;
2785 }
2786 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2787 const wxChar* rv;
2788 const wxChar* _time = time;
2789 rv = self->ParseTime(_time);
2790 if (rv == NULL) return -1;
2791 return rv - _time;
2792 }
2793 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2794 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2795 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2796 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2797 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2798 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2799 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2800 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2801 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2802 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2803 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2804 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2805 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2806 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2807 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2808 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2809
2810 #include <wx/dataobj.h>
2811
2812 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2813 size_t count = self->GetFormatCount(dir);
2814 wxDataFormat* formats = new wxDataFormat[count];
2815 self->GetAllFormats(formats, dir);
2816
2817 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2818 PyObject* list = PyList_New(count);
2819 for (size_t i=0; i<count; i++) {
2820 wxDataFormat* format = new wxDataFormat(formats[i]);
2821 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2822 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
2823 }
2824 wxPyEndBlockThreads(blocked);
2825 delete [] formats;
2826 return list;
2827 }
2828 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2829 PyObject* rval = NULL;
2830 size_t size = self->GetDataSize(format);
2831 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2832 if (size) {
2833 char* buf = new char[size];
2834 if (self->GetDataHere(format, buf))
2835 rval = PyString_FromStringAndSize(buf, size);
2836 delete [] buf;
2837 }
2838 if (! rval) {
2839 rval = Py_None;
2840 Py_INCREF(rval);
2841 }
2842 wxPyEndBlockThreads(blocked);
2843 return rval;
2844 }
2845 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2846 bool rval;
2847 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2848 if (PyString_Check(data)) {
2849 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2850 }
2851 else {
2852 // raise a TypeError if not a string
2853 PyErr_SetString(PyExc_TypeError, "String expected.");
2854 rval = false;
2855 }
2856 wxPyEndBlockThreads(blocked);
2857 return rval;
2858 }
2859 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2860 PyObject* rval = NULL;
2861 size_t size = self->GetDataSize();
2862 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2863 if (size) {
2864 char* buf = new char[size];
2865 if (self->GetDataHere(buf))
2866 rval = PyString_FromStringAndSize(buf, size);
2867 delete [] buf;
2868 }
2869 if (! rval) {
2870 rval = Py_None;
2871 Py_INCREF(rval);
2872 }
2873 wxPyEndBlockThreads(blocked);
2874 return rval;
2875 }
2876 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2877 bool rval;
2878 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2879 if (PyString_Check(data)) {
2880 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2881 }
2882 else {
2883 // raise a TypeError if not a string
2884 PyErr_SetString(PyExc_TypeError, "String expected.");
2885 rval = false;
2886 }
2887 wxPyEndBlockThreads(blocked);
2888 return rval;
2889 }
2890 // Create a new class for wxPython to use
2891 class wxPyDataObjectSimple : public wxDataObjectSimple {
2892 public:
2893 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2894 : wxDataObjectSimple(format) {}
2895
2896 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2897 bool GetDataHere(void *buf) const;
2898 bool SetData(size_t len, const void *buf) const;
2899 PYPRIVATE;
2900 };
2901
2902 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2903
2904 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2905 // We need to get the data for this object and write it to buf. I think
2906 // the best way to do this for wxPython is to have the Python method
2907 // return either a string or None and then act appropriately with the
2908 // C++ version.
2909
2910 bool rval = false;
2911 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2912 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2913 PyObject* ro;
2914 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2915 if (ro) {
2916 rval = (ro != Py_None && PyString_Check(ro));
2917 if (rval)
2918 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2919 Py_DECREF(ro);
2920 }
2921 }
2922 wxPyEndBlockThreads(blocked);
2923 return rval;
2924 }
2925
2926 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2927 // For this one we simply need to make a string from buf and len
2928 // and send it to the Python method.
2929 bool rval = false;
2930 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2931 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2932 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2933 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2934 Py_DECREF(data);
2935 }
2936 wxPyEndBlockThreads(blocked);
2937 return rval;
2938 }
2939
2940 // Create a new class for wxPython to use
2941 class wxPyTextDataObject : public wxTextDataObject {
2942 public:
2943 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2944 : wxTextDataObject(text) {}
2945
2946 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2947 DEC_PYCALLBACK_STRING__const(GetText);
2948 DEC_PYCALLBACK__STRING(SetText);
2949 PYPRIVATE;
2950 };
2951
2952 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2953 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2954 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2955
2956
2957 // Create a new class for wxPython to use
2958 class wxPyBitmapDataObject : public wxBitmapDataObject {
2959 public:
2960 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2961 : wxBitmapDataObject(bitmap) {}
2962
2963 wxBitmap GetBitmap() const;
2964 void SetBitmap(const wxBitmap& bitmap);
2965 PYPRIVATE;
2966 };
2967
2968 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2969 wxBitmap* rval = &wxNullBitmap;
2970 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2971 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2972 PyObject* ro;
2973 wxBitmap* ptr;
2974 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2975 if (ro) {
2976 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2977 rval = ptr;
2978 Py_DECREF(ro);
2979 }
2980 }
2981 wxPyEndBlockThreads(blocked);
2982 return *rval;
2983 }
2984
2985 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2986 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2987 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2988 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2989 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2990 Py_DECREF(bo);
2991 }
2992 wxPyEndBlockThreads(blocked);
2993 }
2994
2995 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2996 return new wxCustomDataObject(wxDataFormat(formatName));
2997 }
2998 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2999 bool rval;
3000 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3001 if (PyString_Check(data)) {
3002 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3003 }
3004 else {
3005 // raise a TypeError if not a string
3006 PyErr_SetString(PyExc_TypeError, "String expected.");
3007 rval = false;
3008 }
3009 wxPyEndBlockThreads(blocked);
3010 return rval;
3011 }
3012 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3013 PyObject* obj;
3014 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3015 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3016 wxPyEndBlockThreads(blocked);
3017 return obj;
3018 }
3019
3020 #include <wx/metafile.h>
3021
3022
3023 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3024
3025
3026 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3027 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3028 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3029 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3030 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3031
3032
3033 class wxPyTextDropTarget : public wxTextDropTarget {
3034 public:
3035 wxPyTextDropTarget() {}
3036
3037 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3038
3039 DEC_PYCALLBACK__(OnLeave);
3040 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3041 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3042 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3043 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3044
3045 PYPRIVATE;
3046 };
3047
3048 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3049 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3050 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3051 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3052 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3053 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3054
3055
3056
3057 class wxPyFileDropTarget : public wxFileDropTarget {
3058 public:
3059 wxPyFileDropTarget() {}
3060
3061 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3062
3063 DEC_PYCALLBACK__(OnLeave);
3064 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3065 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3066 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3067 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3068
3069 PYPRIVATE;
3070 };
3071
3072 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3073 const wxArrayString& filenames) {
3074 bool rval = false;
3075 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3076 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3077 PyObject* list = wxArrayString2PyList_helper(filenames);
3078 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3079 Py_DECREF(list);
3080 }
3081 wxPyEndBlockThreads(blocked);
3082 return rval;
3083 }
3084
3085
3086
3087 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3088 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3089 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3090 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3091 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
3092
3093
3094
3095
3096 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
3097
3098 #include <wx/display.h>
3099
3100 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
3101 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
3102
3103 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
3104 #if !wxUSE_DISPLAY
3105 #include <wx/dynarray.h>
3106 #include <wx/vidmode.h>
3107
3108 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
3109 #include "wx/arrimpl.cpp"
3110 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
3111 const wxVideoMode wxDefaultVideoMode;
3112
3113 class wxDisplay
3114 {
3115 public:
3116 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
3117 ~wxDisplay() {}
3118
3119 static size_t GetCount()
3120 { wxPyRaiseNotImplemented(); return 0; }
3121
3122 static int GetFromPoint(const wxPoint& pt)
3123 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
3124 static int GetFromWindow(wxWindow *window)
3125 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
3126
3127 virtual bool IsOk() const { return false; }
3128 virtual wxRect GetGeometry() const { wxRect r; return r; }
3129 virtual wxString GetName() const { return wxEmptyString; }
3130 bool IsPrimary() const { return false; }
3131
3132 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
3133 { wxArrayVideoModes a; return a; }
3134
3135 virtual wxVideoMode GetCurrentMode() const
3136 { return wxDefaultVideoMode; }
3137
3138 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
3139 { return false; }
3140
3141 void ResetMode() {}
3142 };
3143 #endif
3144
3145 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
3146 PyObject* pyList = NULL;
3147 wxArrayVideoModes arr = self->GetModes(mode);
3148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3149 pyList = PyList_New(0);
3150 for (int i=0; i < arr.GetCount(); i++) {
3151 wxVideoMode* m = new wxVideoMode(arr.Item(i));
3152 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
3153 PyList_Append(pyList, pyObj);
3154 Py_DECREF(pyObj);
3155 }
3156 wxPyEndBlockThreads(blocked);
3157 return pyList;
3158 }
3159
3160 #include <wx/stdpaths.h>
3161
3162 static wxStandardPaths *wxStandardPaths_Get(){
3163 return (wxStandardPaths*) &wxStandardPaths::Get();
3164 }
3165 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
3166 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
3167 #ifdef __cplusplus
3168 extern "C" {
3169 #endif
3170 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3171 PyObject *resultobj = NULL;
3172 wxSystemColour arg1 ;
3173 wxColour result;
3174 PyObject * obj0 = 0 ;
3175 char *kwnames[] = {
3176 (char *) "index", NULL
3177 };
3178
3179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3180 {
3181 arg1 = static_cast<wxSystemColour >(SWIG_As_int(obj0));
3182 if (SWIG_arg_fail(1)) SWIG_fail;
3183 }
3184 {
3185 if (!wxPyCheckForApp()) SWIG_fail;
3186 PyThreadState* __tstate = wxPyBeginAllowThreads();
3187 result = wxSystemSettings::GetColour(arg1);
3188
3189 wxPyEndAllowThreads(__tstate);
3190 if (PyErr_Occurred()) SWIG_fail;
3191 }
3192 {
3193 wxColour * resultptr;
3194 resultptr = new wxColour(static_cast<wxColour & >(result));
3195 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3196 }
3197 return resultobj;
3198 fail:
3199 return NULL;
3200 }
3201
3202
3203 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3204 PyObject *resultobj = NULL;
3205 wxSystemFont arg1 ;
3206 wxFont result;
3207 PyObject * obj0 = 0 ;
3208 char *kwnames[] = {
3209 (char *) "index", NULL
3210 };
3211
3212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3213 {
3214 arg1 = static_cast<wxSystemFont >(SWIG_As_int(obj0));
3215 if (SWIG_arg_fail(1)) SWIG_fail;
3216 }
3217 {
3218 if (!wxPyCheckForApp()) SWIG_fail;
3219 PyThreadState* __tstate = wxPyBeginAllowThreads();
3220 result = wxSystemSettings::GetFont(arg1);
3221
3222 wxPyEndAllowThreads(__tstate);
3223 if (PyErr_Occurred()) SWIG_fail;
3224 }
3225 {
3226 wxFont * resultptr;
3227 resultptr = new wxFont(static_cast<wxFont & >(result));
3228 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3229 }
3230 return resultobj;
3231 fail:
3232 return NULL;
3233 }
3234
3235
3236 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3237 PyObject *resultobj = NULL;
3238 wxSystemMetric arg1 ;
3239 wxWindow *arg2 = (wxWindow *) NULL ;
3240 int result;
3241 PyObject * obj0 = 0 ;
3242 PyObject * obj1 = 0 ;
3243 char *kwnames[] = {
3244 (char *) "index",(char *) "win", NULL
3245 };
3246
3247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3248 {
3249 arg1 = static_cast<wxSystemMetric >(SWIG_As_int(obj0));
3250 if (SWIG_arg_fail(1)) SWIG_fail;
3251 }
3252 if (obj1) {
3253 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3254 if (SWIG_arg_fail(2)) SWIG_fail;
3255 }
3256 {
3257 if (!wxPyCheckForApp()) SWIG_fail;
3258 PyThreadState* __tstate = wxPyBeginAllowThreads();
3259 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
3260
3261 wxPyEndAllowThreads(__tstate);
3262 if (PyErr_Occurred()) SWIG_fail;
3263 }
3264 {
3265 resultobj = SWIG_From_int(static_cast<int >(result));
3266 }
3267 return resultobj;
3268 fail:
3269 return NULL;
3270 }
3271
3272
3273 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3274 PyObject *resultobj = NULL;
3275 wxSystemFeature arg1 ;
3276 bool result;
3277 PyObject * obj0 = 0 ;
3278 char *kwnames[] = {
3279 (char *) "index", NULL
3280 };
3281
3282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3283 {
3284 arg1 = static_cast<wxSystemFeature >(SWIG_As_int(obj0));
3285 if (SWIG_arg_fail(1)) SWIG_fail;
3286 }
3287 {
3288 if (!wxPyCheckForApp()) SWIG_fail;
3289 PyThreadState* __tstate = wxPyBeginAllowThreads();
3290 result = (bool)wxSystemSettings::HasFeature(arg1);
3291
3292 wxPyEndAllowThreads(__tstate);
3293 if (PyErr_Occurred()) SWIG_fail;
3294 }
3295 {
3296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3297 }
3298 return resultobj;
3299 fail:
3300 return NULL;
3301 }
3302
3303
3304 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3305 PyObject *resultobj = NULL;
3306 wxSystemScreenType result;
3307 char *kwnames[] = {
3308 NULL
3309 };
3310
3311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3312 {
3313 if (!wxPyCheckForApp()) SWIG_fail;
3314 PyThreadState* __tstate = wxPyBeginAllowThreads();
3315 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3316
3317 wxPyEndAllowThreads(__tstate);
3318 if (PyErr_Occurred()) SWIG_fail;
3319 }
3320 resultobj = SWIG_From_int((result));
3321 return resultobj;
3322 fail:
3323 return NULL;
3324 }
3325
3326
3327 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3328 PyObject *resultobj = NULL;
3329 wxSystemScreenType arg1 ;
3330 PyObject * obj0 = 0 ;
3331 char *kwnames[] = {
3332 (char *) "screen", NULL
3333 };
3334
3335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3336 {
3337 arg1 = static_cast<wxSystemScreenType >(SWIG_As_int(obj0));
3338 if (SWIG_arg_fail(1)) SWIG_fail;
3339 }
3340 {
3341 if (!wxPyCheckForApp()) SWIG_fail;
3342 PyThreadState* __tstate = wxPyBeginAllowThreads();
3343 wxSystemSettings::SetScreenType(arg1);
3344
3345 wxPyEndAllowThreads(__tstate);
3346 if (PyErr_Occurred()) SWIG_fail;
3347 }
3348 Py_INCREF(Py_None); resultobj = Py_None;
3349 return resultobj;
3350 fail:
3351 return NULL;
3352 }
3353
3354
3355 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3356 PyObject *obj;
3357 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3358 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3359 Py_INCREF(obj);
3360 return Py_BuildValue((char *)"");
3361 }
3362 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3363 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3364 return 1;
3365 }
3366
3367
3368 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3369 PyObject *pyobj = NULL;
3370
3371 {
3372 #if wxUSE_UNICODE
3373 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3374 #else
3375 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3376 #endif
3377 }
3378 return pyobj;
3379 }
3380
3381
3382 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3383 PyObject *resultobj = NULL;
3384 wxSystemOptions *result;
3385 char *kwnames[] = {
3386 NULL
3387 };
3388
3389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3390 {
3391 PyThreadState* __tstate = wxPyBeginAllowThreads();
3392 result = (wxSystemOptions *)new wxSystemOptions();
3393
3394 wxPyEndAllowThreads(__tstate);
3395 if (PyErr_Occurred()) SWIG_fail;
3396 }
3397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3398 return resultobj;
3399 fail:
3400 return NULL;
3401 }
3402
3403
3404 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3405 PyObject *resultobj = NULL;
3406 wxString *arg1 = 0 ;
3407 wxString *arg2 = 0 ;
3408 bool temp1 = false ;
3409 bool temp2 = false ;
3410 PyObject * obj0 = 0 ;
3411 PyObject * obj1 = 0 ;
3412 char *kwnames[] = {
3413 (char *) "name",(char *) "value", NULL
3414 };
3415
3416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3417 {
3418 arg1 = wxString_in_helper(obj0);
3419 if (arg1 == NULL) SWIG_fail;
3420 temp1 = true;
3421 }
3422 {
3423 arg2 = wxString_in_helper(obj1);
3424 if (arg2 == NULL) SWIG_fail;
3425 temp2 = true;
3426 }
3427 {
3428 PyThreadState* __tstate = wxPyBeginAllowThreads();
3429 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3430
3431 wxPyEndAllowThreads(__tstate);
3432 if (PyErr_Occurred()) SWIG_fail;
3433 }
3434 Py_INCREF(Py_None); resultobj = Py_None;
3435 {
3436 if (temp1)
3437 delete arg1;
3438 }
3439 {
3440 if (temp2)
3441 delete arg2;
3442 }
3443 return resultobj;
3444 fail:
3445 {
3446 if (temp1)
3447 delete arg1;
3448 }
3449 {
3450 if (temp2)
3451 delete arg2;
3452 }
3453 return NULL;
3454 }
3455
3456
3457 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3458 PyObject *resultobj = NULL;
3459 wxString *arg1 = 0 ;
3460 int arg2 ;
3461 bool temp1 = false ;
3462 PyObject * obj0 = 0 ;
3463 PyObject * obj1 = 0 ;
3464 char *kwnames[] = {
3465 (char *) "name",(char *) "value", NULL
3466 };
3467
3468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3469 {
3470 arg1 = wxString_in_helper(obj0);
3471 if (arg1 == NULL) SWIG_fail;
3472 temp1 = true;
3473 }
3474 {
3475 arg2 = static_cast<int >(SWIG_As_int(obj1));
3476 if (SWIG_arg_fail(2)) SWIG_fail;
3477 }
3478 {
3479 PyThreadState* __tstate = wxPyBeginAllowThreads();
3480 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3481
3482 wxPyEndAllowThreads(__tstate);
3483 if (PyErr_Occurred()) SWIG_fail;
3484 }
3485 Py_INCREF(Py_None); resultobj = Py_None;
3486 {
3487 if (temp1)
3488 delete arg1;
3489 }
3490 return resultobj;
3491 fail:
3492 {
3493 if (temp1)
3494 delete arg1;
3495 }
3496 return NULL;
3497 }
3498
3499
3500 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3501 PyObject *resultobj = NULL;
3502 wxString *arg1 = 0 ;
3503 wxString result;
3504 bool temp1 = false ;
3505 PyObject * obj0 = 0 ;
3506 char *kwnames[] = {
3507 (char *) "name", NULL
3508 };
3509
3510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3511 {
3512 arg1 = wxString_in_helper(obj0);
3513 if (arg1 == NULL) SWIG_fail;
3514 temp1 = true;
3515 }
3516 {
3517 PyThreadState* __tstate = wxPyBeginAllowThreads();
3518 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3519
3520 wxPyEndAllowThreads(__tstate);
3521 if (PyErr_Occurred()) SWIG_fail;
3522 }
3523 {
3524 #if wxUSE_UNICODE
3525 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3526 #else
3527 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3528 #endif
3529 }
3530 {
3531 if (temp1)
3532 delete arg1;
3533 }
3534 return resultobj;
3535 fail:
3536 {
3537 if (temp1)
3538 delete arg1;
3539 }
3540 return NULL;
3541 }
3542
3543
3544 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3545 PyObject *resultobj = NULL;
3546 wxString *arg1 = 0 ;
3547 int result;
3548 bool temp1 = false ;
3549 PyObject * obj0 = 0 ;
3550 char *kwnames[] = {
3551 (char *) "name", NULL
3552 };
3553
3554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3555 {
3556 arg1 = wxString_in_helper(obj0);
3557 if (arg1 == NULL) SWIG_fail;
3558 temp1 = true;
3559 }
3560 {
3561 PyThreadState* __tstate = wxPyBeginAllowThreads();
3562 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3563
3564 wxPyEndAllowThreads(__tstate);
3565 if (PyErr_Occurred()) SWIG_fail;
3566 }
3567 {
3568 resultobj = SWIG_From_int(static_cast<int >(result));
3569 }
3570 {
3571 if (temp1)
3572 delete arg1;
3573 }
3574 return resultobj;
3575 fail:
3576 {
3577 if (temp1)
3578 delete arg1;
3579 }
3580 return NULL;
3581 }
3582
3583
3584 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3585 PyObject *resultobj = NULL;
3586 wxString *arg1 = 0 ;
3587 bool result;
3588 bool temp1 = false ;
3589 PyObject * obj0 = 0 ;
3590 char *kwnames[] = {
3591 (char *) "name", NULL
3592 };
3593
3594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3595 {
3596 arg1 = wxString_in_helper(obj0);
3597 if (arg1 == NULL) SWIG_fail;
3598 temp1 = true;
3599 }
3600 {
3601 PyThreadState* __tstate = wxPyBeginAllowThreads();
3602 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3603
3604 wxPyEndAllowThreads(__tstate);
3605 if (PyErr_Occurred()) SWIG_fail;
3606 }
3607 {
3608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3609 }
3610 {
3611 if (temp1)
3612 delete arg1;
3613 }
3614 return resultobj;
3615 fail:
3616 {
3617 if (temp1)
3618 delete arg1;
3619 }
3620 return NULL;
3621 }
3622
3623
3624 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3625 PyObject *resultobj = NULL;
3626 wxString *arg1 = 0 ;
3627 bool result;
3628 bool temp1 = false ;
3629 PyObject * obj0 = 0 ;
3630 char *kwnames[] = {
3631 (char *) "name", NULL
3632 };
3633
3634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3635 {
3636 arg1 = wxString_in_helper(obj0);
3637 if (arg1 == NULL) SWIG_fail;
3638 temp1 = true;
3639 }
3640 {
3641 PyThreadState* __tstate = wxPyBeginAllowThreads();
3642 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3643
3644 wxPyEndAllowThreads(__tstate);
3645 if (PyErr_Occurred()) SWIG_fail;
3646 }
3647 {
3648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3649 }
3650 {
3651 if (temp1)
3652 delete arg1;
3653 }
3654 return resultobj;
3655 fail:
3656 {
3657 if (temp1)
3658 delete arg1;
3659 }
3660 return NULL;
3661 }
3662
3663
3664 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3665 PyObject *obj;
3666 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3667 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3668 Py_INCREF(obj);
3669 return Py_BuildValue((char *)"");
3670 }
3671 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3672 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3673 return 1;
3674 }
3675
3676
3677 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3678 PyObject *pyobj = NULL;
3679
3680 {
3681 #if wxUSE_UNICODE
3682 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3683 #else
3684 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3685 #endif
3686 }
3687 return pyobj;
3688 }
3689
3690
3691 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3692 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3693 return 1;
3694 }
3695
3696
3697 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3698 PyObject *pyobj = NULL;
3699
3700 {
3701 #if wxUSE_UNICODE
3702 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3703 #else
3704 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3705 #endif
3706 }
3707 return pyobj;
3708 }
3709
3710
3711 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3712 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3713 return 1;
3714 }
3715
3716
3717 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3718 PyObject *pyobj = NULL;
3719
3720 {
3721 #if wxUSE_UNICODE
3722 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3723 #else
3724 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3725 #endif
3726 }
3727 return pyobj;
3728 }
3729
3730
3731 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3732 PyObject *resultobj = NULL;
3733 long result;
3734 char *kwnames[] = {
3735 NULL
3736 };
3737
3738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3739 {
3740 PyThreadState* __tstate = wxPyBeginAllowThreads();
3741 result = (long)wxNewId();
3742
3743 wxPyEndAllowThreads(__tstate);
3744 if (PyErr_Occurred()) SWIG_fail;
3745 }
3746 {
3747 resultobj = SWIG_From_long(static_cast<long >(result));
3748 }
3749 return resultobj;
3750 fail:
3751 return NULL;
3752 }
3753
3754
3755 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3756 PyObject *resultobj = NULL;
3757 long arg1 ;
3758 PyObject * obj0 = 0 ;
3759 char *kwnames[] = {
3760 (char *) "id", NULL
3761 };
3762
3763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3764 {
3765 arg1 = static_cast<long >(SWIG_As_long(obj0));
3766 if (SWIG_arg_fail(1)) SWIG_fail;
3767 }
3768 {
3769 PyThreadState* __tstate = wxPyBeginAllowThreads();
3770 wxRegisterId(arg1);
3771
3772 wxPyEndAllowThreads(__tstate);
3773 if (PyErr_Occurred()) SWIG_fail;
3774 }
3775 Py_INCREF(Py_None); resultobj = Py_None;
3776 return resultobj;
3777 fail:
3778 return NULL;
3779 }
3780
3781
3782 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3783 PyObject *resultobj = NULL;
3784 long result;
3785 char *kwnames[] = {
3786 NULL
3787 };
3788
3789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3790 {
3791 PyThreadState* __tstate = wxPyBeginAllowThreads();
3792 result = (long)wxGetCurrentId();
3793
3794 wxPyEndAllowThreads(__tstate);
3795 if (PyErr_Occurred()) SWIG_fail;
3796 }
3797 {
3798 resultobj = SWIG_From_long(static_cast<long >(result));
3799 }
3800 return resultobj;
3801 fail:
3802 return NULL;
3803 }
3804
3805
3806 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3807 PyObject *resultobj = NULL;
3808 int arg1 ;
3809 bool result;
3810 PyObject * obj0 = 0 ;
3811 char *kwnames[] = {
3812 (char *) "id", NULL
3813 };
3814
3815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3816 {
3817 arg1 = static_cast<int >(SWIG_As_int(obj0));
3818 if (SWIG_arg_fail(1)) SWIG_fail;
3819 }
3820 {
3821 PyThreadState* __tstate = wxPyBeginAllowThreads();
3822 result = (bool)wxIsStockID(arg1);
3823
3824 wxPyEndAllowThreads(__tstate);
3825 if (PyErr_Occurred()) SWIG_fail;
3826 }
3827 {
3828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3829 }
3830 return resultobj;
3831 fail:
3832 return NULL;
3833 }
3834
3835
3836 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3837 PyObject *resultobj = NULL;
3838 int arg1 ;
3839 wxString *arg2 = 0 ;
3840 bool result;
3841 bool temp2 = false ;
3842 PyObject * obj0 = 0 ;
3843 PyObject * obj1 = 0 ;
3844 char *kwnames[] = {
3845 (char *) "id",(char *) "label", NULL
3846 };
3847
3848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3849 {
3850 arg1 = static_cast<int >(SWIG_As_int(obj0));
3851 if (SWIG_arg_fail(1)) SWIG_fail;
3852 }
3853 {
3854 arg2 = wxString_in_helper(obj1);
3855 if (arg2 == NULL) SWIG_fail;
3856 temp2 = true;
3857 }
3858 {
3859 PyThreadState* __tstate = wxPyBeginAllowThreads();
3860 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3861
3862 wxPyEndAllowThreads(__tstate);
3863 if (PyErr_Occurred()) SWIG_fail;
3864 }
3865 {
3866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3867 }
3868 {
3869 if (temp2)
3870 delete arg2;
3871 }
3872 return resultobj;
3873 fail:
3874 {
3875 if (temp2)
3876 delete arg2;
3877 }
3878 return NULL;
3879 }
3880
3881
3882 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3883 PyObject *resultobj = NULL;
3884 int arg1 ;
3885 bool arg2 = (bool) true ;
3886 wxString arg3 = (wxString) wxPyEmptyString ;
3887 wxString result;
3888 PyObject * obj0 = 0 ;
3889 PyObject * obj1 = 0 ;
3890 PyObject * obj2 = 0 ;
3891 char *kwnames[] = {
3892 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3893 };
3894
3895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3896 {
3897 arg1 = static_cast<int >(SWIG_As_int(obj0));
3898 if (SWIG_arg_fail(1)) SWIG_fail;
3899 }
3900 if (obj1) {
3901 {
3902 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
3903 if (SWIG_arg_fail(2)) SWIG_fail;
3904 }
3905 }
3906 if (obj2) {
3907 {
3908 wxString* sptr = wxString_in_helper(obj2);
3909 if (sptr == NULL) SWIG_fail;
3910 arg3 = *sptr;
3911 delete sptr;
3912 }
3913 }
3914 {
3915 PyThreadState* __tstate = wxPyBeginAllowThreads();
3916 result = wxGetStockLabel(arg1,arg2,arg3);
3917
3918 wxPyEndAllowThreads(__tstate);
3919 if (PyErr_Occurred()) SWIG_fail;
3920 }
3921 {
3922 #if wxUSE_UNICODE
3923 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3924 #else
3925 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3926 #endif
3927 }
3928 return resultobj;
3929 fail:
3930 return NULL;
3931 }
3932
3933
3934 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3935 PyObject *resultobj = NULL;
3936 char *kwnames[] = {
3937 NULL
3938 };
3939
3940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3941 {
3942 if (!wxPyCheckForApp()) SWIG_fail;
3943 PyThreadState* __tstate = wxPyBeginAllowThreads();
3944 wxBell();
3945
3946 wxPyEndAllowThreads(__tstate);
3947 if (PyErr_Occurred()) SWIG_fail;
3948 }
3949 Py_INCREF(Py_None); resultobj = Py_None;
3950 return resultobj;
3951 fail:
3952 return NULL;
3953 }
3954
3955
3956 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3957 PyObject *resultobj = NULL;
3958 char *kwnames[] = {
3959 NULL
3960 };
3961
3962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3963 {
3964 if (!wxPyCheckForApp()) SWIG_fail;
3965 PyThreadState* __tstate = wxPyBeginAllowThreads();
3966 wxEndBusyCursor();
3967
3968 wxPyEndAllowThreads(__tstate);
3969 if (PyErr_Occurred()) SWIG_fail;
3970 }
3971 Py_INCREF(Py_None); resultobj = Py_None;
3972 return resultobj;
3973 fail:
3974 return NULL;
3975 }
3976
3977
3978 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3979 PyObject *resultobj = NULL;
3980 bool arg1 = (bool) true ;
3981 long result;
3982 PyObject * obj0 = 0 ;
3983 char *kwnames[] = {
3984 (char *) "resetTimer", NULL
3985 };
3986
3987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3988 if (obj0) {
3989 {
3990 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
3991 if (SWIG_arg_fail(1)) SWIG_fail;
3992 }
3993 }
3994 {
3995 PyThreadState* __tstate = wxPyBeginAllowThreads();
3996 result = (long)wxGetElapsedTime(arg1);
3997
3998 wxPyEndAllowThreads(__tstate);
3999 if (PyErr_Occurred()) SWIG_fail;
4000 }
4001 {
4002 resultobj = SWIG_From_long(static_cast<long >(result));
4003 }
4004 return resultobj;
4005 fail:
4006 return NULL;
4007 }
4008
4009
4010 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
4011 PyObject *resultobj = NULL;
4012 bool result;
4013 char *kwnames[] = {
4014 NULL
4015 };
4016
4017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
4018 {
4019 PyThreadState* __tstate = wxPyBeginAllowThreads();
4020 result = (bool)wxIsBusy();
4021
4022 wxPyEndAllowThreads(__tstate);
4023 if (PyErr_Occurred()) SWIG_fail;
4024 }
4025 {
4026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4027 }
4028 return resultobj;
4029 fail:
4030 return NULL;
4031 }
4032
4033
4034 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
4035 PyObject *resultobj = NULL;
4036 wxString result;
4037 char *kwnames[] = {
4038 NULL
4039 };
4040
4041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
4042 {
4043 PyThreadState* __tstate = wxPyBeginAllowThreads();
4044 result = wxNow();
4045
4046 wxPyEndAllowThreads(__tstate);
4047 if (PyErr_Occurred()) SWIG_fail;
4048 }
4049 {
4050 #if wxUSE_UNICODE
4051 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4052 #else
4053 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4054 #endif
4055 }
4056 return resultobj;
4057 fail:
4058 return NULL;
4059 }
4060
4061
4062 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
4063 PyObject *resultobj = NULL;
4064 wxString const &arg1_defvalue = wxPyEmptyString ;
4065 wxString *arg1 = (wxString *) &arg1_defvalue ;
4066 bool result;
4067 bool temp1 = false ;
4068 PyObject * obj0 = 0 ;
4069 char *kwnames[] = {
4070 (char *) "command", NULL
4071 };
4072
4073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
4074 if (obj0) {
4075 {
4076 arg1 = wxString_in_helper(obj0);
4077 if (arg1 == NULL) SWIG_fail;
4078 temp1 = true;
4079 }
4080 }
4081 {
4082 PyThreadState* __tstate = wxPyBeginAllowThreads();
4083 result = (bool)wxShell((wxString const &)*arg1);
4084
4085 wxPyEndAllowThreads(__tstate);
4086 if (PyErr_Occurred()) SWIG_fail;
4087 }
4088 {
4089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4090 }
4091 {
4092 if (temp1)
4093 delete arg1;
4094 }
4095 return resultobj;
4096 fail:
4097 {
4098 if (temp1)
4099 delete arg1;
4100 }
4101 return NULL;
4102 }
4103
4104
4105 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
4106 PyObject *resultobj = NULL;
4107 char *kwnames[] = {
4108 NULL
4109 };
4110
4111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
4112 {
4113 PyThreadState* __tstate = wxPyBeginAllowThreads();
4114 wxStartTimer();
4115
4116 wxPyEndAllowThreads(__tstate);
4117 if (PyErr_Occurred()) SWIG_fail;
4118 }
4119 Py_INCREF(Py_None); resultobj = Py_None;
4120 return resultobj;
4121 fail:
4122 return NULL;
4123 }
4124
4125
4126 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
4127 PyObject *resultobj = NULL;
4128 int *arg1 = (int *) 0 ;
4129 int *arg2 = (int *) 0 ;
4130 int result;
4131 int temp1 ;
4132 int res1 = 0 ;
4133 int temp2 ;
4134 int res2 = 0 ;
4135 char *kwnames[] = {
4136 NULL
4137 };
4138
4139 arg1 = &temp1; res1 = SWIG_NEWOBJ;
4140 arg2 = &temp2; res2 = SWIG_NEWOBJ;
4141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
4142 {
4143 PyThreadState* __tstate = wxPyBeginAllowThreads();
4144 result = (int)wxGetOsVersion(arg1,arg2);
4145
4146 wxPyEndAllowThreads(__tstate);
4147 if (PyErr_Occurred()) SWIG_fail;
4148 }
4149 {
4150 resultobj = SWIG_From_int(static_cast<int >(result));
4151 }
4152 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4153 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4154 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4155 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4156 return resultobj;
4157 fail:
4158 return NULL;
4159 }
4160
4161
4162 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4163 PyObject *resultobj = NULL;
4164 wxString result;
4165 char *kwnames[] = {
4166 NULL
4167 };
4168
4169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4170 {
4171 PyThreadState* __tstate = wxPyBeginAllowThreads();
4172 result = wxGetOsDescription();
4173
4174 wxPyEndAllowThreads(__tstate);
4175 if (PyErr_Occurred()) SWIG_fail;
4176 }
4177 {
4178 #if wxUSE_UNICODE
4179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4180 #else
4181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4182 #endif
4183 }
4184 return resultobj;
4185 fail:
4186 return NULL;
4187 }
4188
4189
4190 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4191 PyObject *resultobj = NULL;
4192 wxMemorySize result;
4193 char *kwnames[] = {
4194 NULL
4195 };
4196
4197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4198 {
4199 PyThreadState* __tstate = wxPyBeginAllowThreads();
4200 result = wxGetFreeMemory();
4201
4202 wxPyEndAllowThreads(__tstate);
4203 if (PyErr_Occurred()) SWIG_fail;
4204 }
4205 {
4206 wxMemorySize * resultptr;
4207 resultptr = new wxMemorySize(static_cast<wxMemorySize & >(result));
4208 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMemorySize, 1);
4209 }
4210 return resultobj;
4211 fail:
4212 return NULL;
4213 }
4214
4215
4216 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4217 PyObject *resultobj = NULL;
4218 wxShutdownFlags arg1 ;
4219 bool result;
4220 PyObject * obj0 = 0 ;
4221 char *kwnames[] = {
4222 (char *) "wFlags", NULL
4223 };
4224
4225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4226 {
4227 arg1 = static_cast<wxShutdownFlags >(SWIG_As_int(obj0));
4228 if (SWIG_arg_fail(1)) SWIG_fail;
4229 }
4230 {
4231 if (!wxPyCheckForApp()) SWIG_fail;
4232 PyThreadState* __tstate = wxPyBeginAllowThreads();
4233 result = (bool)wxShutdown(arg1);
4234
4235 wxPyEndAllowThreads(__tstate);
4236 if (PyErr_Occurred()) SWIG_fail;
4237 }
4238 {
4239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4240 }
4241 return resultobj;
4242 fail:
4243 return NULL;
4244 }
4245
4246
4247 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4248 PyObject *resultobj = NULL;
4249 int arg1 ;
4250 PyObject * obj0 = 0 ;
4251 char *kwnames[] = {
4252 (char *) "secs", NULL
4253 };
4254
4255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4256 {
4257 arg1 = static_cast<int >(SWIG_As_int(obj0));
4258 if (SWIG_arg_fail(1)) SWIG_fail;
4259 }
4260 {
4261 PyThreadState* __tstate = wxPyBeginAllowThreads();
4262 wxSleep(arg1);
4263
4264 wxPyEndAllowThreads(__tstate);
4265 if (PyErr_Occurred()) SWIG_fail;
4266 }
4267 Py_INCREF(Py_None); resultobj = Py_None;
4268 return resultobj;
4269 fail:
4270 return NULL;
4271 }
4272
4273
4274 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4275 PyObject *resultobj = NULL;
4276 unsigned long arg1 ;
4277 PyObject * obj0 = 0 ;
4278 char *kwnames[] = {
4279 (char *) "milliseconds", NULL
4280 };
4281
4282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4283 {
4284 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
4285 if (SWIG_arg_fail(1)) SWIG_fail;
4286 }
4287 {
4288 PyThreadState* __tstate = wxPyBeginAllowThreads();
4289 wxMilliSleep(arg1);
4290
4291 wxPyEndAllowThreads(__tstate);
4292 if (PyErr_Occurred()) SWIG_fail;
4293 }
4294 Py_INCREF(Py_None); resultobj = Py_None;
4295 return resultobj;
4296 fail:
4297 return NULL;
4298 }
4299
4300
4301 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4302 PyObject *resultobj = NULL;
4303 unsigned long arg1 ;
4304 PyObject * obj0 = 0 ;
4305 char *kwnames[] = {
4306 (char *) "microseconds", NULL
4307 };
4308
4309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4310 {
4311 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
4312 if (SWIG_arg_fail(1)) SWIG_fail;
4313 }
4314 {
4315 PyThreadState* __tstate = wxPyBeginAllowThreads();
4316 wxMicroSleep(arg1);
4317
4318 wxPyEndAllowThreads(__tstate);
4319 if (PyErr_Occurred()) SWIG_fail;
4320 }
4321 Py_INCREF(Py_None); resultobj = Py_None;
4322 return resultobj;
4323 fail:
4324 return NULL;
4325 }
4326
4327
4328 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4329 PyObject *resultobj = NULL;
4330 bool arg1 ;
4331 PyObject * obj0 = 0 ;
4332 char *kwnames[] = {
4333 (char *) "enable", NULL
4334 };
4335
4336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4337 {
4338 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
4339 if (SWIG_arg_fail(1)) SWIG_fail;
4340 }
4341 {
4342 PyThreadState* __tstate = wxPyBeginAllowThreads();
4343 wxEnableTopLevelWindows(arg1);
4344
4345 wxPyEndAllowThreads(__tstate);
4346 if (PyErr_Occurred()) SWIG_fail;
4347 }
4348 Py_INCREF(Py_None); resultobj = Py_None;
4349 return resultobj;
4350 fail:
4351 return NULL;
4352 }
4353
4354
4355 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4356 PyObject *resultobj = NULL;
4357 wxString *arg1 = 0 ;
4358 wxString result;
4359 bool temp1 = false ;
4360 PyObject * obj0 = 0 ;
4361 char *kwnames[] = {
4362 (char *) "in", NULL
4363 };
4364
4365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4366 {
4367 arg1 = wxString_in_helper(obj0);
4368 if (arg1 == NULL) SWIG_fail;
4369 temp1 = true;
4370 }
4371 {
4372 PyThreadState* __tstate = wxPyBeginAllowThreads();
4373 result = wxStripMenuCodes((wxString const &)*arg1);
4374
4375 wxPyEndAllowThreads(__tstate);
4376 if (PyErr_Occurred()) SWIG_fail;
4377 }
4378 {
4379 #if wxUSE_UNICODE
4380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4381 #else
4382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4383 #endif
4384 }
4385 {
4386 if (temp1)
4387 delete arg1;
4388 }
4389 return resultobj;
4390 fail:
4391 {
4392 if (temp1)
4393 delete arg1;
4394 }
4395 return NULL;
4396 }
4397
4398
4399 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4400 PyObject *resultobj = NULL;
4401 wxString result;
4402 char *kwnames[] = {
4403 NULL
4404 };
4405
4406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4407 {
4408 PyThreadState* __tstate = wxPyBeginAllowThreads();
4409 result = wxGetEmailAddress();
4410
4411 wxPyEndAllowThreads(__tstate);
4412 if (PyErr_Occurred()) SWIG_fail;
4413 }
4414 {
4415 #if wxUSE_UNICODE
4416 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4417 #else
4418 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4419 #endif
4420 }
4421 return resultobj;
4422 fail:
4423 return NULL;
4424 }
4425
4426
4427 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4428 PyObject *resultobj = NULL;
4429 wxString result;
4430 char *kwnames[] = {
4431 NULL
4432 };
4433
4434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4435 {
4436 PyThreadState* __tstate = wxPyBeginAllowThreads();
4437 result = wxGetHostName();
4438
4439 wxPyEndAllowThreads(__tstate);
4440 if (PyErr_Occurred()) SWIG_fail;
4441 }
4442 {
4443 #if wxUSE_UNICODE
4444 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4445 #else
4446 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4447 #endif
4448 }
4449 return resultobj;
4450 fail:
4451 return NULL;
4452 }
4453
4454
4455 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4456 PyObject *resultobj = NULL;
4457 wxString result;
4458 char *kwnames[] = {
4459 NULL
4460 };
4461
4462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4463 {
4464 PyThreadState* __tstate = wxPyBeginAllowThreads();
4465 result = wxGetFullHostName();
4466
4467 wxPyEndAllowThreads(__tstate);
4468 if (PyErr_Occurred()) SWIG_fail;
4469 }
4470 {
4471 #if wxUSE_UNICODE
4472 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4473 #else
4474 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4475 #endif
4476 }
4477 return resultobj;
4478 fail:
4479 return NULL;
4480 }
4481
4482
4483 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4484 PyObject *resultobj = NULL;
4485 wxString result;
4486 char *kwnames[] = {
4487 NULL
4488 };
4489
4490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4491 {
4492 PyThreadState* __tstate = wxPyBeginAllowThreads();
4493 result = wxGetUserId();
4494
4495 wxPyEndAllowThreads(__tstate);
4496 if (PyErr_Occurred()) SWIG_fail;
4497 }
4498 {
4499 #if wxUSE_UNICODE
4500 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4501 #else
4502 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4503 #endif
4504 }
4505 return resultobj;
4506 fail:
4507 return NULL;
4508 }
4509
4510
4511 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4512 PyObject *resultobj = NULL;
4513 wxString result;
4514 char *kwnames[] = {
4515 NULL
4516 };
4517
4518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4519 {
4520 PyThreadState* __tstate = wxPyBeginAllowThreads();
4521 result = wxGetUserName();
4522
4523 wxPyEndAllowThreads(__tstate);
4524 if (PyErr_Occurred()) SWIG_fail;
4525 }
4526 {
4527 #if wxUSE_UNICODE
4528 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4529 #else
4530 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4531 #endif
4532 }
4533 return resultobj;
4534 fail:
4535 return NULL;
4536 }
4537
4538
4539 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4540 PyObject *resultobj = NULL;
4541 wxString result;
4542 char *kwnames[] = {
4543 NULL
4544 };
4545
4546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4547 {
4548 PyThreadState* __tstate = wxPyBeginAllowThreads();
4549 result = wxGetHomeDir();
4550
4551 wxPyEndAllowThreads(__tstate);
4552 if (PyErr_Occurred()) SWIG_fail;
4553 }
4554 {
4555 #if wxUSE_UNICODE
4556 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4557 #else
4558 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4559 #endif
4560 }
4561 return resultobj;
4562 fail:
4563 return NULL;
4564 }
4565
4566
4567 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4568 PyObject *resultobj = NULL;
4569 wxString const &arg1_defvalue = wxPyEmptyString ;
4570 wxString *arg1 = (wxString *) &arg1_defvalue ;
4571 wxString result;
4572 bool temp1 = false ;
4573 PyObject * obj0 = 0 ;
4574 char *kwnames[] = {
4575 (char *) "user", NULL
4576 };
4577
4578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4579 if (obj0) {
4580 {
4581 arg1 = wxString_in_helper(obj0);
4582 if (arg1 == NULL) SWIG_fail;
4583 temp1 = true;
4584 }
4585 }
4586 {
4587 PyThreadState* __tstate = wxPyBeginAllowThreads();
4588 result = wxGetUserHome((wxString const &)*arg1);
4589
4590 wxPyEndAllowThreads(__tstate);
4591 if (PyErr_Occurred()) SWIG_fail;
4592 }
4593 {
4594 #if wxUSE_UNICODE
4595 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4596 #else
4597 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4598 #endif
4599 }
4600 {
4601 if (temp1)
4602 delete arg1;
4603 }
4604 return resultobj;
4605 fail:
4606 {
4607 if (temp1)
4608 delete arg1;
4609 }
4610 return NULL;
4611 }
4612
4613
4614 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4615 PyObject *resultobj = NULL;
4616 unsigned long result;
4617 char *kwnames[] = {
4618 NULL
4619 };
4620
4621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4622 {
4623 PyThreadState* __tstate = wxPyBeginAllowThreads();
4624 result = (unsigned long)wxGetProcessId();
4625
4626 wxPyEndAllowThreads(__tstate);
4627 if (PyErr_Occurred()) SWIG_fail;
4628 }
4629 {
4630 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
4631 }
4632 return resultobj;
4633 fail:
4634 return NULL;
4635 }
4636
4637
4638 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4639 PyObject *resultobj = NULL;
4640 char *kwnames[] = {
4641 NULL
4642 };
4643
4644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4645 {
4646 PyThreadState* __tstate = wxPyBeginAllowThreads();
4647 wxTrap();
4648
4649 wxPyEndAllowThreads(__tstate);
4650 if (PyErr_Occurred()) SWIG_fail;
4651 }
4652 Py_INCREF(Py_None); resultobj = Py_None;
4653 return resultobj;
4654 fail:
4655 return NULL;
4656 }
4657
4658
4659 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4660 PyObject *resultobj = NULL;
4661 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4662 wxString *arg1 = (wxString *) &arg1_defvalue ;
4663 wxString const &arg2_defvalue = wxPyEmptyString ;
4664 wxString *arg2 = (wxString *) &arg2_defvalue ;
4665 wxString const &arg3_defvalue = wxPyEmptyString ;
4666 wxString *arg3 = (wxString *) &arg3_defvalue ;
4667 wxString const &arg4_defvalue = wxPyEmptyString ;
4668 wxString *arg4 = (wxString *) &arg4_defvalue ;
4669 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4670 wxString *arg5 = (wxString *) &arg5_defvalue ;
4671 int arg6 = (int) 0 ;
4672 wxWindow *arg7 = (wxWindow *) NULL ;
4673 int arg8 = (int) -1 ;
4674 int arg9 = (int) -1 ;
4675 wxString result;
4676 bool temp1 = false ;
4677 bool temp2 = false ;
4678 bool temp3 = false ;
4679 bool temp4 = false ;
4680 bool temp5 = false ;
4681 PyObject * obj0 = 0 ;
4682 PyObject * obj1 = 0 ;
4683 PyObject * obj2 = 0 ;
4684 PyObject * obj3 = 0 ;
4685 PyObject * obj4 = 0 ;
4686 PyObject * obj5 = 0 ;
4687 PyObject * obj6 = 0 ;
4688 PyObject * obj7 = 0 ;
4689 PyObject * obj8 = 0 ;
4690 char *kwnames[] = {
4691 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4692 };
4693
4694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4695 if (obj0) {
4696 {
4697 arg1 = wxString_in_helper(obj0);
4698 if (arg1 == NULL) SWIG_fail;
4699 temp1 = true;
4700 }
4701 }
4702 if (obj1) {
4703 {
4704 arg2 = wxString_in_helper(obj1);
4705 if (arg2 == NULL) SWIG_fail;
4706 temp2 = true;
4707 }
4708 }
4709 if (obj2) {
4710 {
4711 arg3 = wxString_in_helper(obj2);
4712 if (arg3 == NULL) SWIG_fail;
4713 temp3 = true;
4714 }
4715 }
4716 if (obj3) {
4717 {
4718 arg4 = wxString_in_helper(obj3);
4719 if (arg4 == NULL) SWIG_fail;
4720 temp4 = true;
4721 }
4722 }
4723 if (obj4) {
4724 {
4725 arg5 = wxString_in_helper(obj4);
4726 if (arg5 == NULL) SWIG_fail;
4727 temp5 = true;
4728 }
4729 }
4730 if (obj5) {
4731 {
4732 arg6 = static_cast<int >(SWIG_As_int(obj5));
4733 if (SWIG_arg_fail(6)) SWIG_fail;
4734 }
4735 }
4736 if (obj6) {
4737 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4738 if (SWIG_arg_fail(7)) SWIG_fail;
4739 }
4740 if (obj7) {
4741 {
4742 arg8 = static_cast<int >(SWIG_As_int(obj7));
4743 if (SWIG_arg_fail(8)) SWIG_fail;
4744 }
4745 }
4746 if (obj8) {
4747 {
4748 arg9 = static_cast<int >(SWIG_As_int(obj8));
4749 if (SWIG_arg_fail(9)) SWIG_fail;
4750 }
4751 }
4752 {
4753 if (!wxPyCheckForApp()) SWIG_fail;
4754 PyThreadState* __tstate = wxPyBeginAllowThreads();
4755 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4756
4757 wxPyEndAllowThreads(__tstate);
4758 if (PyErr_Occurred()) SWIG_fail;
4759 }
4760 {
4761 #if wxUSE_UNICODE
4762 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4763 #else
4764 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4765 #endif
4766 }
4767 {
4768 if (temp1)
4769 delete arg1;
4770 }
4771 {
4772 if (temp2)
4773 delete arg2;
4774 }
4775 {
4776 if (temp3)
4777 delete arg3;
4778 }
4779 {
4780 if (temp4)
4781 delete arg4;
4782 }
4783 {
4784 if (temp5)
4785 delete arg5;
4786 }
4787 return resultobj;
4788 fail:
4789 {
4790 if (temp1)
4791 delete arg1;
4792 }
4793 {
4794 if (temp2)
4795 delete arg2;
4796 }
4797 {
4798 if (temp3)
4799 delete arg3;
4800 }
4801 {
4802 if (temp4)
4803 delete arg4;
4804 }
4805 {
4806 if (temp5)
4807 delete arg5;
4808 }
4809 return NULL;
4810 }
4811
4812
4813 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4814 PyObject *resultobj = NULL;
4815 wxString *arg1 = 0 ;
4816 wxString *arg2 = 0 ;
4817 wxString const &arg3_defvalue = wxPyEmptyString ;
4818 wxString *arg3 = (wxString *) &arg3_defvalue ;
4819 wxWindow *arg4 = (wxWindow *) NULL ;
4820 wxString result;
4821 bool temp1 = false ;
4822 bool temp2 = false ;
4823 bool temp3 = false ;
4824 PyObject * obj0 = 0 ;
4825 PyObject * obj1 = 0 ;
4826 PyObject * obj2 = 0 ;
4827 PyObject * obj3 = 0 ;
4828 char *kwnames[] = {
4829 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4830 };
4831
4832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4833 {
4834 arg1 = wxString_in_helper(obj0);
4835 if (arg1 == NULL) SWIG_fail;
4836 temp1 = true;
4837 }
4838 {
4839 arg2 = wxString_in_helper(obj1);
4840 if (arg2 == NULL) SWIG_fail;
4841 temp2 = true;
4842 }
4843 if (obj2) {
4844 {
4845 arg3 = wxString_in_helper(obj2);
4846 if (arg3 == NULL) SWIG_fail;
4847 temp3 = true;
4848 }
4849 }
4850 if (obj3) {
4851 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4852 if (SWIG_arg_fail(4)) SWIG_fail;
4853 }
4854 {
4855 if (!wxPyCheckForApp()) SWIG_fail;
4856 PyThreadState* __tstate = wxPyBeginAllowThreads();
4857 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4858
4859 wxPyEndAllowThreads(__tstate);
4860 if (PyErr_Occurred()) SWIG_fail;
4861 }
4862 {
4863 #if wxUSE_UNICODE
4864 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4865 #else
4866 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4867 #endif
4868 }
4869 {
4870 if (temp1)
4871 delete arg1;
4872 }
4873 {
4874 if (temp2)
4875 delete arg2;
4876 }
4877 {
4878 if (temp3)
4879 delete arg3;
4880 }
4881 return resultobj;
4882 fail:
4883 {
4884 if (temp1)
4885 delete arg1;
4886 }
4887 {
4888 if (temp2)
4889 delete arg2;
4890 }
4891 {
4892 if (temp3)
4893 delete arg3;
4894 }
4895 return NULL;
4896 }
4897
4898
4899 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4900 PyObject *resultobj = NULL;
4901 wxString *arg1 = 0 ;
4902 wxString *arg2 = 0 ;
4903 wxString const &arg3_defvalue = wxPyEmptyString ;
4904 wxString *arg3 = (wxString *) &arg3_defvalue ;
4905 wxWindow *arg4 = (wxWindow *) NULL ;
4906 wxString result;
4907 bool temp1 = false ;
4908 bool temp2 = false ;
4909 bool temp3 = false ;
4910 PyObject * obj0 = 0 ;
4911 PyObject * obj1 = 0 ;
4912 PyObject * obj2 = 0 ;
4913 PyObject * obj3 = 0 ;
4914 char *kwnames[] = {
4915 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4916 };
4917
4918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4919 {
4920 arg1 = wxString_in_helper(obj0);
4921 if (arg1 == NULL) SWIG_fail;
4922 temp1 = true;
4923 }
4924 {
4925 arg2 = wxString_in_helper(obj1);
4926 if (arg2 == NULL) SWIG_fail;
4927 temp2 = true;
4928 }
4929 if (obj2) {
4930 {
4931 arg3 = wxString_in_helper(obj2);
4932 if (arg3 == NULL) SWIG_fail;
4933 temp3 = true;
4934 }
4935 }
4936 if (obj3) {
4937 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4938 if (SWIG_arg_fail(4)) SWIG_fail;
4939 }
4940 {
4941 if (!wxPyCheckForApp()) SWIG_fail;
4942 PyThreadState* __tstate = wxPyBeginAllowThreads();
4943 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4944
4945 wxPyEndAllowThreads(__tstate);
4946 if (PyErr_Occurred()) SWIG_fail;
4947 }
4948 {
4949 #if wxUSE_UNICODE
4950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4951 #else
4952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4953 #endif
4954 }
4955 {
4956 if (temp1)
4957 delete arg1;
4958 }
4959 {
4960 if (temp2)
4961 delete arg2;
4962 }
4963 {
4964 if (temp3)
4965 delete arg3;
4966 }
4967 return resultobj;
4968 fail:
4969 {
4970 if (temp1)
4971 delete arg1;
4972 }
4973 {
4974 if (temp2)
4975 delete arg2;
4976 }
4977 {
4978 if (temp3)
4979 delete arg3;
4980 }
4981 return NULL;
4982 }
4983
4984
4985 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4986 PyObject *resultobj = NULL;
4987 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4988 wxString *arg1 = (wxString *) &arg1_defvalue ;
4989 wxString const &arg2_defvalue = wxPyEmptyString ;
4990 wxString *arg2 = (wxString *) &arg2_defvalue ;
4991 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4992 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4993 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4994 wxWindow *arg5 = (wxWindow *) NULL ;
4995 wxString result;
4996 bool temp1 = false ;
4997 bool temp2 = false ;
4998 wxPoint temp4 ;
4999 PyObject * obj0 = 0 ;
5000 PyObject * obj1 = 0 ;
5001 PyObject * obj2 = 0 ;
5002 PyObject * obj3 = 0 ;
5003 PyObject * obj4 = 0 ;
5004 char *kwnames[] = {
5005 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5006 };
5007
5008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5009 if (obj0) {
5010 {
5011 arg1 = wxString_in_helper(obj0);
5012 if (arg1 == NULL) SWIG_fail;
5013 temp1 = true;
5014 }
5015 }
5016 if (obj1) {
5017 {
5018 arg2 = wxString_in_helper(obj1);
5019 if (arg2 == NULL) SWIG_fail;
5020 temp2 = true;
5021 }
5022 }
5023 if (obj2) {
5024 {
5025 arg3 = static_cast<long >(SWIG_As_long(obj2));
5026 if (SWIG_arg_fail(3)) SWIG_fail;
5027 }
5028 }
5029 if (obj3) {
5030 {
5031 arg4 = &temp4;
5032 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5033 }
5034 }
5035 if (obj4) {
5036 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5037 if (SWIG_arg_fail(5)) SWIG_fail;
5038 }
5039 {
5040 if (!wxPyCheckForApp()) SWIG_fail;
5041 PyThreadState* __tstate = wxPyBeginAllowThreads();
5042 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5043
5044 wxPyEndAllowThreads(__tstate);
5045 if (PyErr_Occurred()) SWIG_fail;
5046 }
5047 {
5048 #if wxUSE_UNICODE
5049 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5050 #else
5051 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5052 #endif
5053 }
5054 {
5055 if (temp1)
5056 delete arg1;
5057 }
5058 {
5059 if (temp2)
5060 delete arg2;
5061 }
5062 return resultobj;
5063 fail:
5064 {
5065 if (temp1)
5066 delete arg1;
5067 }
5068 {
5069 if (temp2)
5070 delete arg2;
5071 }
5072 return NULL;
5073 }
5074
5075
5076 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5077 PyObject *resultobj = NULL;
5078 wxString *arg1 = 0 ;
5079 wxString const &arg2_defvalue = wxPyEmptyString ;
5080 wxString *arg2 = (wxString *) &arg2_defvalue ;
5081 wxString const &arg3_defvalue = wxPyEmptyString ;
5082 wxString *arg3 = (wxString *) &arg3_defvalue ;
5083 wxWindow *arg4 = (wxWindow *) NULL ;
5084 int arg5 = (int) -1 ;
5085 int arg6 = (int) -1 ;
5086 bool arg7 = (bool) true ;
5087 wxString result;
5088 bool temp1 = false ;
5089 bool temp2 = false ;
5090 bool temp3 = false ;
5091 PyObject * obj0 = 0 ;
5092 PyObject * obj1 = 0 ;
5093 PyObject * obj2 = 0 ;
5094 PyObject * obj3 = 0 ;
5095 PyObject * obj4 = 0 ;
5096 PyObject * obj5 = 0 ;
5097 PyObject * obj6 = 0 ;
5098 char *kwnames[] = {
5099 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5100 };
5101
5102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
5103 {
5104 arg1 = wxString_in_helper(obj0);
5105 if (arg1 == NULL) SWIG_fail;
5106 temp1 = true;
5107 }
5108 if (obj1) {
5109 {
5110 arg2 = wxString_in_helper(obj1);
5111 if (arg2 == NULL) SWIG_fail;
5112 temp2 = true;
5113 }
5114 }
5115 if (obj2) {
5116 {
5117 arg3 = wxString_in_helper(obj2);
5118 if (arg3 == NULL) SWIG_fail;
5119 temp3 = true;
5120 }
5121 }
5122 if (obj3) {
5123 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5124 if (SWIG_arg_fail(4)) SWIG_fail;
5125 }
5126 if (obj4) {
5127 {
5128 arg5 = static_cast<int >(SWIG_As_int(obj4));
5129 if (SWIG_arg_fail(5)) SWIG_fail;
5130 }
5131 }
5132 if (obj5) {
5133 {
5134 arg6 = static_cast<int >(SWIG_As_int(obj5));
5135 if (SWIG_arg_fail(6)) SWIG_fail;
5136 }
5137 }
5138 if (obj6) {
5139 {
5140 arg7 = static_cast<bool >(SWIG_As_bool(obj6));
5141 if (SWIG_arg_fail(7)) SWIG_fail;
5142 }
5143 }
5144 {
5145 if (!wxPyCheckForApp()) SWIG_fail;
5146 PyThreadState* __tstate = wxPyBeginAllowThreads();
5147 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
5148
5149 wxPyEndAllowThreads(__tstate);
5150 if (PyErr_Occurred()) SWIG_fail;
5151 }
5152 {
5153 #if wxUSE_UNICODE
5154 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5155 #else
5156 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5157 #endif
5158 }
5159 {
5160 if (temp1)
5161 delete arg1;
5162 }
5163 {
5164 if (temp2)
5165 delete arg2;
5166 }
5167 {
5168 if (temp3)
5169 delete arg3;
5170 }
5171 return resultobj;
5172 fail:
5173 {
5174 if (temp1)
5175 delete arg1;
5176 }
5177 {
5178 if (temp2)
5179 delete arg2;
5180 }
5181 {
5182 if (temp3)
5183 delete arg3;
5184 }
5185 return NULL;
5186 }
5187
5188
5189 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5190 PyObject *resultobj = NULL;
5191 wxString *arg1 = 0 ;
5192 wxString const &arg2_defvalue = wxPyEmptyString ;
5193 wxString *arg2 = (wxString *) &arg2_defvalue ;
5194 wxString const &arg3_defvalue = wxPyEmptyString ;
5195 wxString *arg3 = (wxString *) &arg3_defvalue ;
5196 wxWindow *arg4 = (wxWindow *) NULL ;
5197 wxString result;
5198 bool temp1 = false ;
5199 bool temp2 = false ;
5200 bool temp3 = false ;
5201 PyObject * obj0 = 0 ;
5202 PyObject * obj1 = 0 ;
5203 PyObject * obj2 = 0 ;
5204 PyObject * obj3 = 0 ;
5205 char *kwnames[] = {
5206 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5207 };
5208
5209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5210 {
5211 arg1 = wxString_in_helper(obj0);
5212 if (arg1 == NULL) SWIG_fail;
5213 temp1 = true;
5214 }
5215 if (obj1) {
5216 {
5217 arg2 = wxString_in_helper(obj1);
5218 if (arg2 == NULL) SWIG_fail;
5219 temp2 = true;
5220 }
5221 }
5222 if (obj2) {
5223 {
5224 arg3 = wxString_in_helper(obj2);
5225 if (arg3 == NULL) SWIG_fail;
5226 temp3 = true;
5227 }
5228 }
5229 if (obj3) {
5230 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5231 if (SWIG_arg_fail(4)) SWIG_fail;
5232 }
5233 {
5234 if (!wxPyCheckForApp()) SWIG_fail;
5235 PyThreadState* __tstate = wxPyBeginAllowThreads();
5236 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5237
5238 wxPyEndAllowThreads(__tstate);
5239 if (PyErr_Occurred()) SWIG_fail;
5240 }
5241 {
5242 #if wxUSE_UNICODE
5243 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5244 #else
5245 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5246 #endif
5247 }
5248 {
5249 if (temp1)
5250 delete arg1;
5251 }
5252 {
5253 if (temp2)
5254 delete arg2;
5255 }
5256 {
5257 if (temp3)
5258 delete arg3;
5259 }
5260 return resultobj;
5261 fail:
5262 {
5263 if (temp1)
5264 delete arg1;
5265 }
5266 {
5267 if (temp2)
5268 delete arg2;
5269 }
5270 {
5271 if (temp3)
5272 delete arg3;
5273 }
5274 return NULL;
5275 }
5276
5277
5278 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5279 PyObject *resultobj = NULL;
5280 wxString *arg1 = 0 ;
5281 wxString *arg2 = 0 ;
5282 int arg3 ;
5283 wxString *arg4 = (wxString *) 0 ;
5284 wxWindow *arg5 = (wxWindow *) NULL ;
5285 int arg6 = (int) -1 ;
5286 int arg7 = (int) -1 ;
5287 bool arg8 = (bool) true ;
5288 int arg9 = (int) 150 ;
5289 int arg10 = (int) 200 ;
5290 wxString result;
5291 bool temp1 = false ;
5292 bool temp2 = false ;
5293 PyObject * obj0 = 0 ;
5294 PyObject * obj1 = 0 ;
5295 PyObject * obj2 = 0 ;
5296 PyObject * obj3 = 0 ;
5297 PyObject * obj4 = 0 ;
5298 PyObject * obj5 = 0 ;
5299 PyObject * obj6 = 0 ;
5300 PyObject * obj7 = 0 ;
5301 PyObject * obj8 = 0 ;
5302 char *kwnames[] = {
5303 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5304 };
5305
5306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5307 {
5308 arg1 = wxString_in_helper(obj0);
5309 if (arg1 == NULL) SWIG_fail;
5310 temp1 = true;
5311 }
5312 {
5313 arg2 = wxString_in_helper(obj1);
5314 if (arg2 == NULL) SWIG_fail;
5315 temp2 = true;
5316 }
5317 {
5318 arg3 = PyList_Size(obj2);
5319 arg4 = wxString_LIST_helper(obj2);
5320 if (arg4 == NULL) SWIG_fail;
5321 }
5322 if (obj3) {
5323 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5324 if (SWIG_arg_fail(5)) SWIG_fail;
5325 }
5326 if (obj4) {
5327 {
5328 arg6 = static_cast<int >(SWIG_As_int(obj4));
5329 if (SWIG_arg_fail(6)) SWIG_fail;
5330 }
5331 }
5332 if (obj5) {
5333 {
5334 arg7 = static_cast<int >(SWIG_As_int(obj5));
5335 if (SWIG_arg_fail(7)) SWIG_fail;
5336 }
5337 }
5338 if (obj6) {
5339 {
5340 arg8 = static_cast<bool >(SWIG_As_bool(obj6));
5341 if (SWIG_arg_fail(8)) SWIG_fail;
5342 }
5343 }
5344 if (obj7) {
5345 {
5346 arg9 = static_cast<int >(SWIG_As_int(obj7));
5347 if (SWIG_arg_fail(9)) SWIG_fail;
5348 }
5349 }
5350 if (obj8) {
5351 {
5352 arg10 = static_cast<int >(SWIG_As_int(obj8));
5353 if (SWIG_arg_fail(10)) SWIG_fail;
5354 }
5355 }
5356 {
5357 if (!wxPyCheckForApp()) SWIG_fail;
5358 PyThreadState* __tstate = wxPyBeginAllowThreads();
5359 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5360
5361 wxPyEndAllowThreads(__tstate);
5362 if (PyErr_Occurred()) SWIG_fail;
5363 }
5364 {
5365 #if wxUSE_UNICODE
5366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5367 #else
5368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5369 #endif
5370 }
5371 {
5372 if (temp1)
5373 delete arg1;
5374 }
5375 {
5376 if (temp2)
5377 delete arg2;
5378 }
5379 {
5380 if (arg4) delete [] arg4;
5381 }
5382 return resultobj;
5383 fail:
5384 {
5385 if (temp1)
5386 delete arg1;
5387 }
5388 {
5389 if (temp2)
5390 delete arg2;
5391 }
5392 {
5393 if (arg4) delete [] arg4;
5394 }
5395 return NULL;
5396 }
5397
5398
5399 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5400 PyObject *resultobj = NULL;
5401 wxString *arg1 = 0 ;
5402 wxString *arg2 = 0 ;
5403 int arg3 ;
5404 wxString *arg4 = (wxString *) 0 ;
5405 wxWindow *arg5 = (wxWindow *) NULL ;
5406 int arg6 = (int) -1 ;
5407 int arg7 = (int) -1 ;
5408 bool arg8 = (bool) true ;
5409 int arg9 = (int) 150 ;
5410 int arg10 = (int) 200 ;
5411 int result;
5412 bool temp1 = false ;
5413 bool temp2 = false ;
5414 PyObject * obj0 = 0 ;
5415 PyObject * obj1 = 0 ;
5416 PyObject * obj2 = 0 ;
5417 PyObject * obj3 = 0 ;
5418 PyObject * obj4 = 0 ;
5419 PyObject * obj5 = 0 ;
5420 PyObject * obj6 = 0 ;
5421 PyObject * obj7 = 0 ;
5422 PyObject * obj8 = 0 ;
5423 char *kwnames[] = {
5424 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5425 };
5426
5427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5428 {
5429 arg1 = wxString_in_helper(obj0);
5430 if (arg1 == NULL) SWIG_fail;
5431 temp1 = true;
5432 }
5433 {
5434 arg2 = wxString_in_helper(obj1);
5435 if (arg2 == NULL) SWIG_fail;
5436 temp2 = true;
5437 }
5438 {
5439 arg3 = PyList_Size(obj2);
5440 arg4 = wxString_LIST_helper(obj2);
5441 if (arg4 == NULL) SWIG_fail;
5442 }
5443 if (obj3) {
5444 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5445 if (SWIG_arg_fail(5)) SWIG_fail;
5446 }
5447 if (obj4) {
5448 {
5449 arg6 = static_cast<int >(SWIG_As_int(obj4));
5450 if (SWIG_arg_fail(6)) SWIG_fail;
5451 }
5452 }
5453 if (obj5) {
5454 {
5455 arg7 = static_cast<int >(SWIG_As_int(obj5));
5456 if (SWIG_arg_fail(7)) SWIG_fail;
5457 }
5458 }
5459 if (obj6) {
5460 {
5461 arg8 = static_cast<bool >(SWIG_As_bool(obj6));
5462 if (SWIG_arg_fail(8)) SWIG_fail;
5463 }
5464 }
5465 if (obj7) {
5466 {
5467 arg9 = static_cast<int >(SWIG_As_int(obj7));
5468 if (SWIG_arg_fail(9)) SWIG_fail;
5469 }
5470 }
5471 if (obj8) {
5472 {
5473 arg10 = static_cast<int >(SWIG_As_int(obj8));
5474 if (SWIG_arg_fail(10)) SWIG_fail;
5475 }
5476 }
5477 {
5478 if (!wxPyCheckForApp()) SWIG_fail;
5479 PyThreadState* __tstate = wxPyBeginAllowThreads();
5480 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5481
5482 wxPyEndAllowThreads(__tstate);
5483 if (PyErr_Occurred()) SWIG_fail;
5484 }
5485 {
5486 resultobj = SWIG_From_int(static_cast<int >(result));
5487 }
5488 {
5489 if (temp1)
5490 delete arg1;
5491 }
5492 {
5493 if (temp2)
5494 delete arg2;
5495 }
5496 {
5497 if (arg4) delete [] arg4;
5498 }
5499 return resultobj;
5500 fail:
5501 {
5502 if (temp1)
5503 delete arg1;
5504 }
5505 {
5506 if (temp2)
5507 delete arg2;
5508 }
5509 {
5510 if (arg4) delete [] arg4;
5511 }
5512 return NULL;
5513 }
5514
5515
5516 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5517 PyObject *resultobj = NULL;
5518 wxString *arg1 = 0 ;
5519 wxString const &arg2_defvalue = wxPyEmptyString ;
5520 wxString *arg2 = (wxString *) &arg2_defvalue ;
5521 int arg3 = (int) wxOK|wxCENTRE ;
5522 wxWindow *arg4 = (wxWindow *) NULL ;
5523 int arg5 = (int) -1 ;
5524 int arg6 = (int) -1 ;
5525 int result;
5526 bool temp1 = false ;
5527 bool temp2 = false ;
5528 PyObject * obj0 = 0 ;
5529 PyObject * obj1 = 0 ;
5530 PyObject * obj2 = 0 ;
5531 PyObject * obj3 = 0 ;
5532 PyObject * obj4 = 0 ;
5533 PyObject * obj5 = 0 ;
5534 char *kwnames[] = {
5535 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5536 };
5537
5538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5539 {
5540 arg1 = wxString_in_helper(obj0);
5541 if (arg1 == NULL) SWIG_fail;
5542 temp1 = true;
5543 }
5544 if (obj1) {
5545 {
5546 arg2 = wxString_in_helper(obj1);
5547 if (arg2 == NULL) SWIG_fail;
5548 temp2 = true;
5549 }
5550 }
5551 if (obj2) {
5552 {
5553 arg3 = static_cast<int >(SWIG_As_int(obj2));
5554 if (SWIG_arg_fail(3)) SWIG_fail;
5555 }
5556 }
5557 if (obj3) {
5558 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5559 if (SWIG_arg_fail(4)) SWIG_fail;
5560 }
5561 if (obj4) {
5562 {
5563 arg5 = static_cast<int >(SWIG_As_int(obj4));
5564 if (SWIG_arg_fail(5)) SWIG_fail;
5565 }
5566 }
5567 if (obj5) {
5568 {
5569 arg6 = static_cast<int >(SWIG_As_int(obj5));
5570 if (SWIG_arg_fail(6)) SWIG_fail;
5571 }
5572 }
5573 {
5574 if (!wxPyCheckForApp()) SWIG_fail;
5575 PyThreadState* __tstate = wxPyBeginAllowThreads();
5576 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5577
5578 wxPyEndAllowThreads(__tstate);
5579 if (PyErr_Occurred()) SWIG_fail;
5580 }
5581 {
5582 resultobj = SWIG_From_int(static_cast<int >(result));
5583 }
5584 {
5585 if (temp1)
5586 delete arg1;
5587 }
5588 {
5589 if (temp2)
5590 delete arg2;
5591 }
5592 return resultobj;
5593 fail:
5594 {
5595 if (temp1)
5596 delete arg1;
5597 }
5598 {
5599 if (temp2)
5600 delete arg2;
5601 }
5602 return NULL;
5603 }
5604
5605
5606 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5607 PyObject *resultobj = NULL;
5608 bool result;
5609 char *kwnames[] = {
5610 NULL
5611 };
5612
5613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5614 {
5615 if (!wxPyCheckForApp()) SWIG_fail;
5616 PyThreadState* __tstate = wxPyBeginAllowThreads();
5617 result = (bool)wxColourDisplay();
5618
5619 wxPyEndAllowThreads(__tstate);
5620 if (PyErr_Occurred()) SWIG_fail;
5621 }
5622 {
5623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5624 }
5625 return resultobj;
5626 fail:
5627 return NULL;
5628 }
5629
5630
5631 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5632 PyObject *resultobj = NULL;
5633 int result;
5634 char *kwnames[] = {
5635 NULL
5636 };
5637
5638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5639 {
5640 if (!wxPyCheckForApp()) SWIG_fail;
5641 PyThreadState* __tstate = wxPyBeginAllowThreads();
5642 result = (int)wxDisplayDepth();
5643
5644 wxPyEndAllowThreads(__tstate);
5645 if (PyErr_Occurred()) SWIG_fail;
5646 }
5647 {
5648 resultobj = SWIG_From_int(static_cast<int >(result));
5649 }
5650 return resultobj;
5651 fail:
5652 return NULL;
5653 }
5654
5655
5656 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5657 PyObject *resultobj = NULL;
5658 int result;
5659 char *kwnames[] = {
5660 NULL
5661 };
5662
5663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5664 {
5665 if (!wxPyCheckForApp()) SWIG_fail;
5666 PyThreadState* __tstate = wxPyBeginAllowThreads();
5667 result = (int)wxGetDisplayDepth();
5668
5669 wxPyEndAllowThreads(__tstate);
5670 if (PyErr_Occurred()) SWIG_fail;
5671 }
5672 {
5673 resultobj = SWIG_From_int(static_cast<int >(result));
5674 }
5675 return resultobj;
5676 fail:
5677 return NULL;
5678 }
5679
5680
5681 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5682 PyObject *resultobj = NULL;
5683 int *arg1 = (int *) 0 ;
5684 int *arg2 = (int *) 0 ;
5685 int temp1 ;
5686 int res1 = 0 ;
5687 int temp2 ;
5688 int res2 = 0 ;
5689 char *kwnames[] = {
5690 NULL
5691 };
5692
5693 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5694 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5696 {
5697 if (!wxPyCheckForApp()) SWIG_fail;
5698 PyThreadState* __tstate = wxPyBeginAllowThreads();
5699 wxDisplaySize(arg1,arg2);
5700
5701 wxPyEndAllowThreads(__tstate);
5702 if (PyErr_Occurred()) SWIG_fail;
5703 }
5704 Py_INCREF(Py_None); resultobj = Py_None;
5705 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5706 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5707 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5708 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5709 return resultobj;
5710 fail:
5711 return NULL;
5712 }
5713
5714
5715 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5716 PyObject *resultobj = NULL;
5717 wxSize result;
5718 char *kwnames[] = {
5719 NULL
5720 };
5721
5722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5723 {
5724 if (!wxPyCheckForApp()) SWIG_fail;
5725 PyThreadState* __tstate = wxPyBeginAllowThreads();
5726 result = wxGetDisplaySize();
5727
5728 wxPyEndAllowThreads(__tstate);
5729 if (PyErr_Occurred()) SWIG_fail;
5730 }
5731 {
5732 wxSize * resultptr;
5733 resultptr = new wxSize(static_cast<wxSize & >(result));
5734 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5735 }
5736 return resultobj;
5737 fail:
5738 return NULL;
5739 }
5740
5741
5742 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5743 PyObject *resultobj = NULL;
5744 int *arg1 = (int *) 0 ;
5745 int *arg2 = (int *) 0 ;
5746 int temp1 ;
5747 int res1 = 0 ;
5748 int temp2 ;
5749 int res2 = 0 ;
5750 char *kwnames[] = {
5751 NULL
5752 };
5753
5754 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5755 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5757 {
5758 if (!wxPyCheckForApp()) SWIG_fail;
5759 PyThreadState* __tstate = wxPyBeginAllowThreads();
5760 wxDisplaySizeMM(arg1,arg2);
5761
5762 wxPyEndAllowThreads(__tstate);
5763 if (PyErr_Occurred()) SWIG_fail;
5764 }
5765 Py_INCREF(Py_None); resultobj = Py_None;
5766 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5767 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5768 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5769 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5770 return resultobj;
5771 fail:
5772 return NULL;
5773 }
5774
5775
5776 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5777 PyObject *resultobj = NULL;
5778 wxSize result;
5779 char *kwnames[] = {
5780 NULL
5781 };
5782
5783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5784 {
5785 if (!wxPyCheckForApp()) SWIG_fail;
5786 PyThreadState* __tstate = wxPyBeginAllowThreads();
5787 result = wxGetDisplaySizeMM();
5788
5789 wxPyEndAllowThreads(__tstate);
5790 if (PyErr_Occurred()) SWIG_fail;
5791 }
5792 {
5793 wxSize * resultptr;
5794 resultptr = new wxSize(static_cast<wxSize & >(result));
5795 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5796 }
5797 return resultobj;
5798 fail:
5799 return NULL;
5800 }
5801
5802
5803 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5804 PyObject *resultobj = NULL;
5805 int *arg1 = (int *) 0 ;
5806 int *arg2 = (int *) 0 ;
5807 int *arg3 = (int *) 0 ;
5808 int *arg4 = (int *) 0 ;
5809 int temp1 ;
5810 int res1 = 0 ;
5811 int temp2 ;
5812 int res2 = 0 ;
5813 int temp3 ;
5814 int res3 = 0 ;
5815 int temp4 ;
5816 int res4 = 0 ;
5817 char *kwnames[] = {
5818 NULL
5819 };
5820
5821 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5822 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5823 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5824 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5826 {
5827 if (!wxPyCheckForApp()) SWIG_fail;
5828 PyThreadState* __tstate = wxPyBeginAllowThreads();
5829 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5830
5831 wxPyEndAllowThreads(__tstate);
5832 if (PyErr_Occurred()) SWIG_fail;
5833 }
5834 Py_INCREF(Py_None); resultobj = Py_None;
5835 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5836 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5837 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5838 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5839 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5840 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5841 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5842 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5843 return resultobj;
5844 fail:
5845 return NULL;
5846 }
5847
5848
5849 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5850 PyObject *resultobj = NULL;
5851 wxRect result;
5852 char *kwnames[] = {
5853 NULL
5854 };
5855
5856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5857 {
5858 if (!wxPyCheckForApp()) SWIG_fail;
5859 PyThreadState* __tstate = wxPyBeginAllowThreads();
5860 result = wxGetClientDisplayRect();
5861
5862 wxPyEndAllowThreads(__tstate);
5863 if (PyErr_Occurred()) SWIG_fail;
5864 }
5865 {
5866 wxRect * resultptr;
5867 resultptr = new wxRect(static_cast<wxRect & >(result));
5868 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5869 }
5870 return resultobj;
5871 fail:
5872 return NULL;
5873 }
5874
5875
5876 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5877 PyObject *resultobj = NULL;
5878 wxCursor *arg1 = 0 ;
5879 PyObject * obj0 = 0 ;
5880 char *kwnames[] = {
5881 (char *) "cursor", NULL
5882 };
5883
5884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5885 {
5886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5887 if (SWIG_arg_fail(1)) SWIG_fail;
5888 if (arg1 == NULL) {
5889 SWIG_null_ref("wxCursor");
5890 }
5891 if (SWIG_arg_fail(1)) SWIG_fail;
5892 }
5893 {
5894 if (!wxPyCheckForApp()) SWIG_fail;
5895 PyThreadState* __tstate = wxPyBeginAllowThreads();
5896 wxSetCursor(*arg1);
5897
5898 wxPyEndAllowThreads(__tstate);
5899 if (PyErr_Occurred()) SWIG_fail;
5900 }
5901 Py_INCREF(Py_None); resultobj = Py_None;
5902 return resultobj;
5903 fail:
5904 return NULL;
5905 }
5906
5907
5908 static PyObject *_wrap_GetXDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5909 PyObject *resultobj = NULL;
5910 void *result;
5911 char *kwnames[] = {
5912 NULL
5913 };
5914
5915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetXDisplay",kwnames)) goto fail;
5916 {
5917 if (!wxPyCheckForApp()) SWIG_fail;
5918 PyThreadState* __tstate = wxPyBeginAllowThreads();
5919 result = (void *)wxGetXDisplay();
5920
5921 wxPyEndAllowThreads(__tstate);
5922 if (PyErr_Occurred()) SWIG_fail;
5923 }
5924 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
5925 return resultobj;
5926 fail:
5927 return NULL;
5928 }
5929
5930
5931 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5932 PyObject *resultobj = NULL;
5933 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5934 PyObject * obj0 = 0 ;
5935 char *kwnames[] = {
5936 (char *) "cursor", NULL
5937 };
5938
5939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5940 if (obj0) {
5941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5942 if (SWIG_arg_fail(1)) SWIG_fail;
5943 }
5944 {
5945 if (!wxPyCheckForApp()) SWIG_fail;
5946 PyThreadState* __tstate = wxPyBeginAllowThreads();
5947 wxBeginBusyCursor(arg1);
5948
5949 wxPyEndAllowThreads(__tstate);
5950 if (PyErr_Occurred()) SWIG_fail;
5951 }
5952 Py_INCREF(Py_None); resultobj = Py_None;
5953 return resultobj;
5954 fail:
5955 return NULL;
5956 }
5957
5958
5959 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
5960 PyObject *resultobj = NULL;
5961 wxPoint result;
5962 char *kwnames[] = {
5963 NULL
5964 };
5965
5966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
5967 {
5968 if (!wxPyCheckForApp()) SWIG_fail;
5969 PyThreadState* __tstate = wxPyBeginAllowThreads();
5970 result = wxGetMousePosition();
5971
5972 wxPyEndAllowThreads(__tstate);
5973 if (PyErr_Occurred()) SWIG_fail;
5974 }
5975 {
5976 wxPoint * resultptr;
5977 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5978 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5979 }
5980 return resultobj;
5981 fail:
5982 return NULL;
5983 }
5984
5985
5986 static PyObject *_wrap_FindWindowAtPointer(PyObject *, PyObject *args, PyObject *kwargs) {
5987 PyObject *resultobj = NULL;
5988 wxWindow *result;
5989 char *kwnames[] = {
5990 NULL
5991 };
5992
5993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FindWindowAtPointer",kwnames)) goto fail;
5994 {
5995 if (!wxPyCheckForApp()) SWIG_fail;
5996 PyThreadState* __tstate = wxPyBeginAllowThreads();
5997 result = (wxWindow *)FindWindowAtPointer();
5998
5999 wxPyEndAllowThreads(__tstate);
6000 if (PyErr_Occurred()) SWIG_fail;
6001 }
6002 {
6003 resultobj = wxPyMake_wxObject(result, 0);
6004 }
6005 return resultobj;
6006 fail:
6007 return NULL;
6008 }
6009
6010
6011 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6012 PyObject *resultobj = NULL;
6013 wxWindow *result;
6014 char *kwnames[] = {
6015 NULL
6016 };
6017
6018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
6019 {
6020 if (!wxPyCheckForApp()) SWIG_fail;
6021 PyThreadState* __tstate = wxPyBeginAllowThreads();
6022 result = (wxWindow *)wxGetActiveWindow();
6023
6024 wxPyEndAllowThreads(__tstate);
6025 if (PyErr_Occurred()) SWIG_fail;
6026 }
6027 {
6028 resultobj = wxPyMake_wxObject(result, 0);
6029 }
6030 return resultobj;
6031 fail:
6032 return NULL;
6033 }
6034
6035
6036 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6037 PyObject *resultobj = NULL;
6038 wxPoint *arg1 = 0 ;
6039 wxWindow *result;
6040 wxPoint temp1 ;
6041 PyObject * obj0 = 0 ;
6042 char *kwnames[] = {
6043 (char *) "pt", NULL
6044 };
6045
6046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
6047 {
6048 arg1 = &temp1;
6049 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6050 }
6051 {
6052 if (!wxPyCheckForApp()) SWIG_fail;
6053 PyThreadState* __tstate = wxPyBeginAllowThreads();
6054 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6055
6056 wxPyEndAllowThreads(__tstate);
6057 if (PyErr_Occurred()) SWIG_fail;
6058 }
6059 {
6060 resultobj = wxPyMake_wxObject(result, 0);
6061 }
6062 return resultobj;
6063 fail:
6064 return NULL;
6065 }
6066
6067
6068 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6069 PyObject *resultobj = NULL;
6070 wxPoint *arg1 = 0 ;
6071 wxWindow *result;
6072 wxPoint temp1 ;
6073 PyObject * obj0 = 0 ;
6074 char *kwnames[] = {
6075 (char *) "pt", NULL
6076 };
6077
6078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
6079 {
6080 arg1 = &temp1;
6081 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6082 }
6083 {
6084 if (!wxPyCheckForApp()) SWIG_fail;
6085 PyThreadState* __tstate = wxPyBeginAllowThreads();
6086 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6087
6088 wxPyEndAllowThreads(__tstate);
6089 if (PyErr_Occurred()) SWIG_fail;
6090 }
6091 {
6092 resultobj = wxPyMake_wxObject(result, 0);
6093 }
6094 return resultobj;
6095 fail:
6096 return NULL;
6097 }
6098
6099
6100 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
6101 PyObject *resultobj = NULL;
6102 wxWindow *arg1 = (wxWindow *) 0 ;
6103 wxWindow *result;
6104 PyObject * obj0 = 0 ;
6105 char *kwnames[] = {
6106 (char *) "win", NULL
6107 };
6108
6109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
6110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6111 if (SWIG_arg_fail(1)) SWIG_fail;
6112 {
6113 if (!wxPyCheckForApp()) SWIG_fail;
6114 PyThreadState* __tstate = wxPyBeginAllowThreads();
6115 result = (wxWindow *)wxGetTopLevelParent(arg1);
6116
6117 wxPyEndAllowThreads(__tstate);
6118 if (PyErr_Occurred()) SWIG_fail;
6119 }
6120 {
6121 resultobj = wxPyMake_wxObject(result, 0);
6122 }
6123 return resultobj;
6124 fail:
6125 return NULL;
6126 }
6127
6128
6129 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6130 PyObject *resultobj = NULL;
6131 wxString *arg1 = 0 ;
6132 bool result;
6133 bool temp1 = false ;
6134 PyObject * obj0 = 0 ;
6135 char *kwnames[] = {
6136 (char *) "url", NULL
6137 };
6138
6139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6140 {
6141 arg1 = wxString_in_helper(obj0);
6142 if (arg1 == NULL) SWIG_fail;
6143 temp1 = true;
6144 }
6145 {
6146 PyThreadState* __tstate = wxPyBeginAllowThreads();
6147 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6148
6149 wxPyEndAllowThreads(__tstate);
6150 if (PyErr_Occurred()) SWIG_fail;
6151 }
6152 {
6153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6154 }
6155 {
6156 if (temp1)
6157 delete arg1;
6158 }
6159 return resultobj;
6160 fail:
6161 {
6162 if (temp1)
6163 delete arg1;
6164 }
6165 return NULL;
6166 }
6167
6168
6169 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6170 PyObject *resultobj = NULL;
6171 wxKeyCode arg1 ;
6172 bool result;
6173 PyObject * obj0 = 0 ;
6174 char *kwnames[] = {
6175 (char *) "key", NULL
6176 };
6177
6178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6179 {
6180 arg1 = static_cast<wxKeyCode >(SWIG_As_int(obj0));
6181 if (SWIG_arg_fail(1)) SWIG_fail;
6182 }
6183 {
6184 if (!wxPyCheckForApp()) SWIG_fail;
6185 PyThreadState* __tstate = wxPyBeginAllowThreads();
6186 result = (bool)wxGetKeyState(arg1);
6187
6188 wxPyEndAllowThreads(__tstate);
6189 if (PyErr_Occurred()) SWIG_fail;
6190 }
6191 {
6192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6193 }
6194 return resultobj;
6195 fail:
6196 return NULL;
6197 }
6198
6199
6200 static PyObject *_wrap_new_MouseState(PyObject *, PyObject *args, PyObject *kwargs) {
6201 PyObject *resultobj = NULL;
6202 wxMouseState *result;
6203 char *kwnames[] = {
6204 NULL
6205 };
6206
6207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MouseState",kwnames)) goto fail;
6208 {
6209 PyThreadState* __tstate = wxPyBeginAllowThreads();
6210 result = (wxMouseState *)new wxMouseState();
6211
6212 wxPyEndAllowThreads(__tstate);
6213 if (PyErr_Occurred()) SWIG_fail;
6214 }
6215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseState, 1);
6216 return resultobj;
6217 fail:
6218 return NULL;
6219 }
6220
6221
6222 static PyObject *_wrap_delete_MouseState(PyObject *, PyObject *args, PyObject *kwargs) {
6223 PyObject *resultobj = NULL;
6224 wxMouseState *arg1 = (wxMouseState *) 0 ;
6225 PyObject * obj0 = 0 ;
6226 char *kwnames[] = {
6227 (char *) "self", NULL
6228 };
6229
6230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MouseState",kwnames,&obj0)) goto fail;
6231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6232 if (SWIG_arg_fail(1)) SWIG_fail;
6233 {
6234 PyThreadState* __tstate = wxPyBeginAllowThreads();
6235 delete arg1;
6236
6237 wxPyEndAllowThreads(__tstate);
6238 if (PyErr_Occurred()) SWIG_fail;
6239 }
6240 Py_INCREF(Py_None); resultobj = Py_None;
6241 return resultobj;
6242 fail:
6243 return NULL;
6244 }
6245
6246
6247 static PyObject *_wrap_MouseState_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
6248 PyObject *resultobj = NULL;
6249 wxMouseState *arg1 = (wxMouseState *) 0 ;
6250 int result;
6251 PyObject * obj0 = 0 ;
6252 char *kwnames[] = {
6253 (char *) "self", NULL
6254 };
6255
6256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_GetX",kwnames,&obj0)) goto fail;
6257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6258 if (SWIG_arg_fail(1)) SWIG_fail;
6259 {
6260 PyThreadState* __tstate = wxPyBeginAllowThreads();
6261 result = (int)(arg1)->GetX();
6262
6263 wxPyEndAllowThreads(__tstate);
6264 if (PyErr_Occurred()) SWIG_fail;
6265 }
6266 {
6267 resultobj = SWIG_From_int(static_cast<int >(result));
6268 }
6269 return resultobj;
6270 fail:
6271 return NULL;
6272 }
6273
6274
6275 static PyObject *_wrap_MouseState_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
6276 PyObject *resultobj = NULL;
6277 wxMouseState *arg1 = (wxMouseState *) 0 ;
6278 int result;
6279 PyObject * obj0 = 0 ;
6280 char *kwnames[] = {
6281 (char *) "self", NULL
6282 };
6283
6284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_GetY",kwnames,&obj0)) goto fail;
6285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6286 if (SWIG_arg_fail(1)) SWIG_fail;
6287 {
6288 PyThreadState* __tstate = wxPyBeginAllowThreads();
6289 result = (int)(arg1)->GetY();
6290
6291 wxPyEndAllowThreads(__tstate);
6292 if (PyErr_Occurred()) SWIG_fail;
6293 }
6294 {
6295 resultobj = SWIG_From_int(static_cast<int >(result));
6296 }
6297 return resultobj;
6298 fail:
6299 return NULL;
6300 }
6301
6302
6303 static PyObject *_wrap_MouseState_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
6304 PyObject *resultobj = NULL;
6305 wxMouseState *arg1 = (wxMouseState *) 0 ;
6306 bool result;
6307 PyObject * obj0 = 0 ;
6308 char *kwnames[] = {
6309 (char *) "self", NULL
6310 };
6311
6312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_LeftDown",kwnames,&obj0)) goto fail;
6313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6314 if (SWIG_arg_fail(1)) SWIG_fail;
6315 {
6316 PyThreadState* __tstate = wxPyBeginAllowThreads();
6317 result = (bool)(arg1)->LeftDown();
6318
6319 wxPyEndAllowThreads(__tstate);
6320 if (PyErr_Occurred()) SWIG_fail;
6321 }
6322 {
6323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6324 }
6325 return resultobj;
6326 fail:
6327 return NULL;
6328 }
6329
6330
6331 static PyObject *_wrap_MouseState_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
6332 PyObject *resultobj = NULL;
6333 wxMouseState *arg1 = (wxMouseState *) 0 ;
6334 bool result;
6335 PyObject * obj0 = 0 ;
6336 char *kwnames[] = {
6337 (char *) "self", NULL
6338 };
6339
6340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_MiddleDown",kwnames,&obj0)) goto fail;
6341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6342 if (SWIG_arg_fail(1)) SWIG_fail;
6343 {
6344 PyThreadState* __tstate = wxPyBeginAllowThreads();
6345 result = (bool)(arg1)->MiddleDown();
6346
6347 wxPyEndAllowThreads(__tstate);
6348 if (PyErr_Occurred()) SWIG_fail;
6349 }
6350 {
6351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6352 }
6353 return resultobj;
6354 fail:
6355 return NULL;
6356 }
6357
6358
6359 static PyObject *_wrap_MouseState_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
6360 PyObject *resultobj = NULL;
6361 wxMouseState *arg1 = (wxMouseState *) 0 ;
6362 bool result;
6363 PyObject * obj0 = 0 ;
6364 char *kwnames[] = {
6365 (char *) "self", NULL
6366 };
6367
6368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_RightDown",kwnames,&obj0)) goto fail;
6369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6370 if (SWIG_arg_fail(1)) SWIG_fail;
6371 {
6372 PyThreadState* __tstate = wxPyBeginAllowThreads();
6373 result = (bool)(arg1)->RightDown();
6374
6375 wxPyEndAllowThreads(__tstate);
6376 if (PyErr_Occurred()) SWIG_fail;
6377 }
6378 {
6379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6380 }
6381 return resultobj;
6382 fail:
6383 return NULL;
6384 }
6385
6386
6387 static PyObject *_wrap_MouseState_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
6388 PyObject *resultobj = NULL;
6389 wxMouseState *arg1 = (wxMouseState *) 0 ;
6390 bool result;
6391 PyObject * obj0 = 0 ;
6392 char *kwnames[] = {
6393 (char *) "self", NULL
6394 };
6395
6396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_ControlDown",kwnames,&obj0)) goto fail;
6397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6398 if (SWIG_arg_fail(1)) SWIG_fail;
6399 {
6400 PyThreadState* __tstate = wxPyBeginAllowThreads();
6401 result = (bool)(arg1)->ControlDown();
6402
6403 wxPyEndAllowThreads(__tstate);
6404 if (PyErr_Occurred()) SWIG_fail;
6405 }
6406 {
6407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6408 }
6409 return resultobj;
6410 fail:
6411 return NULL;
6412 }
6413
6414
6415 static PyObject *_wrap_MouseState_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
6416 PyObject *resultobj = NULL;
6417 wxMouseState *arg1 = (wxMouseState *) 0 ;
6418 bool result;
6419 PyObject * obj0 = 0 ;
6420 char *kwnames[] = {
6421 (char *) "self", NULL
6422 };
6423
6424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_ShiftDown",kwnames,&obj0)) goto fail;
6425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6426 if (SWIG_arg_fail(1)) SWIG_fail;
6427 {
6428 PyThreadState* __tstate = wxPyBeginAllowThreads();
6429 result = (bool)(arg1)->ShiftDown();
6430
6431 wxPyEndAllowThreads(__tstate);
6432 if (PyErr_Occurred()) SWIG_fail;
6433 }
6434 {
6435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6436 }
6437 return resultobj;
6438 fail:
6439 return NULL;
6440 }
6441
6442
6443 static PyObject *_wrap_MouseState_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
6444 PyObject *resultobj = NULL;
6445 wxMouseState *arg1 = (wxMouseState *) 0 ;
6446 bool result;
6447 PyObject * obj0 = 0 ;
6448 char *kwnames[] = {
6449 (char *) "self", NULL
6450 };
6451
6452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_AltDown",kwnames,&obj0)) goto fail;
6453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6454 if (SWIG_arg_fail(1)) SWIG_fail;
6455 {
6456 PyThreadState* __tstate = wxPyBeginAllowThreads();
6457 result = (bool)(arg1)->AltDown();
6458
6459 wxPyEndAllowThreads(__tstate);
6460 if (PyErr_Occurred()) SWIG_fail;
6461 }
6462 {
6463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6464 }
6465 return resultobj;
6466 fail:
6467 return NULL;
6468 }
6469
6470
6471 static PyObject *_wrap_MouseState_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
6472 PyObject *resultobj = NULL;
6473 wxMouseState *arg1 = (wxMouseState *) 0 ;
6474 bool result;
6475 PyObject * obj0 = 0 ;
6476 char *kwnames[] = {
6477 (char *) "self", NULL
6478 };
6479
6480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_MetaDown",kwnames,&obj0)) goto fail;
6481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6482 if (SWIG_arg_fail(1)) SWIG_fail;
6483 {
6484 PyThreadState* __tstate = wxPyBeginAllowThreads();
6485 result = (bool)(arg1)->MetaDown();
6486
6487 wxPyEndAllowThreads(__tstate);
6488 if (PyErr_Occurred()) SWIG_fail;
6489 }
6490 {
6491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6492 }
6493 return resultobj;
6494 fail:
6495 return NULL;
6496 }
6497
6498
6499 static PyObject *_wrap_MouseState_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
6500 PyObject *resultobj = NULL;
6501 wxMouseState *arg1 = (wxMouseState *) 0 ;
6502 bool result;
6503 PyObject * obj0 = 0 ;
6504 char *kwnames[] = {
6505 (char *) "self", NULL
6506 };
6507
6508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_CmdDown",kwnames,&obj0)) goto fail;
6509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6510 if (SWIG_arg_fail(1)) SWIG_fail;
6511 {
6512 PyThreadState* __tstate = wxPyBeginAllowThreads();
6513 result = (bool)(arg1)->CmdDown();
6514
6515 wxPyEndAllowThreads(__tstate);
6516 if (PyErr_Occurred()) SWIG_fail;
6517 }
6518 {
6519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6520 }
6521 return resultobj;
6522 fail:
6523 return NULL;
6524 }
6525
6526
6527 static PyObject *_wrap_MouseState_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
6528 PyObject *resultobj = NULL;
6529 wxMouseState *arg1 = (wxMouseState *) 0 ;
6530 int arg2 ;
6531 PyObject * obj0 = 0 ;
6532 PyObject * obj1 = 0 ;
6533 char *kwnames[] = {
6534 (char *) "self",(char *) "x", NULL
6535 };
6536
6537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) goto fail;
6538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6539 if (SWIG_arg_fail(1)) SWIG_fail;
6540 {
6541 arg2 = static_cast<int >(SWIG_As_int(obj1));
6542 if (SWIG_arg_fail(2)) SWIG_fail;
6543 }
6544 {
6545 PyThreadState* __tstate = wxPyBeginAllowThreads();
6546 (arg1)->SetX(arg2);
6547
6548 wxPyEndAllowThreads(__tstate);
6549 if (PyErr_Occurred()) SWIG_fail;
6550 }
6551 Py_INCREF(Py_None); resultobj = Py_None;
6552 return resultobj;
6553 fail:
6554 return NULL;
6555 }
6556
6557
6558 static PyObject *_wrap_MouseState_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
6559 PyObject *resultobj = NULL;
6560 wxMouseState *arg1 = (wxMouseState *) 0 ;
6561 int arg2 ;
6562 PyObject * obj0 = 0 ;
6563 PyObject * obj1 = 0 ;
6564 char *kwnames[] = {
6565 (char *) "self",(char *) "y", NULL
6566 };
6567
6568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) goto fail;
6569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6570 if (SWIG_arg_fail(1)) SWIG_fail;
6571 {
6572 arg2 = static_cast<int >(SWIG_As_int(obj1));
6573 if (SWIG_arg_fail(2)) SWIG_fail;
6574 }
6575 {
6576 PyThreadState* __tstate = wxPyBeginAllowThreads();
6577 (arg1)->SetY(arg2);
6578
6579 wxPyEndAllowThreads(__tstate);
6580 if (PyErr_Occurred()) SWIG_fail;
6581 }
6582 Py_INCREF(Py_None); resultobj = Py_None;
6583 return resultobj;
6584 fail:
6585 return NULL;
6586 }
6587
6588
6589 static PyObject *_wrap_MouseState_SetLeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
6590 PyObject *resultobj = NULL;
6591 wxMouseState *arg1 = (wxMouseState *) 0 ;
6592 bool arg2 ;
6593 PyObject * obj0 = 0 ;
6594 PyObject * obj1 = 0 ;
6595 char *kwnames[] = {
6596 (char *) "self",(char *) "down", NULL
6597 };
6598
6599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) goto fail;
6600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6601 if (SWIG_arg_fail(1)) SWIG_fail;
6602 {
6603 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6604 if (SWIG_arg_fail(2)) SWIG_fail;
6605 }
6606 {
6607 PyThreadState* __tstate = wxPyBeginAllowThreads();
6608 (arg1)->SetLeftDown(arg2);
6609
6610 wxPyEndAllowThreads(__tstate);
6611 if (PyErr_Occurred()) SWIG_fail;
6612 }
6613 Py_INCREF(Py_None); resultobj = Py_None;
6614 return resultobj;
6615 fail:
6616 return NULL;
6617 }
6618
6619
6620 static PyObject *_wrap_MouseState_SetMiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
6621 PyObject *resultobj = NULL;
6622 wxMouseState *arg1 = (wxMouseState *) 0 ;
6623 bool arg2 ;
6624 PyObject * obj0 = 0 ;
6625 PyObject * obj1 = 0 ;
6626 char *kwnames[] = {
6627 (char *) "self",(char *) "down", NULL
6628 };
6629
6630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) goto fail;
6631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6632 if (SWIG_arg_fail(1)) SWIG_fail;
6633 {
6634 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6635 if (SWIG_arg_fail(2)) SWIG_fail;
6636 }
6637 {
6638 PyThreadState* __tstate = wxPyBeginAllowThreads();
6639 (arg1)->SetMiddleDown(arg2);
6640
6641 wxPyEndAllowThreads(__tstate);
6642 if (PyErr_Occurred()) SWIG_fail;
6643 }
6644 Py_INCREF(Py_None); resultobj = Py_None;
6645 return resultobj;
6646 fail:
6647 return NULL;
6648 }
6649
6650
6651 static PyObject *_wrap_MouseState_SetRightDown(PyObject *, PyObject *args, PyObject *kwargs) {
6652 PyObject *resultobj = NULL;
6653 wxMouseState *arg1 = (wxMouseState *) 0 ;
6654 bool arg2 ;
6655 PyObject * obj0 = 0 ;
6656 PyObject * obj1 = 0 ;
6657 char *kwnames[] = {
6658 (char *) "self",(char *) "down", NULL
6659 };
6660
6661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) goto fail;
6662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6663 if (SWIG_arg_fail(1)) SWIG_fail;
6664 {
6665 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6666 if (SWIG_arg_fail(2)) SWIG_fail;
6667 }
6668 {
6669 PyThreadState* __tstate = wxPyBeginAllowThreads();
6670 (arg1)->SetRightDown(arg2);
6671
6672 wxPyEndAllowThreads(__tstate);
6673 if (PyErr_Occurred()) SWIG_fail;
6674 }
6675 Py_INCREF(Py_None); resultobj = Py_None;
6676 return resultobj;
6677 fail:
6678 return NULL;
6679 }
6680
6681
6682 static PyObject *_wrap_MouseState_SetControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
6683 PyObject *resultobj = NULL;
6684 wxMouseState *arg1 = (wxMouseState *) 0 ;
6685 bool arg2 ;
6686 PyObject * obj0 = 0 ;
6687 PyObject * obj1 = 0 ;
6688 char *kwnames[] = {
6689 (char *) "self",(char *) "down", NULL
6690 };
6691
6692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) goto fail;
6693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6694 if (SWIG_arg_fail(1)) SWIG_fail;
6695 {
6696 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6697 if (SWIG_arg_fail(2)) SWIG_fail;
6698 }
6699 {
6700 PyThreadState* __tstate = wxPyBeginAllowThreads();
6701 (arg1)->SetControlDown(arg2);
6702
6703 wxPyEndAllowThreads(__tstate);
6704 if (PyErr_Occurred()) SWIG_fail;
6705 }
6706 Py_INCREF(Py_None); resultobj = Py_None;
6707 return resultobj;
6708 fail:
6709 return NULL;
6710 }
6711
6712
6713 static PyObject *_wrap_MouseState_SetShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
6714 PyObject *resultobj = NULL;
6715 wxMouseState *arg1 = (wxMouseState *) 0 ;
6716 bool arg2 ;
6717 PyObject * obj0 = 0 ;
6718 PyObject * obj1 = 0 ;
6719 char *kwnames[] = {
6720 (char *) "self",(char *) "down", NULL
6721 };
6722
6723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) goto fail;
6724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6725 if (SWIG_arg_fail(1)) SWIG_fail;
6726 {
6727 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6728 if (SWIG_arg_fail(2)) SWIG_fail;
6729 }
6730 {
6731 PyThreadState* __tstate = wxPyBeginAllowThreads();
6732 (arg1)->SetShiftDown(arg2);
6733
6734 wxPyEndAllowThreads(__tstate);
6735 if (PyErr_Occurred()) SWIG_fail;
6736 }
6737 Py_INCREF(Py_None); resultobj = Py_None;
6738 return resultobj;
6739 fail:
6740 return NULL;
6741 }
6742
6743
6744 static PyObject *_wrap_MouseState_SetAltDown(PyObject *, PyObject *args, PyObject *kwargs) {
6745 PyObject *resultobj = NULL;
6746 wxMouseState *arg1 = (wxMouseState *) 0 ;
6747 bool arg2 ;
6748 PyObject * obj0 = 0 ;
6749 PyObject * obj1 = 0 ;
6750 char *kwnames[] = {
6751 (char *) "self",(char *) "down", NULL
6752 };
6753
6754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) goto fail;
6755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6756 if (SWIG_arg_fail(1)) SWIG_fail;
6757 {
6758 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6759 if (SWIG_arg_fail(2)) SWIG_fail;
6760 }
6761 {
6762 PyThreadState* __tstate = wxPyBeginAllowThreads();
6763 (arg1)->SetAltDown(arg2);
6764
6765 wxPyEndAllowThreads(__tstate);
6766 if (PyErr_Occurred()) SWIG_fail;
6767 }
6768 Py_INCREF(Py_None); resultobj = Py_None;
6769 return resultobj;
6770 fail:
6771 return NULL;
6772 }
6773
6774
6775 static PyObject *_wrap_MouseState_SetMetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
6776 PyObject *resultobj = NULL;
6777 wxMouseState *arg1 = (wxMouseState *) 0 ;
6778 bool arg2 ;
6779 PyObject * obj0 = 0 ;
6780 PyObject * obj1 = 0 ;
6781 char *kwnames[] = {
6782 (char *) "self",(char *) "down", NULL
6783 };
6784
6785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) goto fail;
6786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6787 if (SWIG_arg_fail(1)) SWIG_fail;
6788 {
6789 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6790 if (SWIG_arg_fail(2)) SWIG_fail;
6791 }
6792 {
6793 PyThreadState* __tstate = wxPyBeginAllowThreads();
6794 (arg1)->SetMetaDown(arg2);
6795
6796 wxPyEndAllowThreads(__tstate);
6797 if (PyErr_Occurred()) SWIG_fail;
6798 }
6799 Py_INCREF(Py_None); resultobj = Py_None;
6800 return resultobj;
6801 fail:
6802 return NULL;
6803 }
6804
6805
6806 static PyObject * MouseState_swigregister(PyObject *, PyObject *args) {
6807 PyObject *obj;
6808 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6809 SWIG_TypeClientData(SWIGTYPE_p_wxMouseState, obj);
6810 Py_INCREF(obj);
6811 return Py_BuildValue((char *)"");
6812 }
6813 static PyObject *_wrap_GetMouseState(PyObject *, PyObject *args, PyObject *kwargs) {
6814 PyObject *resultobj = NULL;
6815 wxMouseState result;
6816 char *kwnames[] = {
6817 NULL
6818 };
6819
6820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMouseState",kwnames)) goto fail;
6821 {
6822 PyThreadState* __tstate = wxPyBeginAllowThreads();
6823 result = wxGetMouseState();
6824
6825 wxPyEndAllowThreads(__tstate);
6826 if (PyErr_Occurred()) SWIG_fail;
6827 }
6828 {
6829 wxMouseState * resultptr;
6830 resultptr = new wxMouseState(static_cast<wxMouseState & >(result));
6831 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMouseState, 1);
6832 }
6833 return resultobj;
6834 fail:
6835 return NULL;
6836 }
6837
6838
6839 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6840 PyObject *resultobj = NULL;
6841 char *kwnames[] = {
6842 NULL
6843 };
6844
6845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6846 {
6847 if (!wxPyCheckForApp()) SWIG_fail;
6848 PyThreadState* __tstate = wxPyBeginAllowThreads();
6849 wxWakeUpMainThread();
6850
6851 wxPyEndAllowThreads(__tstate);
6852 if (PyErr_Occurred()) SWIG_fail;
6853 }
6854 Py_INCREF(Py_None); resultobj = Py_None;
6855 return resultobj;
6856 fail:
6857 return NULL;
6858 }
6859
6860
6861 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6862 PyObject *resultobj = NULL;
6863 char *kwnames[] = {
6864 NULL
6865 };
6866
6867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6868 {
6869 if (!wxPyCheckForApp()) SWIG_fail;
6870 PyThreadState* __tstate = wxPyBeginAllowThreads();
6871 wxMutexGuiEnter();
6872
6873 wxPyEndAllowThreads(__tstate);
6874 if (PyErr_Occurred()) SWIG_fail;
6875 }
6876 Py_INCREF(Py_None); resultobj = Py_None;
6877 return resultobj;
6878 fail:
6879 return NULL;
6880 }
6881
6882
6883 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6884 PyObject *resultobj = NULL;
6885 char *kwnames[] = {
6886 NULL
6887 };
6888
6889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6890 {
6891 if (!wxPyCheckForApp()) SWIG_fail;
6892 PyThreadState* __tstate = wxPyBeginAllowThreads();
6893 wxMutexGuiLeave();
6894
6895 wxPyEndAllowThreads(__tstate);
6896 if (PyErr_Occurred()) SWIG_fail;
6897 }
6898 Py_INCREF(Py_None); resultobj = Py_None;
6899 return resultobj;
6900 fail:
6901 return NULL;
6902 }
6903
6904
6905 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6906 PyObject *resultobj = NULL;
6907 wxMutexGuiLocker *result;
6908 char *kwnames[] = {
6909 NULL
6910 };
6911
6912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6913 {
6914 if (!wxPyCheckForApp()) SWIG_fail;
6915 PyThreadState* __tstate = wxPyBeginAllowThreads();
6916 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6917
6918 wxPyEndAllowThreads(__tstate);
6919 if (PyErr_Occurred()) SWIG_fail;
6920 }
6921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6922 return resultobj;
6923 fail:
6924 return NULL;
6925 }
6926
6927
6928 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6929 PyObject *resultobj = NULL;
6930 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6931 PyObject * obj0 = 0 ;
6932 char *kwnames[] = {
6933 (char *) "self", NULL
6934 };
6935
6936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6938 if (SWIG_arg_fail(1)) SWIG_fail;
6939 {
6940 PyThreadState* __tstate = wxPyBeginAllowThreads();
6941 delete arg1;
6942
6943 wxPyEndAllowThreads(__tstate);
6944 if (PyErr_Occurred()) SWIG_fail;
6945 }
6946 Py_INCREF(Py_None); resultobj = Py_None;
6947 return resultobj;
6948 fail:
6949 return NULL;
6950 }
6951
6952
6953 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6954 PyObject *obj;
6955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6956 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6957 Py_INCREF(obj);
6958 return Py_BuildValue((char *)"");
6959 }
6960 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6961 PyObject *resultobj = NULL;
6962 bool result;
6963 char *kwnames[] = {
6964 NULL
6965 };
6966
6967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6968 {
6969 PyThreadState* __tstate = wxPyBeginAllowThreads();
6970 result = (bool)wxThread_IsMain();
6971
6972 wxPyEndAllowThreads(__tstate);
6973 if (PyErr_Occurred()) SWIG_fail;
6974 }
6975 {
6976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6977 }
6978 return resultobj;
6979 fail:
6980 return NULL;
6981 }
6982
6983
6984 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6985 PyObject *resultobj = NULL;
6986 wxString *arg1 = 0 ;
6987 wxToolTip *result;
6988 bool temp1 = false ;
6989 PyObject * obj0 = 0 ;
6990 char *kwnames[] = {
6991 (char *) "tip", NULL
6992 };
6993
6994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6995 {
6996 arg1 = wxString_in_helper(obj0);
6997 if (arg1 == NULL) SWIG_fail;
6998 temp1 = true;
6999 }
7000 {
7001 if (!wxPyCheckForApp()) SWIG_fail;
7002 PyThreadState* __tstate = wxPyBeginAllowThreads();
7003 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7004
7005 wxPyEndAllowThreads(__tstate);
7006 if (PyErr_Occurred()) SWIG_fail;
7007 }
7008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxToolTip, 1);
7009 {
7010 if (temp1)
7011 delete arg1;
7012 }
7013 return resultobj;
7014 fail:
7015 {
7016 if (temp1)
7017 delete arg1;
7018 }
7019 return NULL;
7020 }
7021
7022
7023 static PyObject *_wrap_delete_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
7024 PyObject *resultobj = NULL;
7025 wxToolTip *arg1 = (wxToolTip *) 0 ;
7026 PyObject * obj0 = 0 ;
7027 char *kwnames[] = {
7028 (char *) "self", NULL
7029 };
7030
7031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ToolTip",kwnames,&obj0)) goto fail;
7032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
7033 if (SWIG_arg_fail(1)) SWIG_fail;
7034 {
7035 PyThreadState* __tstate = wxPyBeginAllowThreads();
7036 delete arg1;
7037
7038 wxPyEndAllowThreads(__tstate);
7039 if (PyErr_Occurred()) SWIG_fail;
7040 }
7041 Py_INCREF(Py_None); resultobj = Py_None;
7042 return resultobj;
7043 fail:
7044 return NULL;
7045 }
7046
7047
7048 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7049 PyObject *resultobj = NULL;
7050 wxToolTip *arg1 = (wxToolTip *) 0 ;
7051 wxString *arg2 = 0 ;
7052 bool temp2 = false ;
7053 PyObject * obj0 = 0 ;
7054 PyObject * obj1 = 0 ;
7055 char *kwnames[] = {
7056 (char *) "self",(char *) "tip", NULL
7057 };
7058
7059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
7060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
7061 if (SWIG_arg_fail(1)) SWIG_fail;
7062 {
7063 arg2 = wxString_in_helper(obj1);
7064 if (arg2 == NULL) SWIG_fail;
7065 temp2 = true;
7066 }
7067 {
7068 PyThreadState* __tstate = wxPyBeginAllowThreads();
7069 (arg1)->SetTip((wxString const &)*arg2);
7070
7071 wxPyEndAllowThreads(__tstate);
7072 if (PyErr_Occurred()) SWIG_fail;
7073 }
7074 Py_INCREF(Py_None); resultobj = Py_None;
7075 {
7076 if (temp2)
7077 delete arg2;
7078 }
7079 return resultobj;
7080 fail:
7081 {
7082 if (temp2)
7083 delete arg2;
7084 }
7085 return NULL;
7086 }
7087
7088
7089 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7090 PyObject *resultobj = NULL;
7091 wxToolTip *arg1 = (wxToolTip *) 0 ;
7092 wxString result;
7093 PyObject * obj0 = 0 ;
7094 char *kwnames[] = {
7095 (char *) "self", NULL
7096 };
7097
7098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
7099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
7100 if (SWIG_arg_fail(1)) SWIG_fail;
7101 {
7102 PyThreadState* __tstate = wxPyBeginAllowThreads();
7103 result = (arg1)->GetTip();
7104
7105 wxPyEndAllowThreads(__tstate);
7106 if (PyErr_Occurred()) SWIG_fail;
7107 }
7108 {
7109 #if wxUSE_UNICODE
7110 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7111 #else
7112 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7113 #endif
7114 }
7115 return resultobj;
7116 fail:
7117 return NULL;
7118 }
7119
7120
7121 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7122 PyObject *resultobj = NULL;
7123 wxToolTip *arg1 = (wxToolTip *) 0 ;
7124 wxWindow *result;
7125 PyObject * obj0 = 0 ;
7126 char *kwnames[] = {
7127 (char *) "self", NULL
7128 };
7129
7130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
7131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
7132 if (SWIG_arg_fail(1)) SWIG_fail;
7133 {
7134 PyThreadState* __tstate = wxPyBeginAllowThreads();
7135 result = (wxWindow *)(arg1)->GetWindow();
7136
7137 wxPyEndAllowThreads(__tstate);
7138 if (PyErr_Occurred()) SWIG_fail;
7139 }
7140 {
7141 resultobj = wxPyMake_wxObject(result, 0);
7142 }
7143 return resultobj;
7144 fail:
7145 return NULL;
7146 }
7147
7148
7149 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
7150 PyObject *resultobj = NULL;
7151 bool arg1 ;
7152 PyObject * obj0 = 0 ;
7153 char *kwnames[] = {
7154 (char *) "flag", NULL
7155 };
7156
7157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
7158 {
7159 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
7160 if (SWIG_arg_fail(1)) SWIG_fail;
7161 }
7162 {
7163 PyThreadState* __tstate = wxPyBeginAllowThreads();
7164 wxToolTip::Enable(arg1);
7165
7166 wxPyEndAllowThreads(__tstate);
7167 if (PyErr_Occurred()) SWIG_fail;
7168 }
7169 Py_INCREF(Py_None); resultobj = Py_None;
7170 return resultobj;
7171 fail:
7172 return NULL;
7173 }
7174
7175
7176 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
7177 PyObject *resultobj = NULL;
7178 long arg1 ;
7179 PyObject * obj0 = 0 ;
7180 char *kwnames[] = {
7181 (char *) "milliseconds", NULL
7182 };
7183
7184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
7185 {
7186 arg1 = static_cast<long >(SWIG_As_long(obj0));
7187 if (SWIG_arg_fail(1)) SWIG_fail;
7188 }
7189 {
7190 PyThreadState* __tstate = wxPyBeginAllowThreads();
7191 wxToolTip::SetDelay(arg1);
7192
7193 wxPyEndAllowThreads(__tstate);
7194 if (PyErr_Occurred()) SWIG_fail;
7195 }
7196 Py_INCREF(Py_None); resultobj = Py_None;
7197 return resultobj;
7198 fail:
7199 return NULL;
7200 }
7201
7202
7203 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
7204 PyObject *obj;
7205 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7206 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
7207 Py_INCREF(obj);
7208 return Py_BuildValue((char *)"");
7209 }
7210 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
7211 PyObject *resultobj = NULL;
7212 wxWindow *arg1 = (wxWindow *) 0 ;
7213 wxSize *arg2 = 0 ;
7214 wxCaret *result;
7215 wxSize temp2 ;
7216 PyObject * obj0 = 0 ;
7217 PyObject * obj1 = 0 ;
7218 char *kwnames[] = {
7219 (char *) "window",(char *) "size", NULL
7220 };
7221
7222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
7223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7224 if (SWIG_arg_fail(1)) SWIG_fail;
7225 {
7226 arg2 = &temp2;
7227 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
7228 }
7229 {
7230 if (!wxPyCheckForApp()) SWIG_fail;
7231 PyThreadState* __tstate = wxPyBeginAllowThreads();
7232 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
7233
7234 wxPyEndAllowThreads(__tstate);
7235 if (PyErr_Occurred()) SWIG_fail;
7236 }
7237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
7238 return resultobj;
7239 fail:
7240 return NULL;
7241 }
7242
7243
7244 static PyObject *_wrap_delete_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
7245 PyObject *resultobj = NULL;
7246 wxCaret *arg1 = (wxCaret *) 0 ;
7247 PyObject * obj0 = 0 ;
7248 char *kwnames[] = {
7249 (char *) "self", NULL
7250 };
7251
7252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Caret",kwnames,&obj0)) goto fail;
7253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7254 if (SWIG_arg_fail(1)) SWIG_fail;
7255 {
7256 PyThreadState* __tstate = wxPyBeginAllowThreads();
7257 delete arg1;
7258
7259 wxPyEndAllowThreads(__tstate);
7260 if (PyErr_Occurred()) SWIG_fail;
7261 }
7262 Py_INCREF(Py_None); resultobj = Py_None;
7263 return resultobj;
7264 fail:
7265 return NULL;
7266 }
7267
7268
7269 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
7270 PyObject *resultobj = NULL;
7271 wxCaret *arg1 = (wxCaret *) 0 ;
7272 PyObject * obj0 = 0 ;
7273 char *kwnames[] = {
7274 (char *) "self", NULL
7275 };
7276
7277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
7278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7279 if (SWIG_arg_fail(1)) SWIG_fail;
7280 {
7281 PyThreadState* __tstate = wxPyBeginAllowThreads();
7282 wxCaret_Destroy(arg1);
7283
7284 wxPyEndAllowThreads(__tstate);
7285 if (PyErr_Occurred()) SWIG_fail;
7286 }
7287 Py_INCREF(Py_None); resultobj = Py_None;
7288 return resultobj;
7289 fail:
7290 return NULL;
7291 }
7292
7293
7294 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
7295 PyObject *resultobj = NULL;
7296 wxCaret *arg1 = (wxCaret *) 0 ;
7297 bool result;
7298 PyObject * obj0 = 0 ;
7299 char *kwnames[] = {
7300 (char *) "self", NULL
7301 };
7302
7303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
7304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7305 if (SWIG_arg_fail(1)) SWIG_fail;
7306 {
7307 PyThreadState* __tstate = wxPyBeginAllowThreads();
7308 result = (bool)(arg1)->IsOk();
7309
7310 wxPyEndAllowThreads(__tstate);
7311 if (PyErr_Occurred()) SWIG_fail;
7312 }
7313 {
7314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7315 }
7316 return resultobj;
7317 fail:
7318 return NULL;
7319 }
7320
7321
7322 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
7323 PyObject *resultobj = NULL;
7324 wxCaret *arg1 = (wxCaret *) 0 ;
7325 bool result;
7326 PyObject * obj0 = 0 ;
7327 char *kwnames[] = {
7328 (char *) "self", NULL
7329 };
7330
7331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
7332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7333 if (SWIG_arg_fail(1)) SWIG_fail;
7334 {
7335 PyThreadState* __tstate = wxPyBeginAllowThreads();
7336 result = (bool)(arg1)->IsVisible();
7337
7338 wxPyEndAllowThreads(__tstate);
7339 if (PyErr_Occurred()) SWIG_fail;
7340 }
7341 {
7342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7343 }
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
7351 PyObject *resultobj = NULL;
7352 wxCaret *arg1 = (wxCaret *) 0 ;
7353 wxPoint result;
7354 PyObject * obj0 = 0 ;
7355 char *kwnames[] = {
7356 (char *) "self", NULL
7357 };
7358
7359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
7360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7361 if (SWIG_arg_fail(1)) SWIG_fail;
7362 {
7363 PyThreadState* __tstate = wxPyBeginAllowThreads();
7364 result = (arg1)->GetPosition();
7365
7366 wxPyEndAllowThreads(__tstate);
7367 if (PyErr_Occurred()) SWIG_fail;
7368 }
7369 {
7370 wxPoint * resultptr;
7371 resultptr = new wxPoint(static_cast<wxPoint & >(result));
7372 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
7373 }
7374 return resultobj;
7375 fail:
7376 return NULL;
7377 }
7378
7379
7380 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
7381 PyObject *resultobj = NULL;
7382 wxCaret *arg1 = (wxCaret *) 0 ;
7383 int *arg2 = (int *) 0 ;
7384 int *arg3 = (int *) 0 ;
7385 int temp2 ;
7386 int res2 = 0 ;
7387 int temp3 ;
7388 int res3 = 0 ;
7389 PyObject * obj0 = 0 ;
7390 char *kwnames[] = {
7391 (char *) "self", NULL
7392 };
7393
7394 arg2 = &temp2; res2 = SWIG_NEWOBJ;
7395 arg3 = &temp3; res3 = SWIG_NEWOBJ;
7396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
7397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7398 if (SWIG_arg_fail(1)) SWIG_fail;
7399 {
7400 PyThreadState* __tstate = wxPyBeginAllowThreads();
7401 (arg1)->GetPosition(arg2,arg3);
7402
7403 wxPyEndAllowThreads(__tstate);
7404 if (PyErr_Occurred()) SWIG_fail;
7405 }
7406 Py_INCREF(Py_None); resultobj = Py_None;
7407 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
7408 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
7409 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
7410 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
7411 return resultobj;
7412 fail:
7413 return NULL;
7414 }
7415
7416
7417 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
7418 PyObject *resultobj = NULL;
7419 wxCaret *arg1 = (wxCaret *) 0 ;
7420 wxSize result;
7421 PyObject * obj0 = 0 ;
7422 char *kwnames[] = {
7423 (char *) "self", NULL
7424 };
7425
7426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
7427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7428 if (SWIG_arg_fail(1)) SWIG_fail;
7429 {
7430 PyThreadState* __tstate = wxPyBeginAllowThreads();
7431 result = (arg1)->GetSize();
7432
7433 wxPyEndAllowThreads(__tstate);
7434 if (PyErr_Occurred()) SWIG_fail;
7435 }
7436 {
7437 wxSize * resultptr;
7438 resultptr = new wxSize(static_cast<wxSize & >(result));
7439 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
7440 }
7441 return resultobj;
7442 fail:
7443 return NULL;
7444 }
7445
7446
7447 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
7448 PyObject *resultobj = NULL;
7449 wxCaret *arg1 = (wxCaret *) 0 ;
7450 int *arg2 = (int *) 0 ;
7451 int *arg3 = (int *) 0 ;
7452 int temp2 ;
7453 int res2 = 0 ;
7454 int temp3 ;
7455 int res3 = 0 ;
7456 PyObject * obj0 = 0 ;
7457 char *kwnames[] = {
7458 (char *) "self", NULL
7459 };
7460
7461 arg2 = &temp2; res2 = SWIG_NEWOBJ;
7462 arg3 = &temp3; res3 = SWIG_NEWOBJ;
7463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
7464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7465 if (SWIG_arg_fail(1)) SWIG_fail;
7466 {
7467 PyThreadState* __tstate = wxPyBeginAllowThreads();
7468 (arg1)->GetSize(arg2,arg3);
7469
7470 wxPyEndAllowThreads(__tstate);
7471 if (PyErr_Occurred()) SWIG_fail;
7472 }
7473 Py_INCREF(Py_None); resultobj = Py_None;
7474 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
7475 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
7476 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
7477 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
7478 return resultobj;
7479 fail:
7480 return NULL;
7481 }
7482
7483
7484 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7485 PyObject *resultobj = NULL;
7486 wxCaret *arg1 = (wxCaret *) 0 ;
7487 wxWindow *result;
7488 PyObject * obj0 = 0 ;
7489 char *kwnames[] = {
7490 (char *) "self", NULL
7491 };
7492
7493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
7494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7495 if (SWIG_arg_fail(1)) SWIG_fail;
7496 {
7497 PyThreadState* __tstate = wxPyBeginAllowThreads();
7498 result = (wxWindow *)(arg1)->GetWindow();
7499
7500 wxPyEndAllowThreads(__tstate);
7501 if (PyErr_Occurred()) SWIG_fail;
7502 }
7503 {
7504 resultobj = wxPyMake_wxObject(result, 0);
7505 }
7506 return resultobj;
7507 fail:
7508 return NULL;
7509 }
7510
7511
7512 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
7513 PyObject *resultobj = NULL;
7514 wxCaret *arg1 = (wxCaret *) 0 ;
7515 int arg2 ;
7516 int arg3 ;
7517 PyObject * obj0 = 0 ;
7518 PyObject * obj1 = 0 ;
7519 PyObject * obj2 = 0 ;
7520 char *kwnames[] = {
7521 (char *) "self",(char *) "x",(char *) "y", NULL
7522 };
7523
7524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
7525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7526 if (SWIG_arg_fail(1)) SWIG_fail;
7527 {
7528 arg2 = static_cast<int >(SWIG_As_int(obj1));
7529 if (SWIG_arg_fail(2)) SWIG_fail;
7530 }
7531 {
7532 arg3 = static_cast<int >(SWIG_As_int(obj2));
7533 if (SWIG_arg_fail(3)) SWIG_fail;
7534 }
7535 {
7536 PyThreadState* __tstate = wxPyBeginAllowThreads();
7537 (arg1)->Move(arg2,arg3);
7538
7539 wxPyEndAllowThreads(__tstate);
7540 if (PyErr_Occurred()) SWIG_fail;
7541 }
7542 Py_INCREF(Py_None); resultobj = Py_None;
7543 return resultobj;
7544 fail:
7545 return NULL;
7546 }
7547
7548
7549 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
7550 PyObject *resultobj = NULL;
7551 wxCaret *arg1 = (wxCaret *) 0 ;
7552 wxPoint *arg2 = 0 ;
7553 wxPoint temp2 ;
7554 PyObject * obj0 = 0 ;
7555 PyObject * obj1 = 0 ;
7556 char *kwnames[] = {
7557 (char *) "self",(char *) "pt", NULL
7558 };
7559
7560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
7561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7562 if (SWIG_arg_fail(1)) SWIG_fail;
7563 {
7564 arg2 = &temp2;
7565 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7566 }
7567 {
7568 PyThreadState* __tstate = wxPyBeginAllowThreads();
7569 (arg1)->Move((wxPoint const &)*arg2);
7570
7571 wxPyEndAllowThreads(__tstate);
7572 if (PyErr_Occurred()) SWIG_fail;
7573 }
7574 Py_INCREF(Py_None); resultobj = Py_None;
7575 return resultobj;
7576 fail:
7577 return NULL;
7578 }
7579
7580
7581 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
7582 PyObject *resultobj = NULL;
7583 wxCaret *arg1 = (wxCaret *) 0 ;
7584 int arg2 ;
7585 int arg3 ;
7586 PyObject * obj0 = 0 ;
7587 PyObject * obj1 = 0 ;
7588 PyObject * obj2 = 0 ;
7589 char *kwnames[] = {
7590 (char *) "self",(char *) "width",(char *) "height", NULL
7591 };
7592
7593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
7594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7595 if (SWIG_arg_fail(1)) SWIG_fail;
7596 {
7597 arg2 = static_cast<int >(SWIG_As_int(obj1));
7598 if (SWIG_arg_fail(2)) SWIG_fail;
7599 }
7600 {
7601 arg3 = static_cast<int >(SWIG_As_int(obj2));
7602 if (SWIG_arg_fail(3)) SWIG_fail;
7603 }
7604 {
7605 PyThreadState* __tstate = wxPyBeginAllowThreads();
7606 (arg1)->SetSize(arg2,arg3);
7607
7608 wxPyEndAllowThreads(__tstate);
7609 if (PyErr_Occurred()) SWIG_fail;
7610 }
7611 Py_INCREF(Py_None); resultobj = Py_None;
7612 return resultobj;
7613 fail:
7614 return NULL;
7615 }
7616
7617
7618 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
7619 PyObject *resultobj = NULL;
7620 wxCaret *arg1 = (wxCaret *) 0 ;
7621 wxSize *arg2 = 0 ;
7622 wxSize temp2 ;
7623 PyObject * obj0 = 0 ;
7624 PyObject * obj1 = 0 ;
7625 char *kwnames[] = {
7626 (char *) "self",(char *) "size", NULL
7627 };
7628
7629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
7630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7631 if (SWIG_arg_fail(1)) SWIG_fail;
7632 {
7633 arg2 = &temp2;
7634 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
7635 }
7636 {
7637 PyThreadState* __tstate = wxPyBeginAllowThreads();
7638 (arg1)->SetSize((wxSize const &)*arg2);
7639
7640 wxPyEndAllowThreads(__tstate);
7641 if (PyErr_Occurred()) SWIG_fail;
7642 }
7643 Py_INCREF(Py_None); resultobj = Py_None;
7644 return resultobj;
7645 fail:
7646 return NULL;
7647 }
7648
7649
7650 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
7651 PyObject *resultobj = NULL;
7652 wxCaret *arg1 = (wxCaret *) 0 ;
7653 int arg2 = (int) true ;
7654 PyObject * obj0 = 0 ;
7655 PyObject * obj1 = 0 ;
7656 char *kwnames[] = {
7657 (char *) "self",(char *) "show", NULL
7658 };
7659
7660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
7661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7662 if (SWIG_arg_fail(1)) SWIG_fail;
7663 if (obj1) {
7664 {
7665 arg2 = static_cast<int >(SWIG_As_int(obj1));
7666 if (SWIG_arg_fail(2)) SWIG_fail;
7667 }
7668 }
7669 {
7670 PyThreadState* __tstate = wxPyBeginAllowThreads();
7671 (arg1)->Show(arg2);
7672
7673 wxPyEndAllowThreads(__tstate);
7674 if (PyErr_Occurred()) SWIG_fail;
7675 }
7676 Py_INCREF(Py_None); resultobj = Py_None;
7677 return resultobj;
7678 fail:
7679 return NULL;
7680 }
7681
7682
7683 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
7684 PyObject *resultobj = NULL;
7685 wxCaret *arg1 = (wxCaret *) 0 ;
7686 PyObject * obj0 = 0 ;
7687 char *kwnames[] = {
7688 (char *) "self", NULL
7689 };
7690
7691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
7692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7693 if (SWIG_arg_fail(1)) SWIG_fail;
7694 {
7695 PyThreadState* __tstate = wxPyBeginAllowThreads();
7696 (arg1)->Hide();
7697
7698 wxPyEndAllowThreads(__tstate);
7699 if (PyErr_Occurred()) SWIG_fail;
7700 }
7701 Py_INCREF(Py_None); resultobj = Py_None;
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
7709 PyObject *resultobj = NULL;
7710 int result;
7711 char *kwnames[] = {
7712 NULL
7713 };
7714
7715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
7716 {
7717 PyThreadState* __tstate = wxPyBeginAllowThreads();
7718 result = (int)wxCaret::GetBlinkTime();
7719
7720 wxPyEndAllowThreads(__tstate);
7721 if (PyErr_Occurred()) SWIG_fail;
7722 }
7723 {
7724 resultobj = SWIG_From_int(static_cast<int >(result));
7725 }
7726 return resultobj;
7727 fail:
7728 return NULL;
7729 }
7730
7731
7732 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
7733 PyObject *resultobj = NULL;
7734 int arg1 ;
7735 PyObject * obj0 = 0 ;
7736 char *kwnames[] = {
7737 (char *) "milliseconds", NULL
7738 };
7739
7740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
7741 {
7742 arg1 = static_cast<int >(SWIG_As_int(obj0));
7743 if (SWIG_arg_fail(1)) SWIG_fail;
7744 }
7745 {
7746 PyThreadState* __tstate = wxPyBeginAllowThreads();
7747 wxCaret::SetBlinkTime(arg1);
7748
7749 wxPyEndAllowThreads(__tstate);
7750 if (PyErr_Occurred()) SWIG_fail;
7751 }
7752 Py_INCREF(Py_None); resultobj = Py_None;
7753 return resultobj;
7754 fail:
7755 return NULL;
7756 }
7757
7758
7759 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
7760 PyObject *obj;
7761 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7762 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
7763 Py_INCREF(obj);
7764 return Py_BuildValue((char *)"");
7765 }
7766 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7767 PyObject *resultobj = NULL;
7768 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7769 wxBusyCursor *result;
7770 PyObject * obj0 = 0 ;
7771 char *kwnames[] = {
7772 (char *) "cursor", NULL
7773 };
7774
7775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
7776 if (obj0) {
7777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
7778 if (SWIG_arg_fail(1)) SWIG_fail;
7779 }
7780 {
7781 if (!wxPyCheckForApp()) SWIG_fail;
7782 PyThreadState* __tstate = wxPyBeginAllowThreads();
7783 result = (wxBusyCursor *)new wxBusyCursor(arg1);
7784
7785 wxPyEndAllowThreads(__tstate);
7786 if (PyErr_Occurred()) SWIG_fail;
7787 }
7788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
7789 return resultobj;
7790 fail:
7791 return NULL;
7792 }
7793
7794
7795 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7796 PyObject *resultobj = NULL;
7797 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
7798 PyObject * obj0 = 0 ;
7799 char *kwnames[] = {
7800 (char *) "self", NULL
7801 };
7802
7803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
7804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
7805 if (SWIG_arg_fail(1)) SWIG_fail;
7806 {
7807 PyThreadState* __tstate = wxPyBeginAllowThreads();
7808 delete arg1;
7809
7810 wxPyEndAllowThreads(__tstate);
7811 if (PyErr_Occurred()) SWIG_fail;
7812 }
7813 Py_INCREF(Py_None); resultobj = Py_None;
7814 return resultobj;
7815 fail:
7816 return NULL;
7817 }
7818
7819
7820 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7821 PyObject *obj;
7822 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7823 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7824 Py_INCREF(obj);
7825 return Py_BuildValue((char *)"");
7826 }
7827 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7828 PyObject *resultobj = NULL;
7829 wxWindow *arg1 = (wxWindow *) NULL ;
7830 wxWindowDisabler *result;
7831 PyObject * obj0 = 0 ;
7832 char *kwnames[] = {
7833 (char *) "winToSkip", NULL
7834 };
7835
7836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7837 if (obj0) {
7838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7839 if (SWIG_arg_fail(1)) SWIG_fail;
7840 }
7841 {
7842 if (!wxPyCheckForApp()) SWIG_fail;
7843 PyThreadState* __tstate = wxPyBeginAllowThreads();
7844 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7845
7846 wxPyEndAllowThreads(__tstate);
7847 if (PyErr_Occurred()) SWIG_fail;
7848 }
7849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7850 return resultobj;
7851 fail:
7852 return NULL;
7853 }
7854
7855
7856 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7857 PyObject *resultobj = NULL;
7858 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7859 PyObject * obj0 = 0 ;
7860 char *kwnames[] = {
7861 (char *) "self", NULL
7862 };
7863
7864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7866 if (SWIG_arg_fail(1)) SWIG_fail;
7867 {
7868 PyThreadState* __tstate = wxPyBeginAllowThreads();
7869 delete arg1;
7870
7871 wxPyEndAllowThreads(__tstate);
7872 if (PyErr_Occurred()) SWIG_fail;
7873 }
7874 Py_INCREF(Py_None); resultobj = Py_None;
7875 return resultobj;
7876 fail:
7877 return NULL;
7878 }
7879
7880
7881 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7882 PyObject *obj;
7883 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7884 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7885 Py_INCREF(obj);
7886 return Py_BuildValue((char *)"");
7887 }
7888 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7889 PyObject *resultobj = NULL;
7890 wxString *arg1 = 0 ;
7891 wxBusyInfo *result;
7892 bool temp1 = false ;
7893 PyObject * obj0 = 0 ;
7894 char *kwnames[] = {
7895 (char *) "message", NULL
7896 };
7897
7898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7899 {
7900 arg1 = wxString_in_helper(obj0);
7901 if (arg1 == NULL) SWIG_fail;
7902 temp1 = true;
7903 }
7904 {
7905 if (!wxPyCheckForApp()) SWIG_fail;
7906 PyThreadState* __tstate = wxPyBeginAllowThreads();
7907 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7908
7909 wxPyEndAllowThreads(__tstate);
7910 if (PyErr_Occurred()) SWIG_fail;
7911 }
7912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7913 {
7914 if (temp1)
7915 delete arg1;
7916 }
7917 return resultobj;
7918 fail:
7919 {
7920 if (temp1)
7921 delete arg1;
7922 }
7923 return NULL;
7924 }
7925
7926
7927 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7928 PyObject *resultobj = NULL;
7929 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7930 PyObject * obj0 = 0 ;
7931 char *kwnames[] = {
7932 (char *) "self", NULL
7933 };
7934
7935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7937 if (SWIG_arg_fail(1)) SWIG_fail;
7938 {
7939 PyThreadState* __tstate = wxPyBeginAllowThreads();
7940 delete arg1;
7941
7942 wxPyEndAllowThreads(__tstate);
7943 if (PyErr_Occurred()) SWIG_fail;
7944 }
7945 Py_INCREF(Py_None); resultobj = Py_None;
7946 return resultobj;
7947 fail:
7948 return NULL;
7949 }
7950
7951
7952 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7953 PyObject *obj;
7954 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7955 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7956 Py_INCREF(obj);
7957 return Py_BuildValue((char *)"");
7958 }
7959 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7960 PyObject *resultobj = NULL;
7961 wxStopWatch *result;
7962 char *kwnames[] = {
7963 NULL
7964 };
7965
7966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7967 {
7968 PyThreadState* __tstate = wxPyBeginAllowThreads();
7969 result = (wxStopWatch *)new wxStopWatch();
7970
7971 wxPyEndAllowThreads(__tstate);
7972 if (PyErr_Occurred()) SWIG_fail;
7973 }
7974 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7975 return resultobj;
7976 fail:
7977 return NULL;
7978 }
7979
7980
7981 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7982 PyObject *resultobj = NULL;
7983 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7984 long arg2 = (long) 0 ;
7985 PyObject * obj0 = 0 ;
7986 PyObject * obj1 = 0 ;
7987 char *kwnames[] = {
7988 (char *) "self",(char *) "t0", NULL
7989 };
7990
7991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7993 if (SWIG_arg_fail(1)) SWIG_fail;
7994 if (obj1) {
7995 {
7996 arg2 = static_cast<long >(SWIG_As_long(obj1));
7997 if (SWIG_arg_fail(2)) SWIG_fail;
7998 }
7999 }
8000 {
8001 PyThreadState* __tstate = wxPyBeginAllowThreads();
8002 (arg1)->Start(arg2);
8003
8004 wxPyEndAllowThreads(__tstate);
8005 if (PyErr_Occurred()) SWIG_fail;
8006 }
8007 Py_INCREF(Py_None); resultobj = Py_None;
8008 return resultobj;
8009 fail:
8010 return NULL;
8011 }
8012
8013
8014 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
8015 PyObject *resultobj = NULL;
8016 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
8017 PyObject * obj0 = 0 ;
8018 char *kwnames[] = {
8019 (char *) "self", NULL
8020 };
8021
8022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
8023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
8024 if (SWIG_arg_fail(1)) SWIG_fail;
8025 {
8026 PyThreadState* __tstate = wxPyBeginAllowThreads();
8027 (arg1)->Pause();
8028
8029 wxPyEndAllowThreads(__tstate);
8030 if (PyErr_Occurred()) SWIG_fail;
8031 }
8032 Py_INCREF(Py_None); resultobj = Py_None;
8033 return resultobj;
8034 fail:
8035 return NULL;
8036 }
8037
8038
8039 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8040 PyObject *resultobj = NULL;
8041 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
8042 PyObject * obj0 = 0 ;
8043 char *kwnames[] = {
8044 (char *) "self", NULL
8045 };
8046
8047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
8048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
8049 if (SWIG_arg_fail(1)) SWIG_fail;
8050 {
8051 PyThreadState* __tstate = wxPyBeginAllowThreads();
8052 (arg1)->Resume();
8053
8054 wxPyEndAllowThreads(__tstate);
8055 if (PyErr_Occurred()) SWIG_fail;
8056 }
8057 Py_INCREF(Py_None); resultobj = Py_None;
8058 return resultobj;
8059 fail:
8060 return NULL;
8061 }
8062
8063
8064 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
8065 PyObject *resultobj = NULL;
8066 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
8067 long result;
8068 PyObject * obj0 = 0 ;
8069 char *kwnames[] = {
8070 (char *) "self", NULL
8071 };
8072
8073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
8074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
8075 if (SWIG_arg_fail(1)) SWIG_fail;
8076 {
8077 PyThreadState* __tstate = wxPyBeginAllowThreads();
8078 result = (long)((wxStopWatch const *)arg1)->Time();
8079
8080 wxPyEndAllowThreads(__tstate);
8081 if (PyErr_Occurred()) SWIG_fail;
8082 }
8083 {
8084 resultobj = SWIG_From_long(static_cast<long >(result));
8085 }
8086 return resultobj;
8087 fail:
8088 return NULL;
8089 }
8090
8091
8092 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
8093 PyObject *obj;
8094 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8095 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
8096 Py_INCREF(obj);
8097 return Py_BuildValue((char *)"");
8098 }
8099 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
8100 PyObject *resultobj = NULL;
8101 int arg1 = (int) 9 ;
8102 int arg2 = (int) wxID_FILE1 ;
8103 wxFileHistory *result;
8104 PyObject * obj0 = 0 ;
8105 PyObject * obj1 = 0 ;
8106 char *kwnames[] = {
8107 (char *) "maxFiles",(char *) "idBase", NULL
8108 };
8109
8110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
8111 if (obj0) {
8112 {
8113 arg1 = static_cast<int >(SWIG_As_int(obj0));
8114 if (SWIG_arg_fail(1)) SWIG_fail;
8115 }
8116 }
8117 if (obj1) {
8118 {
8119 arg2 = static_cast<int >(SWIG_As_int(obj1));
8120 if (SWIG_arg_fail(2)) SWIG_fail;
8121 }
8122 }
8123 {
8124 PyThreadState* __tstate = wxPyBeginAllowThreads();
8125 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
8126
8127 wxPyEndAllowThreads(__tstate);
8128 if (PyErr_Occurred()) SWIG_fail;
8129 }
8130 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
8131 return resultobj;
8132 fail:
8133 return NULL;
8134 }
8135
8136
8137 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
8138 PyObject *resultobj = NULL;
8139 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8140 PyObject * obj0 = 0 ;
8141 char *kwnames[] = {
8142 (char *) "self", NULL
8143 };
8144
8145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
8146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8147 if (SWIG_arg_fail(1)) SWIG_fail;
8148 {
8149 PyThreadState* __tstate = wxPyBeginAllowThreads();
8150 delete arg1;
8151
8152 wxPyEndAllowThreads(__tstate);
8153 if (PyErr_Occurred()) SWIG_fail;
8154 }
8155 Py_INCREF(Py_None); resultobj = Py_None;
8156 return resultobj;
8157 fail:
8158 return NULL;
8159 }
8160
8161
8162 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
8163 PyObject *resultobj = NULL;
8164 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8165 wxString *arg2 = 0 ;
8166 bool temp2 = false ;
8167 PyObject * obj0 = 0 ;
8168 PyObject * obj1 = 0 ;
8169 char *kwnames[] = {
8170 (char *) "self",(char *) "file", NULL
8171 };
8172
8173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
8174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8175 if (SWIG_arg_fail(1)) SWIG_fail;
8176 {
8177 arg2 = wxString_in_helper(obj1);
8178 if (arg2 == NULL) SWIG_fail;
8179 temp2 = true;
8180 }
8181 {
8182 PyThreadState* __tstate = wxPyBeginAllowThreads();
8183 (arg1)->AddFileToHistory((wxString const &)*arg2);
8184
8185 wxPyEndAllowThreads(__tstate);
8186 if (PyErr_Occurred()) SWIG_fail;
8187 }
8188 Py_INCREF(Py_None); resultobj = Py_None;
8189 {
8190 if (temp2)
8191 delete arg2;
8192 }
8193 return resultobj;
8194 fail:
8195 {
8196 if (temp2)
8197 delete arg2;
8198 }
8199 return NULL;
8200 }
8201
8202
8203 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
8204 PyObject *resultobj = NULL;
8205 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8206 int arg2 ;
8207 PyObject * obj0 = 0 ;
8208 PyObject * obj1 = 0 ;
8209 char *kwnames[] = {
8210 (char *) "self",(char *) "i", NULL
8211 };
8212
8213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
8214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8215 if (SWIG_arg_fail(1)) SWIG_fail;
8216 {
8217 arg2 = static_cast<int >(SWIG_As_int(obj1));
8218 if (SWIG_arg_fail(2)) SWIG_fail;
8219 }
8220 {
8221 PyThreadState* __tstate = wxPyBeginAllowThreads();
8222 (arg1)->RemoveFileFromHistory(arg2);
8223
8224 wxPyEndAllowThreads(__tstate);
8225 if (PyErr_Occurred()) SWIG_fail;
8226 }
8227 Py_INCREF(Py_None); resultobj = Py_None;
8228 return resultobj;
8229 fail:
8230 return NULL;
8231 }
8232
8233
8234 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
8235 PyObject *resultobj = NULL;
8236 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8237 int result;
8238 PyObject * obj0 = 0 ;
8239 char *kwnames[] = {
8240 (char *) "self", NULL
8241 };
8242
8243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
8244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8245 if (SWIG_arg_fail(1)) SWIG_fail;
8246 {
8247 PyThreadState* __tstate = wxPyBeginAllowThreads();
8248 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
8249
8250 wxPyEndAllowThreads(__tstate);
8251 if (PyErr_Occurred()) SWIG_fail;
8252 }
8253 {
8254 resultobj = SWIG_From_int(static_cast<int >(result));
8255 }
8256 return resultobj;
8257 fail:
8258 return NULL;
8259 }
8260
8261
8262 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
8263 PyObject *resultobj = NULL;
8264 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8265 wxMenu *arg2 = (wxMenu *) 0 ;
8266 PyObject * obj0 = 0 ;
8267 PyObject * obj1 = 0 ;
8268 char *kwnames[] = {
8269 (char *) "self",(char *) "menu", NULL
8270 };
8271
8272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
8273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8274 if (SWIG_arg_fail(1)) SWIG_fail;
8275 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
8276 if (SWIG_arg_fail(2)) SWIG_fail;
8277 {
8278 PyThreadState* __tstate = wxPyBeginAllowThreads();
8279 (arg1)->UseMenu(arg2);
8280
8281 wxPyEndAllowThreads(__tstate);
8282 if (PyErr_Occurred()) SWIG_fail;
8283 }
8284 Py_INCREF(Py_None); resultobj = Py_None;
8285 return resultobj;
8286 fail:
8287 return NULL;
8288 }
8289
8290
8291 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
8292 PyObject *resultobj = NULL;
8293 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8294 wxMenu *arg2 = (wxMenu *) 0 ;
8295 PyObject * obj0 = 0 ;
8296 PyObject * obj1 = 0 ;
8297 char *kwnames[] = {
8298 (char *) "self",(char *) "menu", NULL
8299 };
8300
8301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
8302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8303 if (SWIG_arg_fail(1)) SWIG_fail;
8304 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
8305 if (SWIG_arg_fail(2)) SWIG_fail;
8306 {
8307 PyThreadState* __tstate = wxPyBeginAllowThreads();
8308 (arg1)->RemoveMenu(arg2);
8309
8310 wxPyEndAllowThreads(__tstate);
8311 if (PyErr_Occurred()) SWIG_fail;
8312 }
8313 Py_INCREF(Py_None); resultobj = Py_None;
8314 return resultobj;
8315 fail:
8316 return NULL;
8317 }
8318
8319
8320 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
8321 PyObject *resultobj = NULL;
8322 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8323 wxConfigBase *arg2 = 0 ;
8324 PyObject * obj0 = 0 ;
8325 PyObject * obj1 = 0 ;
8326 char *kwnames[] = {
8327 (char *) "self",(char *) "config", NULL
8328 };
8329
8330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
8331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8332 if (SWIG_arg_fail(1)) SWIG_fail;
8333 {
8334 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8335 if (SWIG_arg_fail(2)) SWIG_fail;
8336 if (arg2 == NULL) {
8337 SWIG_null_ref("wxConfigBase");
8338 }
8339 if (SWIG_arg_fail(2)) SWIG_fail;
8340 }
8341 {
8342 PyThreadState* __tstate = wxPyBeginAllowThreads();
8343 (arg1)->Load(*arg2);
8344
8345 wxPyEndAllowThreads(__tstate);
8346 if (PyErr_Occurred()) SWIG_fail;
8347 }
8348 Py_INCREF(Py_None); resultobj = Py_None;
8349 return resultobj;
8350 fail:
8351 return NULL;
8352 }
8353
8354
8355 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
8356 PyObject *resultobj = NULL;
8357 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8358 wxConfigBase *arg2 = 0 ;
8359 PyObject * obj0 = 0 ;
8360 PyObject * obj1 = 0 ;
8361 char *kwnames[] = {
8362 (char *) "self",(char *) "config", NULL
8363 };
8364
8365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
8366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8367 if (SWIG_arg_fail(1)) SWIG_fail;
8368 {
8369 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8370 if (SWIG_arg_fail(2)) SWIG_fail;
8371 if (arg2 == NULL) {
8372 SWIG_null_ref("wxConfigBase");
8373 }
8374 if (SWIG_arg_fail(2)) SWIG_fail;
8375 }
8376 {
8377 PyThreadState* __tstate = wxPyBeginAllowThreads();
8378 (arg1)->Save(*arg2);
8379
8380 wxPyEndAllowThreads(__tstate);
8381 if (PyErr_Occurred()) SWIG_fail;
8382 }
8383 Py_INCREF(Py_None); resultobj = Py_None;
8384 return resultobj;
8385 fail:
8386 return NULL;
8387 }
8388
8389
8390 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
8391 PyObject *resultobj = NULL;
8392 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8393 PyObject * obj0 = 0 ;
8394 char *kwnames[] = {
8395 (char *) "self", NULL
8396 };
8397
8398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
8399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8400 if (SWIG_arg_fail(1)) SWIG_fail;
8401 {
8402 PyThreadState* __tstate = wxPyBeginAllowThreads();
8403 (arg1)->AddFilesToMenu();
8404
8405 wxPyEndAllowThreads(__tstate);
8406 if (PyErr_Occurred()) SWIG_fail;
8407 }
8408 Py_INCREF(Py_None); resultobj = Py_None;
8409 return resultobj;
8410 fail:
8411 return NULL;
8412 }
8413
8414
8415 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
8416 PyObject *resultobj = NULL;
8417 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8418 wxMenu *arg2 = (wxMenu *) 0 ;
8419 PyObject * obj0 = 0 ;
8420 PyObject * obj1 = 0 ;
8421 char *kwnames[] = {
8422 (char *) "self",(char *) "menu", NULL
8423 };
8424
8425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
8426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8427 if (SWIG_arg_fail(1)) SWIG_fail;
8428 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
8429 if (SWIG_arg_fail(2)) SWIG_fail;
8430 {
8431 PyThreadState* __tstate = wxPyBeginAllowThreads();
8432 (arg1)->AddFilesToMenu(arg2);
8433
8434 wxPyEndAllowThreads(__tstate);
8435 if (PyErr_Occurred()) SWIG_fail;
8436 }
8437 Py_INCREF(Py_None); resultobj = Py_None;
8438 return resultobj;
8439 fail:
8440 return NULL;
8441 }
8442
8443
8444 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
8445 PyObject *resultobj = NULL;
8446 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8447 int arg2 ;
8448 wxString result;
8449 PyObject * obj0 = 0 ;
8450 PyObject * obj1 = 0 ;
8451 char *kwnames[] = {
8452 (char *) "self",(char *) "i", NULL
8453 };
8454
8455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
8456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8457 if (SWIG_arg_fail(1)) SWIG_fail;
8458 {
8459 arg2 = static_cast<int >(SWIG_As_int(obj1));
8460 if (SWIG_arg_fail(2)) SWIG_fail;
8461 }
8462 {
8463 PyThreadState* __tstate = wxPyBeginAllowThreads();
8464 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
8465
8466 wxPyEndAllowThreads(__tstate);
8467 if (PyErr_Occurred()) SWIG_fail;
8468 }
8469 {
8470 #if wxUSE_UNICODE
8471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8472 #else
8473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8474 #endif
8475 }
8476 return resultobj;
8477 fail:
8478 return NULL;
8479 }
8480
8481
8482 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
8483 PyObject *resultobj = NULL;
8484 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8485 int result;
8486 PyObject * obj0 = 0 ;
8487 char *kwnames[] = {
8488 (char *) "self", NULL
8489 };
8490
8491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
8492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8493 if (SWIG_arg_fail(1)) SWIG_fail;
8494 {
8495 PyThreadState* __tstate = wxPyBeginAllowThreads();
8496 result = (int)((wxFileHistory const *)arg1)->GetCount();
8497
8498 wxPyEndAllowThreads(__tstate);
8499 if (PyErr_Occurred()) SWIG_fail;
8500 }
8501 {
8502 resultobj = SWIG_From_int(static_cast<int >(result));
8503 }
8504 return resultobj;
8505 fail:
8506 return NULL;
8507 }
8508
8509
8510 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
8511 PyObject *obj;
8512 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8513 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
8514 Py_INCREF(obj);
8515 return Py_BuildValue((char *)"");
8516 }
8517 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
8518 PyObject *resultobj = NULL;
8519 wxString *arg1 = 0 ;
8520 wxString const &arg2_defvalue = wxPyEmptyString ;
8521 wxString *arg2 = (wxString *) &arg2_defvalue ;
8522 wxSingleInstanceChecker *result;
8523 bool temp1 = false ;
8524 bool temp2 = false ;
8525 PyObject * obj0 = 0 ;
8526 PyObject * obj1 = 0 ;
8527 char *kwnames[] = {
8528 (char *) "name",(char *) "path", NULL
8529 };
8530
8531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
8532 {
8533 arg1 = wxString_in_helper(obj0);
8534 if (arg1 == NULL) SWIG_fail;
8535 temp1 = true;
8536 }
8537 if (obj1) {
8538 {
8539 arg2 = wxString_in_helper(obj1);
8540 if (arg2 == NULL) SWIG_fail;
8541 temp2 = true;
8542 }
8543 }
8544 {
8545 PyThreadState* __tstate = wxPyBeginAllowThreads();
8546 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
8547
8548 wxPyEndAllowThreads(__tstate);
8549 if (PyErr_Occurred()) SWIG_fail;
8550 }
8551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
8552 {
8553 if (temp1)
8554 delete arg1;
8555 }
8556 {
8557 if (temp2)
8558 delete arg2;
8559 }
8560 return resultobj;
8561 fail:
8562 {
8563 if (temp1)
8564 delete arg1;
8565 }
8566 {
8567 if (temp2)
8568 delete arg2;
8569 }
8570 return NULL;
8571 }
8572
8573
8574 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
8575 PyObject *resultobj = NULL;
8576 wxSingleInstanceChecker *result;
8577 char *kwnames[] = {
8578 NULL
8579 };
8580
8581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
8582 {
8583 PyThreadState* __tstate = wxPyBeginAllowThreads();
8584 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
8585
8586 wxPyEndAllowThreads(__tstate);
8587 if (PyErr_Occurred()) SWIG_fail;
8588 }
8589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
8590 return resultobj;
8591 fail:
8592 return NULL;
8593 }
8594
8595
8596 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
8597 PyObject *resultobj = NULL;
8598 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
8599 PyObject * obj0 = 0 ;
8600 char *kwnames[] = {
8601 (char *) "self", NULL
8602 };
8603
8604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
8605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
8606 if (SWIG_arg_fail(1)) SWIG_fail;
8607 {
8608 PyThreadState* __tstate = wxPyBeginAllowThreads();
8609 delete arg1;
8610
8611 wxPyEndAllowThreads(__tstate);
8612 if (PyErr_Occurred()) SWIG_fail;
8613 }
8614 Py_INCREF(Py_None); resultobj = Py_None;
8615 return resultobj;
8616 fail:
8617 return NULL;
8618 }
8619
8620
8621 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
8622 PyObject *resultobj = NULL;
8623 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
8624 wxString *arg2 = 0 ;
8625 wxString const &arg3_defvalue = wxPyEmptyString ;
8626 wxString *arg3 = (wxString *) &arg3_defvalue ;
8627 bool result;
8628 bool temp2 = false ;
8629 bool temp3 = false ;
8630 PyObject * obj0 = 0 ;
8631 PyObject * obj1 = 0 ;
8632 PyObject * obj2 = 0 ;
8633 char *kwnames[] = {
8634 (char *) "self",(char *) "name",(char *) "path", NULL
8635 };
8636
8637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
8638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
8639 if (SWIG_arg_fail(1)) SWIG_fail;
8640 {
8641 arg2 = wxString_in_helper(obj1);
8642 if (arg2 == NULL) SWIG_fail;
8643 temp2 = true;
8644 }
8645 if (obj2) {
8646 {
8647 arg3 = wxString_in_helper(obj2);
8648 if (arg3 == NULL) SWIG_fail;
8649 temp3 = true;
8650 }
8651 }
8652 {
8653 PyThreadState* __tstate = wxPyBeginAllowThreads();
8654 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
8655
8656 wxPyEndAllowThreads(__tstate);
8657 if (PyErr_Occurred()) SWIG_fail;
8658 }
8659 {
8660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8661 }
8662 {
8663 if (temp2)
8664 delete arg2;
8665 }
8666 {
8667 if (temp3)
8668 delete arg3;
8669 }
8670 return resultobj;
8671 fail:
8672 {
8673 if (temp2)
8674 delete arg2;
8675 }
8676 {
8677 if (temp3)
8678 delete arg3;
8679 }
8680 return NULL;
8681 }
8682
8683
8684 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8685 PyObject *resultobj = NULL;
8686 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
8687 bool result;
8688 PyObject * obj0 = 0 ;
8689 char *kwnames[] = {
8690 (char *) "self", NULL
8691 };
8692
8693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
8694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
8695 if (SWIG_arg_fail(1)) SWIG_fail;
8696 {
8697 PyThreadState* __tstate = wxPyBeginAllowThreads();
8698 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
8699
8700 wxPyEndAllowThreads(__tstate);
8701 if (PyErr_Occurred()) SWIG_fail;
8702 }
8703 {
8704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8705 }
8706 return resultobj;
8707 fail:
8708 return NULL;
8709 }
8710
8711
8712 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
8713 PyObject *obj;
8714 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8715 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
8716 Py_INCREF(obj);
8717 return Py_BuildValue((char *)"");
8718 }
8719 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
8720 PyObject *resultobj = NULL;
8721 wxWindow *arg1 = (wxWindow *) 0 ;
8722 wxDC *arg2 = 0 ;
8723 bool result;
8724 PyObject * obj0 = 0 ;
8725 PyObject * obj1 = 0 ;
8726 char *kwnames[] = {
8727 (char *) "window",(char *) "dc", NULL
8728 };
8729
8730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
8731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8732 if (SWIG_arg_fail(1)) SWIG_fail;
8733 {
8734 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
8735 if (SWIG_arg_fail(2)) SWIG_fail;
8736 if (arg2 == NULL) {
8737 SWIG_null_ref("wxDC");
8738 }
8739 if (SWIG_arg_fail(2)) SWIG_fail;
8740 }
8741 {
8742 PyThreadState* __tstate = wxPyBeginAllowThreads();
8743 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
8744
8745 wxPyEndAllowThreads(__tstate);
8746 if (PyErr_Occurred()) SWIG_fail;
8747 }
8748 {
8749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8750 }
8751 return resultobj;
8752 fail:
8753 return NULL;
8754 }
8755
8756
8757 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8758 PyObject *resultobj = NULL;
8759 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8760 PyObject * obj0 = 0 ;
8761 char *kwnames[] = {
8762 (char *) "self", NULL
8763 };
8764
8765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
8766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8767 if (SWIG_arg_fail(1)) SWIG_fail;
8768 {
8769 PyThreadState* __tstate = wxPyBeginAllowThreads();
8770 delete arg1;
8771
8772 wxPyEndAllowThreads(__tstate);
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 Py_INCREF(Py_None); resultobj = Py_None;
8776 return resultobj;
8777 fail:
8778 return NULL;
8779 }
8780
8781
8782 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
8783 PyObject *resultobj = NULL;
8784 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8785 wxString result;
8786 PyObject * obj0 = 0 ;
8787 char *kwnames[] = {
8788 (char *) "self", NULL
8789 };
8790
8791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
8792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8793 if (SWIG_arg_fail(1)) SWIG_fail;
8794 {
8795 PyThreadState* __tstate = wxPyBeginAllowThreads();
8796 result = (arg1)->GetTip();
8797
8798 wxPyEndAllowThreads(__tstate);
8799 if (PyErr_Occurred()) SWIG_fail;
8800 }
8801 {
8802 #if wxUSE_UNICODE
8803 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8804 #else
8805 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8806 #endif
8807 }
8808 return resultobj;
8809 fail:
8810 return NULL;
8811 }
8812
8813
8814 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8815 PyObject *resultobj = NULL;
8816 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8817 size_t result;
8818 PyObject * obj0 = 0 ;
8819 char *kwnames[] = {
8820 (char *) "self", NULL
8821 };
8822
8823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8825 if (SWIG_arg_fail(1)) SWIG_fail;
8826 {
8827 PyThreadState* __tstate = wxPyBeginAllowThreads();
8828 result = (size_t)(arg1)->GetCurrentTip();
8829
8830 wxPyEndAllowThreads(__tstate);
8831 if (PyErr_Occurred()) SWIG_fail;
8832 }
8833 {
8834 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
8835 }
8836 return resultobj;
8837 fail:
8838 return NULL;
8839 }
8840
8841
8842 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8843 PyObject *resultobj = NULL;
8844 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8845 wxString *arg2 = 0 ;
8846 wxString result;
8847 bool temp2 = false ;
8848 PyObject * obj0 = 0 ;
8849 PyObject * obj1 = 0 ;
8850 char *kwnames[] = {
8851 (char *) "self",(char *) "tip", NULL
8852 };
8853
8854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8856 if (SWIG_arg_fail(1)) SWIG_fail;
8857 {
8858 arg2 = wxString_in_helper(obj1);
8859 if (arg2 == NULL) SWIG_fail;
8860 temp2 = true;
8861 }
8862 {
8863 PyThreadState* __tstate = wxPyBeginAllowThreads();
8864 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8865
8866 wxPyEndAllowThreads(__tstate);
8867 if (PyErr_Occurred()) SWIG_fail;
8868 }
8869 {
8870 #if wxUSE_UNICODE
8871 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8872 #else
8873 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8874 #endif
8875 }
8876 {
8877 if (temp2)
8878 delete arg2;
8879 }
8880 return resultobj;
8881 fail:
8882 {
8883 if (temp2)
8884 delete arg2;
8885 }
8886 return NULL;
8887 }
8888
8889
8890 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8891 PyObject *obj;
8892 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8893 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8894 Py_INCREF(obj);
8895 return Py_BuildValue((char *)"");
8896 }
8897 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8898 PyObject *resultobj = NULL;
8899 size_t arg1 ;
8900 wxPyTipProvider *result;
8901 PyObject * obj0 = 0 ;
8902 char *kwnames[] = {
8903 (char *) "currentTip", NULL
8904 };
8905
8906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8907 {
8908 arg1 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj0));
8909 if (SWIG_arg_fail(1)) SWIG_fail;
8910 }
8911 {
8912 PyThreadState* __tstate = wxPyBeginAllowThreads();
8913 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8914
8915 wxPyEndAllowThreads(__tstate);
8916 if (PyErr_Occurred()) SWIG_fail;
8917 }
8918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8919 return resultobj;
8920 fail:
8921 return NULL;
8922 }
8923
8924
8925 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8926 PyObject *resultobj = NULL;
8927 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8928 PyObject *arg2 = (PyObject *) 0 ;
8929 PyObject *arg3 = (PyObject *) 0 ;
8930 PyObject * obj0 = 0 ;
8931 PyObject * obj1 = 0 ;
8932 PyObject * obj2 = 0 ;
8933 char *kwnames[] = {
8934 (char *) "self",(char *) "self",(char *) "_class", NULL
8935 };
8936
8937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8939 if (SWIG_arg_fail(1)) SWIG_fail;
8940 arg2 = obj1;
8941 arg3 = obj2;
8942 {
8943 PyThreadState* __tstate = wxPyBeginAllowThreads();
8944 (arg1)->_setCallbackInfo(arg2,arg3);
8945
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 Py_INCREF(Py_None); resultobj = Py_None;
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8957 PyObject *obj;
8958 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8959 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8960 Py_INCREF(obj);
8961 return Py_BuildValue((char *)"");
8962 }
8963 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8964 PyObject *resultobj = NULL;
8965 wxWindow *arg1 = (wxWindow *) 0 ;
8966 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8967 bool arg3 = (bool) true ;
8968 bool result;
8969 PyObject * obj0 = 0 ;
8970 PyObject * obj1 = 0 ;
8971 PyObject * obj2 = 0 ;
8972 char *kwnames[] = {
8973 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8974 };
8975
8976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8978 if (SWIG_arg_fail(1)) SWIG_fail;
8979 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8980 if (SWIG_arg_fail(2)) SWIG_fail;
8981 if (obj2) {
8982 {
8983 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
8984 if (SWIG_arg_fail(3)) SWIG_fail;
8985 }
8986 }
8987 {
8988 if (!wxPyCheckForApp()) SWIG_fail;
8989 PyThreadState* __tstate = wxPyBeginAllowThreads();
8990 result = (bool)wxShowTip(arg1,arg2,arg3);
8991
8992 wxPyEndAllowThreads(__tstate);
8993 if (PyErr_Occurred()) SWIG_fail;
8994 }
8995 {
8996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8997 }
8998 return resultobj;
8999 fail:
9000 return NULL;
9001 }
9002
9003
9004 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
9005 PyObject *resultobj = NULL;
9006 wxString *arg1 = 0 ;
9007 size_t arg2 ;
9008 wxTipProvider *result;
9009 bool temp1 = false ;
9010 PyObject * obj0 = 0 ;
9011 PyObject * obj1 = 0 ;
9012 char *kwnames[] = {
9013 (char *) "filename",(char *) "currentTip", NULL
9014 };
9015
9016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
9017 {
9018 arg1 = wxString_in_helper(obj0);
9019 if (arg1 == NULL) SWIG_fail;
9020 temp1 = true;
9021 }
9022 {
9023 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
9024 if (SWIG_arg_fail(2)) SWIG_fail;
9025 }
9026 {
9027 if (!wxPyCheckForApp()) SWIG_fail;
9028 PyThreadState* __tstate = wxPyBeginAllowThreads();
9029 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
9030
9031 wxPyEndAllowThreads(__tstate);
9032 if (PyErr_Occurred()) SWIG_fail;
9033 }
9034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
9035 {
9036 if (temp1)
9037 delete arg1;
9038 }
9039 return resultobj;
9040 fail:
9041 {
9042 if (temp1)
9043 delete arg1;
9044 }
9045 return NULL;
9046 }
9047
9048
9049 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
9050 PyObject *resultobj = NULL;
9051 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
9052 int arg2 = (int) -1 ;
9053 wxPyTimer *result;
9054 PyObject * obj0 = 0 ;
9055 PyObject * obj1 = 0 ;
9056 char *kwnames[] = {
9057 (char *) "owner",(char *) "id", NULL
9058 };
9059
9060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
9061 if (obj0) {
9062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
9063 if (SWIG_arg_fail(1)) SWIG_fail;
9064 }
9065 if (obj1) {
9066 {
9067 arg2 = static_cast<int >(SWIG_As_int(obj1));
9068 if (SWIG_arg_fail(2)) SWIG_fail;
9069 }
9070 }
9071 {
9072 if (!wxPyCheckForApp()) SWIG_fail;
9073 PyThreadState* __tstate = wxPyBeginAllowThreads();
9074 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
9075
9076 wxPyEndAllowThreads(__tstate);
9077 if (PyErr_Occurred()) SWIG_fail;
9078 }
9079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
9080 return resultobj;
9081 fail:
9082 return NULL;
9083 }
9084
9085
9086 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
9087 PyObject *resultobj = NULL;
9088 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9089 PyObject * obj0 = 0 ;
9090 char *kwnames[] = {
9091 (char *) "self", NULL
9092 };
9093
9094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
9095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9096 if (SWIG_arg_fail(1)) SWIG_fail;
9097 {
9098 PyThreadState* __tstate = wxPyBeginAllowThreads();
9099 delete arg1;
9100
9101 wxPyEndAllowThreads(__tstate);
9102 if (PyErr_Occurred()) SWIG_fail;
9103 }
9104 Py_INCREF(Py_None); resultobj = Py_None;
9105 return resultobj;
9106 fail:
9107 return NULL;
9108 }
9109
9110
9111 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9112 PyObject *resultobj = NULL;
9113 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9114 PyObject *arg2 = (PyObject *) 0 ;
9115 PyObject *arg3 = (PyObject *) 0 ;
9116 int arg4 = (int) 1 ;
9117 PyObject * obj0 = 0 ;
9118 PyObject * obj1 = 0 ;
9119 PyObject * obj2 = 0 ;
9120 PyObject * obj3 = 0 ;
9121 char *kwnames[] = {
9122 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
9123 };
9124
9125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9127 if (SWIG_arg_fail(1)) SWIG_fail;
9128 arg2 = obj1;
9129 arg3 = obj2;
9130 if (obj3) {
9131 {
9132 arg4 = static_cast<int >(SWIG_As_int(obj3));
9133 if (SWIG_arg_fail(4)) SWIG_fail;
9134 }
9135 }
9136 {
9137 PyThreadState* __tstate = wxPyBeginAllowThreads();
9138 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
9139
9140 wxPyEndAllowThreads(__tstate);
9141 if (PyErr_Occurred()) SWIG_fail;
9142 }
9143 Py_INCREF(Py_None); resultobj = Py_None;
9144 return resultobj;
9145 fail:
9146 return NULL;
9147 }
9148
9149
9150 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
9151 PyObject *resultobj = NULL;
9152 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9153 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
9154 int arg3 = (int) -1 ;
9155 PyObject * obj0 = 0 ;
9156 PyObject * obj1 = 0 ;
9157 PyObject * obj2 = 0 ;
9158 char *kwnames[] = {
9159 (char *) "self",(char *) "owner",(char *) "id", NULL
9160 };
9161
9162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
9163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9164 if (SWIG_arg_fail(1)) SWIG_fail;
9165 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
9166 if (SWIG_arg_fail(2)) SWIG_fail;
9167 if (obj2) {
9168 {
9169 arg3 = static_cast<int >(SWIG_As_int(obj2));
9170 if (SWIG_arg_fail(3)) SWIG_fail;
9171 }
9172 }
9173 {
9174 PyThreadState* __tstate = wxPyBeginAllowThreads();
9175 (arg1)->SetOwner(arg2,arg3);
9176
9177 wxPyEndAllowThreads(__tstate);
9178 if (PyErr_Occurred()) SWIG_fail;
9179 }
9180 Py_INCREF(Py_None); resultobj = Py_None;
9181 return resultobj;
9182 fail:
9183 return NULL;
9184 }
9185
9186
9187 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
9188 PyObject *resultobj = NULL;
9189 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9190 wxEvtHandler *result;
9191 PyObject * obj0 = 0 ;
9192 char *kwnames[] = {
9193 (char *) "self", NULL
9194 };
9195
9196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
9197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9198 if (SWIG_arg_fail(1)) SWIG_fail;
9199 {
9200 PyThreadState* __tstate = wxPyBeginAllowThreads();
9201 result = (wxEvtHandler *)(arg1)->GetOwner();
9202
9203 wxPyEndAllowThreads(__tstate);
9204 if (PyErr_Occurred()) SWIG_fail;
9205 }
9206 {
9207 resultobj = wxPyMake_wxObject(result, 0);
9208 }
9209 return resultobj;
9210 fail:
9211 return NULL;
9212 }
9213
9214
9215 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
9216 PyObject *resultobj = NULL;
9217 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9218 int arg2 = (int) -1 ;
9219 bool arg3 = (bool) false ;
9220 bool result;
9221 PyObject * obj0 = 0 ;
9222 PyObject * obj1 = 0 ;
9223 PyObject * obj2 = 0 ;
9224 char *kwnames[] = {
9225 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
9226 };
9227
9228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
9229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9230 if (SWIG_arg_fail(1)) SWIG_fail;
9231 if (obj1) {
9232 {
9233 arg2 = static_cast<int >(SWIG_As_int(obj1));
9234 if (SWIG_arg_fail(2)) SWIG_fail;
9235 }
9236 }
9237 if (obj2) {
9238 {
9239 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
9240 if (SWIG_arg_fail(3)) SWIG_fail;
9241 }
9242 }
9243 {
9244 PyThreadState* __tstate = wxPyBeginAllowThreads();
9245 result = (bool)(arg1)->Start(arg2,arg3);
9246
9247 wxPyEndAllowThreads(__tstate);
9248 if (PyErr_Occurred()) SWIG_fail;
9249 }
9250 {
9251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9252 }
9253 return resultobj;
9254 fail:
9255 return NULL;
9256 }
9257
9258
9259 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
9260 PyObject *resultobj = NULL;
9261 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9262 PyObject * obj0 = 0 ;
9263 char *kwnames[] = {
9264 (char *) "self", NULL
9265 };
9266
9267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
9268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9269 if (SWIG_arg_fail(1)) SWIG_fail;
9270 {
9271 PyThreadState* __tstate = wxPyBeginAllowThreads();
9272 (arg1)->Stop();
9273
9274 wxPyEndAllowThreads(__tstate);
9275 if (PyErr_Occurred()) SWIG_fail;
9276 }
9277 Py_INCREF(Py_None); resultobj = Py_None;
9278 return resultobj;
9279 fail:
9280 return NULL;
9281 }
9282
9283
9284 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
9285 PyObject *resultobj = NULL;
9286 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9287 bool result;
9288 PyObject * obj0 = 0 ;
9289 char *kwnames[] = {
9290 (char *) "self", NULL
9291 };
9292
9293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
9294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9295 if (SWIG_arg_fail(1)) SWIG_fail;
9296 {
9297 PyThreadState* __tstate = wxPyBeginAllowThreads();
9298 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
9299
9300 wxPyEndAllowThreads(__tstate);
9301 if (PyErr_Occurred()) SWIG_fail;
9302 }
9303 {
9304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9305 }
9306 return resultobj;
9307 fail:
9308 return NULL;
9309 }
9310
9311
9312 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
9313 PyObject *resultobj = NULL;
9314 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9315 int result;
9316 PyObject * obj0 = 0 ;
9317 char *kwnames[] = {
9318 (char *) "self", NULL
9319 };
9320
9321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
9322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9323 if (SWIG_arg_fail(1)) SWIG_fail;
9324 {
9325 PyThreadState* __tstate = wxPyBeginAllowThreads();
9326 result = (int)((wxPyTimer const *)arg1)->GetInterval();
9327
9328 wxPyEndAllowThreads(__tstate);
9329 if (PyErr_Occurred()) SWIG_fail;
9330 }
9331 {
9332 resultobj = SWIG_From_int(static_cast<int >(result));
9333 }
9334 return resultobj;
9335 fail:
9336 return NULL;
9337 }
9338
9339
9340 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
9341 PyObject *resultobj = NULL;
9342 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9343 bool result;
9344 PyObject * obj0 = 0 ;
9345 char *kwnames[] = {
9346 (char *) "self", NULL
9347 };
9348
9349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
9350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9351 if (SWIG_arg_fail(1)) SWIG_fail;
9352 {
9353 PyThreadState* __tstate = wxPyBeginAllowThreads();
9354 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
9355
9356 wxPyEndAllowThreads(__tstate);
9357 if (PyErr_Occurred()) SWIG_fail;
9358 }
9359 {
9360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9361 }
9362 return resultobj;
9363 fail:
9364 return NULL;
9365 }
9366
9367
9368 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
9369 PyObject *resultobj = NULL;
9370 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9371 int result;
9372 PyObject * obj0 = 0 ;
9373 char *kwnames[] = {
9374 (char *) "self", NULL
9375 };
9376
9377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
9378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9379 if (SWIG_arg_fail(1)) SWIG_fail;
9380 {
9381 PyThreadState* __tstate = wxPyBeginAllowThreads();
9382 result = (int)((wxPyTimer const *)arg1)->GetId();
9383
9384 wxPyEndAllowThreads(__tstate);
9385 if (PyErr_Occurred()) SWIG_fail;
9386 }
9387 {
9388 resultobj = SWIG_From_int(static_cast<int >(result));
9389 }
9390 return resultobj;
9391 fail:
9392 return NULL;
9393 }
9394
9395
9396 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
9397 PyObject *obj;
9398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9399 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
9400 Py_INCREF(obj);
9401 return Py_BuildValue((char *)"");
9402 }
9403 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
9404 PyObject *resultobj = NULL;
9405 int arg1 = (int) 0 ;
9406 int arg2 = (int) 0 ;
9407 wxTimerEvent *result;
9408 PyObject * obj0 = 0 ;
9409 PyObject * obj1 = 0 ;
9410 char *kwnames[] = {
9411 (char *) "timerid",(char *) "interval", NULL
9412 };
9413
9414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
9415 if (obj0) {
9416 {
9417 arg1 = static_cast<int >(SWIG_As_int(obj0));
9418 if (SWIG_arg_fail(1)) SWIG_fail;
9419 }
9420 }
9421 if (obj1) {
9422 {
9423 arg2 = static_cast<int >(SWIG_As_int(obj1));
9424 if (SWIG_arg_fail(2)) SWIG_fail;
9425 }
9426 }
9427 {
9428 PyThreadState* __tstate = wxPyBeginAllowThreads();
9429 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
9430
9431 wxPyEndAllowThreads(__tstate);
9432 if (PyErr_Occurred()) SWIG_fail;
9433 }
9434 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
9435 return resultobj;
9436 fail:
9437 return NULL;
9438 }
9439
9440
9441 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
9442 PyObject *resultobj = NULL;
9443 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
9444 int result;
9445 PyObject * obj0 = 0 ;
9446 char *kwnames[] = {
9447 (char *) "self", NULL
9448 };
9449
9450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
9451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
9452 if (SWIG_arg_fail(1)) SWIG_fail;
9453 {
9454 PyThreadState* __tstate = wxPyBeginAllowThreads();
9455 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
9456
9457 wxPyEndAllowThreads(__tstate);
9458 if (PyErr_Occurred()) SWIG_fail;
9459 }
9460 {
9461 resultobj = SWIG_From_int(static_cast<int >(result));
9462 }
9463 return resultobj;
9464 fail:
9465 return NULL;
9466 }
9467
9468
9469 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
9470 PyObject *obj;
9471 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9472 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
9473 Py_INCREF(obj);
9474 return Py_BuildValue((char *)"");
9475 }
9476 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
9477 PyObject *resultobj = NULL;
9478 wxTimer *arg1 = 0 ;
9479 wxTimerRunner *result;
9480 PyObject * obj0 = 0 ;
9481
9482 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
9483 {
9484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
9485 if (SWIG_arg_fail(1)) SWIG_fail;
9486 if (arg1 == NULL) {
9487 SWIG_null_ref("wxTimer");
9488 }
9489 if (SWIG_arg_fail(1)) SWIG_fail;
9490 }
9491 {
9492 if (!wxPyCheckForApp()) SWIG_fail;
9493 PyThreadState* __tstate = wxPyBeginAllowThreads();
9494 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
9495
9496 wxPyEndAllowThreads(__tstate);
9497 if (PyErr_Occurred()) SWIG_fail;
9498 }
9499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
9500 return resultobj;
9501 fail:
9502 return NULL;
9503 }
9504
9505
9506 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
9507 PyObject *resultobj = NULL;
9508 wxTimer *arg1 = 0 ;
9509 int arg2 ;
9510 bool arg3 = (bool) false ;
9511 wxTimerRunner *result;
9512 PyObject * obj0 = 0 ;
9513 PyObject * obj1 = 0 ;
9514 PyObject * obj2 = 0 ;
9515
9516 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
9517 {
9518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
9519 if (SWIG_arg_fail(1)) SWIG_fail;
9520 if (arg1 == NULL) {
9521 SWIG_null_ref("wxTimer");
9522 }
9523 if (SWIG_arg_fail(1)) SWIG_fail;
9524 }
9525 {
9526 arg2 = static_cast<int >(SWIG_As_int(obj1));
9527 if (SWIG_arg_fail(2)) SWIG_fail;
9528 }
9529 if (obj2) {
9530 {
9531 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
9532 if (SWIG_arg_fail(3)) SWIG_fail;
9533 }
9534 }
9535 {
9536 if (!wxPyCheckForApp()) SWIG_fail;
9537 PyThreadState* __tstate = wxPyBeginAllowThreads();
9538 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
9539
9540 wxPyEndAllowThreads(__tstate);
9541 if (PyErr_Occurred()) SWIG_fail;
9542 }
9543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
9544 return resultobj;
9545 fail:
9546 return NULL;
9547 }
9548
9549
9550 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
9551 int argc;
9552 PyObject *argv[4];
9553 int ii;
9554
9555 argc = PyObject_Length(args);
9556 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
9557 argv[ii] = PyTuple_GetItem(args,ii);
9558 }
9559 if (argc == 1) {
9560 int _v;
9561 {
9562 void *ptr = 0;
9563 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
9564 _v = 0;
9565 PyErr_Clear();
9566 } else {
9567 _v = (ptr != 0);
9568 }
9569 }
9570 if (_v) {
9571 return _wrap_new_TimerRunner__SWIG_0(self,args);
9572 }
9573 }
9574 if ((argc >= 2) && (argc <= 3)) {
9575 int _v;
9576 {
9577 void *ptr = 0;
9578 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
9579 _v = 0;
9580 PyErr_Clear();
9581 } else {
9582 _v = (ptr != 0);
9583 }
9584 }
9585 if (_v) {
9586 _v = SWIG_Check_int(argv[1]);
9587 if (_v) {
9588 if (argc <= 2) {
9589 return _wrap_new_TimerRunner__SWIG_1(self,args);
9590 }
9591 _v = SWIG_Check_bool(argv[2]);
9592 if (_v) {
9593 return _wrap_new_TimerRunner__SWIG_1(self,args);
9594 }
9595 }
9596 }
9597 }
9598
9599 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
9600 return NULL;
9601 }
9602
9603
9604 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
9605 PyObject *resultobj = NULL;
9606 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
9607 PyObject * obj0 = 0 ;
9608 char *kwnames[] = {
9609 (char *) "self", NULL
9610 };
9611
9612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
9613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
9614 if (SWIG_arg_fail(1)) SWIG_fail;
9615 {
9616 PyThreadState* __tstate = wxPyBeginAllowThreads();
9617 delete arg1;
9618
9619 wxPyEndAllowThreads(__tstate);
9620 if (PyErr_Occurred()) SWIG_fail;
9621 }
9622 Py_INCREF(Py_None); resultobj = Py_None;
9623 return resultobj;
9624 fail:
9625 return NULL;
9626 }
9627
9628
9629 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
9630 PyObject *resultobj = NULL;
9631 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
9632 int arg2 ;
9633 bool arg3 = (bool) false ;
9634 PyObject * obj0 = 0 ;
9635 PyObject * obj1 = 0 ;
9636 PyObject * obj2 = 0 ;
9637 char *kwnames[] = {
9638 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
9639 };
9640
9641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
9642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
9643 if (SWIG_arg_fail(1)) SWIG_fail;
9644 {
9645 arg2 = static_cast<int >(SWIG_As_int(obj1));
9646 if (SWIG_arg_fail(2)) SWIG_fail;
9647 }
9648 if (obj2) {
9649 {
9650 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
9651 if (SWIG_arg_fail(3)) SWIG_fail;
9652 }
9653 }
9654 {
9655 PyThreadState* __tstate = wxPyBeginAllowThreads();
9656 (arg1)->Start(arg2,arg3);
9657
9658 wxPyEndAllowThreads(__tstate);
9659 if (PyErr_Occurred()) SWIG_fail;
9660 }
9661 Py_INCREF(Py_None); resultobj = Py_None;
9662 return resultobj;
9663 fail:
9664 return NULL;
9665 }
9666
9667
9668 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
9669 PyObject *obj;
9670 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9671 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
9672 Py_INCREF(obj);
9673 return Py_BuildValue((char *)"");
9674 }
9675 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
9676 PyObject *resultobj = NULL;
9677 wxLog *result;
9678 char *kwnames[] = {
9679 NULL
9680 };
9681
9682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
9683 {
9684 PyThreadState* __tstate = wxPyBeginAllowThreads();
9685 result = (wxLog *)new wxLog();
9686
9687 wxPyEndAllowThreads(__tstate);
9688 if (PyErr_Occurred()) SWIG_fail;
9689 }
9690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
9691 return resultobj;
9692 fail:
9693 return NULL;
9694 }
9695
9696
9697 static PyObject *_wrap_delete_Log(PyObject *, PyObject *args, PyObject *kwargs) {
9698 PyObject *resultobj = NULL;
9699 wxLog *arg1 = (wxLog *) 0 ;
9700 PyObject * obj0 = 0 ;
9701 char *kwnames[] = {
9702 (char *) "self", NULL
9703 };
9704
9705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Log",kwnames,&obj0)) goto fail;
9706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9707 if (SWIG_arg_fail(1)) SWIG_fail;
9708 {
9709 PyThreadState* __tstate = wxPyBeginAllowThreads();
9710 delete arg1;
9711
9712 wxPyEndAllowThreads(__tstate);
9713 if (PyErr_Occurred()) SWIG_fail;
9714 }
9715 Py_INCREF(Py_None); resultobj = Py_None;
9716 return resultobj;
9717 fail:
9718 return NULL;
9719 }
9720
9721
9722 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
9723 PyObject *resultobj = NULL;
9724 bool result;
9725 char *kwnames[] = {
9726 NULL
9727 };
9728
9729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
9730 {
9731 PyThreadState* __tstate = wxPyBeginAllowThreads();
9732 result = (bool)wxLog::IsEnabled();
9733
9734 wxPyEndAllowThreads(__tstate);
9735 if (PyErr_Occurred()) SWIG_fail;
9736 }
9737 {
9738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9739 }
9740 return resultobj;
9741 fail:
9742 return NULL;
9743 }
9744
9745
9746 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
9747 PyObject *resultobj = NULL;
9748 bool arg1 = (bool) true ;
9749 bool result;
9750 PyObject * obj0 = 0 ;
9751 char *kwnames[] = {
9752 (char *) "doIt", NULL
9753 };
9754
9755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
9756 if (obj0) {
9757 {
9758 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
9759 if (SWIG_arg_fail(1)) SWIG_fail;
9760 }
9761 }
9762 {
9763 PyThreadState* __tstate = wxPyBeginAllowThreads();
9764 result = (bool)wxLog::EnableLogging(arg1);
9765
9766 wxPyEndAllowThreads(__tstate);
9767 if (PyErr_Occurred()) SWIG_fail;
9768 }
9769 {
9770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9771 }
9772 return resultobj;
9773 fail:
9774 return NULL;
9775 }
9776
9777
9778 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
9779 PyObject *resultobj = NULL;
9780 wxLogLevel arg1 ;
9781 wxChar *arg2 = (wxChar *) 0 ;
9782 time_t arg3 ;
9783 PyObject * obj0 = 0 ;
9784 PyObject * obj1 = 0 ;
9785 PyObject * obj2 = 0 ;
9786 char *kwnames[] = {
9787 (char *) "level",(char *) "szString",(char *) "t", NULL
9788 };
9789
9790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
9791 {
9792 arg1 = static_cast<wxLogLevel >(SWIG_As_unsigned_SS_long(obj0));
9793 if (SWIG_arg_fail(1)) SWIG_fail;
9794 }
9795 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9796 if (SWIG_arg_fail(2)) SWIG_fail;
9797 {
9798 arg3 = static_cast<time_t >(SWIG_As_unsigned_SS_int(obj2));
9799 if (SWIG_arg_fail(3)) SWIG_fail;
9800 }
9801 {
9802 PyThreadState* __tstate = wxPyBeginAllowThreads();
9803 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
9804
9805 wxPyEndAllowThreads(__tstate);
9806 if (PyErr_Occurred()) SWIG_fail;
9807 }
9808 Py_INCREF(Py_None); resultobj = Py_None;
9809 return resultobj;
9810 fail:
9811 return NULL;
9812 }
9813
9814
9815 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
9816 PyObject *resultobj = NULL;
9817 wxLog *arg1 = (wxLog *) 0 ;
9818 PyObject * obj0 = 0 ;
9819 char *kwnames[] = {
9820 (char *) "self", NULL
9821 };
9822
9823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
9824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9825 if (SWIG_arg_fail(1)) SWIG_fail;
9826 {
9827 PyThreadState* __tstate = wxPyBeginAllowThreads();
9828 (arg1)->Flush();
9829
9830 wxPyEndAllowThreads(__tstate);
9831 if (PyErr_Occurred()) SWIG_fail;
9832 }
9833 Py_INCREF(Py_None); resultobj = Py_None;
9834 return resultobj;
9835 fail:
9836 return NULL;
9837 }
9838
9839
9840 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9841 PyObject *resultobj = NULL;
9842 char *kwnames[] = {
9843 NULL
9844 };
9845
9846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9847 {
9848 PyThreadState* __tstate = wxPyBeginAllowThreads();
9849 wxLog::FlushActive();
9850
9851 wxPyEndAllowThreads(__tstate);
9852 if (PyErr_Occurred()) SWIG_fail;
9853 }
9854 Py_INCREF(Py_None); resultobj = Py_None;
9855 return resultobj;
9856 fail:
9857 return NULL;
9858 }
9859
9860
9861 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9862 PyObject *resultobj = NULL;
9863 wxLog *result;
9864 char *kwnames[] = {
9865 NULL
9866 };
9867
9868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9869 {
9870 PyThreadState* __tstate = wxPyBeginAllowThreads();
9871 result = (wxLog *)wxLog::GetActiveTarget();
9872
9873 wxPyEndAllowThreads(__tstate);
9874 if (PyErr_Occurred()) SWIG_fail;
9875 }
9876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9877 return resultobj;
9878 fail:
9879 return NULL;
9880 }
9881
9882
9883 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9884 PyObject *resultobj = NULL;
9885 wxLog *arg1 = (wxLog *) 0 ;
9886 wxLog *result;
9887 PyObject * obj0 = 0 ;
9888 char *kwnames[] = {
9889 (char *) "pLogger", NULL
9890 };
9891
9892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
9894 if (SWIG_arg_fail(1)) SWIG_fail;
9895 {
9896 PyThreadState* __tstate = wxPyBeginAllowThreads();
9897 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9898
9899 wxPyEndAllowThreads(__tstate);
9900 if (PyErr_Occurred()) SWIG_fail;
9901 }
9902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
9903 return resultobj;
9904 fail:
9905 return NULL;
9906 }
9907
9908
9909 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9910 PyObject *resultobj = NULL;
9911 char *kwnames[] = {
9912 NULL
9913 };
9914
9915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9916 {
9917 PyThreadState* __tstate = wxPyBeginAllowThreads();
9918 wxLog::Suspend();
9919
9920 wxPyEndAllowThreads(__tstate);
9921 if (PyErr_Occurred()) SWIG_fail;
9922 }
9923 Py_INCREF(Py_None); resultobj = Py_None;
9924 return resultobj;
9925 fail:
9926 return NULL;
9927 }
9928
9929
9930 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9931 PyObject *resultobj = NULL;
9932 char *kwnames[] = {
9933 NULL
9934 };
9935
9936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9937 {
9938 PyThreadState* __tstate = wxPyBeginAllowThreads();
9939 wxLog::Resume();
9940
9941 wxPyEndAllowThreads(__tstate);
9942 if (PyErr_Occurred()) SWIG_fail;
9943 }
9944 Py_INCREF(Py_None); resultobj = Py_None;
9945 return resultobj;
9946 fail:
9947 return NULL;
9948 }
9949
9950
9951 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9952 PyObject *resultobj = NULL;
9953 bool arg1 = (bool) true ;
9954 PyObject * obj0 = 0 ;
9955 char *kwnames[] = {
9956 (char *) "bVerbose", NULL
9957 };
9958
9959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9960 if (obj0) {
9961 {
9962 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
9963 if (SWIG_arg_fail(1)) SWIG_fail;
9964 }
9965 }
9966 {
9967 PyThreadState* __tstate = wxPyBeginAllowThreads();
9968 wxLog::SetVerbose(arg1);
9969
9970 wxPyEndAllowThreads(__tstate);
9971 if (PyErr_Occurred()) SWIG_fail;
9972 }
9973 Py_INCREF(Py_None); resultobj = Py_None;
9974 return resultobj;
9975 fail:
9976 return NULL;
9977 }
9978
9979
9980 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9981 PyObject *resultobj = NULL;
9982 wxLogLevel arg1 ;
9983 PyObject * obj0 = 0 ;
9984 char *kwnames[] = {
9985 (char *) "logLevel", NULL
9986 };
9987
9988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9989 {
9990 arg1 = static_cast<wxLogLevel >(SWIG_As_unsigned_SS_long(obj0));
9991 if (SWIG_arg_fail(1)) SWIG_fail;
9992 }
9993 {
9994 PyThreadState* __tstate = wxPyBeginAllowThreads();
9995 wxLog::SetLogLevel(arg1);
9996
9997 wxPyEndAllowThreads(__tstate);
9998 if (PyErr_Occurred()) SWIG_fail;
9999 }
10000 Py_INCREF(Py_None); resultobj = Py_None;
10001 return resultobj;
10002 fail:
10003 return NULL;
10004 }
10005
10006
10007 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
10008 PyObject *resultobj = NULL;
10009 char *kwnames[] = {
10010 NULL
10011 };
10012
10013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
10014 {
10015 PyThreadState* __tstate = wxPyBeginAllowThreads();
10016 wxLog::DontCreateOnDemand();
10017
10018 wxPyEndAllowThreads(__tstate);
10019 if (PyErr_Occurred()) SWIG_fail;
10020 }
10021 Py_INCREF(Py_None); resultobj = Py_None;
10022 return resultobj;
10023 fail:
10024 return NULL;
10025 }
10026
10027
10028 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10029 PyObject *resultobj = NULL;
10030 wxTraceMask arg1 ;
10031 PyObject * obj0 = 0 ;
10032 char *kwnames[] = {
10033 (char *) "ulMask", NULL
10034 };
10035
10036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
10037 {
10038 arg1 = static_cast<wxTraceMask >(SWIG_As_unsigned_SS_long(obj0));
10039 if (SWIG_arg_fail(1)) SWIG_fail;
10040 }
10041 {
10042 PyThreadState* __tstate = wxPyBeginAllowThreads();
10043 wxLog::SetTraceMask(arg1);
10044
10045 wxPyEndAllowThreads(__tstate);
10046 if (PyErr_Occurred()) SWIG_fail;
10047 }
10048 Py_INCREF(Py_None); resultobj = Py_None;
10049 return resultobj;
10050 fail:
10051 return NULL;
10052 }
10053
10054
10055 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10056 PyObject *resultobj = NULL;
10057 wxString *arg1 = 0 ;
10058 bool temp1 = false ;
10059 PyObject * obj0 = 0 ;
10060 char *kwnames[] = {
10061 (char *) "str", NULL
10062 };
10063
10064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
10065 {
10066 arg1 = wxString_in_helper(obj0);
10067 if (arg1 == NULL) SWIG_fail;
10068 temp1 = true;
10069 }
10070 {
10071 PyThreadState* __tstate = wxPyBeginAllowThreads();
10072 wxLog::AddTraceMask((wxString const &)*arg1);
10073
10074 wxPyEndAllowThreads(__tstate);
10075 if (PyErr_Occurred()) SWIG_fail;
10076 }
10077 Py_INCREF(Py_None); resultobj = Py_None;
10078 {
10079 if (temp1)
10080 delete arg1;
10081 }
10082 return resultobj;
10083 fail:
10084 {
10085 if (temp1)
10086 delete arg1;
10087 }
10088 return NULL;
10089 }
10090
10091
10092 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10093 PyObject *resultobj = NULL;
10094 wxString *arg1 = 0 ;
10095 bool temp1 = false ;
10096 PyObject * obj0 = 0 ;
10097 char *kwnames[] = {
10098 (char *) "str", NULL
10099 };
10100
10101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
10102 {
10103 arg1 = wxString_in_helper(obj0);
10104 if (arg1 == NULL) SWIG_fail;
10105 temp1 = true;
10106 }
10107 {
10108 PyThreadState* __tstate = wxPyBeginAllowThreads();
10109 wxLog::RemoveTraceMask((wxString const &)*arg1);
10110
10111 wxPyEndAllowThreads(__tstate);
10112 if (PyErr_Occurred()) SWIG_fail;
10113 }
10114 Py_INCREF(Py_None); resultobj = Py_None;
10115 {
10116 if (temp1)
10117 delete arg1;
10118 }
10119 return resultobj;
10120 fail:
10121 {
10122 if (temp1)
10123 delete arg1;
10124 }
10125 return NULL;
10126 }
10127
10128
10129 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
10130 PyObject *resultobj = NULL;
10131 char *kwnames[] = {
10132 NULL
10133 };
10134
10135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
10136 {
10137 PyThreadState* __tstate = wxPyBeginAllowThreads();
10138 wxLog::ClearTraceMasks();
10139
10140 wxPyEndAllowThreads(__tstate);
10141 if (PyErr_Occurred()) SWIG_fail;
10142 }
10143 Py_INCREF(Py_None); resultobj = Py_None;
10144 return resultobj;
10145 fail:
10146 return NULL;
10147 }
10148
10149
10150 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
10151 PyObject *resultobj = NULL;
10152 wxArrayString *result;
10153 char *kwnames[] = {
10154 NULL
10155 };
10156
10157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
10158 {
10159 PyThreadState* __tstate = wxPyBeginAllowThreads();
10160 {
10161 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
10162 result = (wxArrayString *) &_result_ref;
10163 }
10164
10165 wxPyEndAllowThreads(__tstate);
10166 if (PyErr_Occurred()) SWIG_fail;
10167 }
10168 {
10169 resultobj = wxArrayString2PyList_helper(*result);
10170 }
10171 return resultobj;
10172 fail:
10173 return NULL;
10174 }
10175
10176
10177 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
10178 PyObject *resultobj = NULL;
10179 wxChar *arg1 = (wxChar *) 0 ;
10180 PyObject * obj0 = 0 ;
10181 char *kwnames[] = {
10182 (char *) "ts", NULL
10183 };
10184
10185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
10186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
10187 if (SWIG_arg_fail(1)) SWIG_fail;
10188 {
10189 PyThreadState* __tstate = wxPyBeginAllowThreads();
10190 wxLog::SetTimestamp((wxChar const *)arg1);
10191
10192 wxPyEndAllowThreads(__tstate);
10193 if (PyErr_Occurred()) SWIG_fail;
10194 }
10195 Py_INCREF(Py_None); resultobj = Py_None;
10196 return resultobj;
10197 fail:
10198 return NULL;
10199 }
10200
10201
10202 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10203 PyObject *resultobj = NULL;
10204 bool result;
10205 char *kwnames[] = {
10206 NULL
10207 };
10208
10209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
10210 {
10211 PyThreadState* __tstate = wxPyBeginAllowThreads();
10212 result = (bool)wxLog::GetVerbose();
10213
10214 wxPyEndAllowThreads(__tstate);
10215 if (PyErr_Occurred()) SWIG_fail;
10216 }
10217 {
10218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10219 }
10220 return resultobj;
10221 fail:
10222 return NULL;
10223 }
10224
10225
10226 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10227 PyObject *resultobj = NULL;
10228 wxTraceMask result;
10229 char *kwnames[] = {
10230 NULL
10231 };
10232
10233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
10234 {
10235 PyThreadState* __tstate = wxPyBeginAllowThreads();
10236 result = (wxTraceMask)wxLog::GetTraceMask();
10237
10238 wxPyEndAllowThreads(__tstate);
10239 if (PyErr_Occurred()) SWIG_fail;
10240 }
10241 {
10242 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10243 }
10244 return resultobj;
10245 fail:
10246 return NULL;
10247 }
10248
10249
10250 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10251 PyObject *resultobj = NULL;
10252 wxChar *arg1 = (wxChar *) 0 ;
10253 bool result;
10254 PyObject * obj0 = 0 ;
10255 char *kwnames[] = {
10256 (char *) "mask", NULL
10257 };
10258
10259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
10260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
10261 if (SWIG_arg_fail(1)) SWIG_fail;
10262 {
10263 PyThreadState* __tstate = wxPyBeginAllowThreads();
10264 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
10265
10266 wxPyEndAllowThreads(__tstate);
10267 if (PyErr_Occurred()) SWIG_fail;
10268 }
10269 {
10270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10271 }
10272 return resultobj;
10273 fail:
10274 return NULL;
10275 }
10276
10277
10278 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
10279 PyObject *resultobj = NULL;
10280 wxLogLevel result;
10281 char *kwnames[] = {
10282 NULL
10283 };
10284
10285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
10286 {
10287 PyThreadState* __tstate = wxPyBeginAllowThreads();
10288 result = (wxLogLevel)wxLog::GetLogLevel();
10289
10290 wxPyEndAllowThreads(__tstate);
10291 if (PyErr_Occurred()) SWIG_fail;
10292 }
10293 {
10294 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10295 }
10296 return resultobj;
10297 fail:
10298 return NULL;
10299 }
10300
10301
10302 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
10303 PyObject *resultobj = NULL;
10304 wxChar *result;
10305 char *kwnames[] = {
10306 NULL
10307 };
10308
10309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
10310 {
10311 PyThreadState* __tstate = wxPyBeginAllowThreads();
10312 result = (wxChar *)wxLog::GetTimestamp();
10313
10314 wxPyEndAllowThreads(__tstate);
10315 if (PyErr_Occurred()) SWIG_fail;
10316 }
10317 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
10318 return resultobj;
10319 fail:
10320 return NULL;
10321 }
10322
10323
10324 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
10325 PyObject *resultobj = NULL;
10326 wxString result;
10327 char *kwnames[] = {
10328 NULL
10329 };
10330
10331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
10332 {
10333 PyThreadState* __tstate = wxPyBeginAllowThreads();
10334 result = wxLog_TimeStamp();
10335
10336 wxPyEndAllowThreads(__tstate);
10337 if (PyErr_Occurred()) SWIG_fail;
10338 }
10339 {
10340 #if wxUSE_UNICODE
10341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10342 #else
10343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10344 #endif
10345 }
10346 return resultobj;
10347 fail:
10348 return NULL;
10349 }
10350
10351
10352 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10353 PyObject *resultobj = NULL;
10354 wxLog *arg1 = (wxLog *) 0 ;
10355 PyObject * obj0 = 0 ;
10356 char *kwnames[] = {
10357 (char *) "self", NULL
10358 };
10359
10360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
10361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
10362 if (SWIG_arg_fail(1)) SWIG_fail;
10363 {
10364 PyThreadState* __tstate = wxPyBeginAllowThreads();
10365 wxLog_Destroy(arg1);
10366
10367 wxPyEndAllowThreads(__tstate);
10368 if (PyErr_Occurred()) SWIG_fail;
10369 }
10370 Py_INCREF(Py_None); resultobj = Py_None;
10371 return resultobj;
10372 fail:
10373 return NULL;
10374 }
10375
10376
10377 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
10378 PyObject *obj;
10379 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10380 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
10381 Py_INCREF(obj);
10382 return Py_BuildValue((char *)"");
10383 }
10384 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
10385 PyObject *resultobj = NULL;
10386 wxLogStderr *result;
10387 char *kwnames[] = {
10388 NULL
10389 };
10390
10391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
10392 {
10393 PyThreadState* __tstate = wxPyBeginAllowThreads();
10394 result = (wxLogStderr *)new wxLogStderr();
10395
10396 wxPyEndAllowThreads(__tstate);
10397 if (PyErr_Occurred()) SWIG_fail;
10398 }
10399 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
10400 return resultobj;
10401 fail:
10402 return NULL;
10403 }
10404
10405
10406 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
10407 PyObject *obj;
10408 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10409 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
10410 Py_INCREF(obj);
10411 return Py_BuildValue((char *)"");
10412 }
10413 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
10414 PyObject *resultobj = NULL;
10415 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10416 wxLogTextCtrl *result;
10417 PyObject * obj0 = 0 ;
10418 char *kwnames[] = {
10419 (char *) "pTextCtrl", NULL
10420 };
10421
10422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
10423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10424 if (SWIG_arg_fail(1)) SWIG_fail;
10425 {
10426 PyThreadState* __tstate = wxPyBeginAllowThreads();
10427 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
10428
10429 wxPyEndAllowThreads(__tstate);
10430 if (PyErr_Occurred()) SWIG_fail;
10431 }
10432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
10433 return resultobj;
10434 fail:
10435 return NULL;
10436 }
10437
10438
10439 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
10440 PyObject *obj;
10441 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10442 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
10443 Py_INCREF(obj);
10444 return Py_BuildValue((char *)"");
10445 }
10446 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
10447 PyObject *resultobj = NULL;
10448 wxLogGui *result;
10449 char *kwnames[] = {
10450 NULL
10451 };
10452
10453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
10454 {
10455 PyThreadState* __tstate = wxPyBeginAllowThreads();
10456 result = (wxLogGui *)new wxLogGui();
10457
10458 wxPyEndAllowThreads(__tstate);
10459 if (PyErr_Occurred()) SWIG_fail;
10460 }
10461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
10462 return resultobj;
10463 fail:
10464 return NULL;
10465 }
10466
10467
10468 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
10469 PyObject *obj;
10470 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10471 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
10472 Py_INCREF(obj);
10473 return Py_BuildValue((char *)"");
10474 }
10475 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10476 PyObject *resultobj = NULL;
10477 wxFrame *arg1 = (wxFrame *) 0 ;
10478 wxString *arg2 = 0 ;
10479 bool arg3 = (bool) true ;
10480 bool arg4 = (bool) true ;
10481 wxLogWindow *result;
10482 bool temp2 = false ;
10483 PyObject * obj0 = 0 ;
10484 PyObject * obj1 = 0 ;
10485 PyObject * obj2 = 0 ;
10486 PyObject * obj3 = 0 ;
10487 char *kwnames[] = {
10488 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
10489 };
10490
10491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10493 if (SWIG_arg_fail(1)) SWIG_fail;
10494 {
10495 arg2 = wxString_in_helper(obj1);
10496 if (arg2 == NULL) SWIG_fail;
10497 temp2 = true;
10498 }
10499 if (obj2) {
10500 {
10501 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
10502 if (SWIG_arg_fail(3)) SWIG_fail;
10503 }
10504 }
10505 if (obj3) {
10506 {
10507 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
10508 if (SWIG_arg_fail(4)) SWIG_fail;
10509 }
10510 }
10511 {
10512 PyThreadState* __tstate = wxPyBeginAllowThreads();
10513 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
10514
10515 wxPyEndAllowThreads(__tstate);
10516 if (PyErr_Occurred()) SWIG_fail;
10517 }
10518 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
10519 {
10520 if (temp2)
10521 delete arg2;
10522 }
10523 return resultobj;
10524 fail:
10525 {
10526 if (temp2)
10527 delete arg2;
10528 }
10529 return NULL;
10530 }
10531
10532
10533 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
10534 PyObject *resultobj = NULL;
10535 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10536 bool arg2 = (bool) true ;
10537 PyObject * obj0 = 0 ;
10538 PyObject * obj1 = 0 ;
10539 char *kwnames[] = {
10540 (char *) "self",(char *) "bShow", NULL
10541 };
10542
10543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
10544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10545 if (SWIG_arg_fail(1)) SWIG_fail;
10546 if (obj1) {
10547 {
10548 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
10549 if (SWIG_arg_fail(2)) SWIG_fail;
10550 }
10551 }
10552 {
10553 PyThreadState* __tstate = wxPyBeginAllowThreads();
10554 (arg1)->Show(arg2);
10555
10556 wxPyEndAllowThreads(__tstate);
10557 if (PyErr_Occurred()) SWIG_fail;
10558 }
10559 Py_INCREF(Py_None); resultobj = Py_None;
10560 return resultobj;
10561 fail:
10562 return NULL;
10563 }
10564
10565
10566 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10567 PyObject *resultobj = NULL;
10568 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10569 wxFrame *result;
10570 PyObject * obj0 = 0 ;
10571 char *kwnames[] = {
10572 (char *) "self", NULL
10573 };
10574
10575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
10576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10577 if (SWIG_arg_fail(1)) SWIG_fail;
10578 {
10579 PyThreadState* __tstate = wxPyBeginAllowThreads();
10580 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
10581
10582 wxPyEndAllowThreads(__tstate);
10583 if (PyErr_Occurred()) SWIG_fail;
10584 }
10585 {
10586 resultobj = wxPyMake_wxObject(result, (bool)0);
10587 }
10588 return resultobj;
10589 fail:
10590 return NULL;
10591 }
10592
10593
10594 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10595 PyObject *resultobj = NULL;
10596 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10597 wxLog *result;
10598 PyObject * obj0 = 0 ;
10599 char *kwnames[] = {
10600 (char *) "self", NULL
10601 };
10602
10603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
10604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10605 if (SWIG_arg_fail(1)) SWIG_fail;
10606 {
10607 PyThreadState* __tstate = wxPyBeginAllowThreads();
10608 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
10609
10610 wxPyEndAllowThreads(__tstate);
10611 if (PyErr_Occurred()) SWIG_fail;
10612 }
10613 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10614 return resultobj;
10615 fail:
10616 return NULL;
10617 }
10618
10619
10620 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
10621 PyObject *resultobj = NULL;
10622 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10623 bool result;
10624 PyObject * obj0 = 0 ;
10625 char *kwnames[] = {
10626 (char *) "self", NULL
10627 };
10628
10629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
10630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10631 if (SWIG_arg_fail(1)) SWIG_fail;
10632 {
10633 PyThreadState* __tstate = wxPyBeginAllowThreads();
10634 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
10635
10636 wxPyEndAllowThreads(__tstate);
10637 if (PyErr_Occurred()) SWIG_fail;
10638 }
10639 {
10640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10641 }
10642 return resultobj;
10643 fail:
10644 return NULL;
10645 }
10646
10647
10648 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
10649 PyObject *resultobj = NULL;
10650 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10651 bool arg2 ;
10652 PyObject * obj0 = 0 ;
10653 PyObject * obj1 = 0 ;
10654 char *kwnames[] = {
10655 (char *) "self",(char *) "bDoPass", NULL
10656 };
10657
10658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
10659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10660 if (SWIG_arg_fail(1)) SWIG_fail;
10661 {
10662 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
10663 if (SWIG_arg_fail(2)) SWIG_fail;
10664 }
10665 {
10666 PyThreadState* __tstate = wxPyBeginAllowThreads();
10667 (arg1)->PassMessages(arg2);
10668
10669 wxPyEndAllowThreads(__tstate);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 Py_INCREF(Py_None); resultobj = Py_None;
10673 return resultobj;
10674 fail:
10675 return NULL;
10676 }
10677
10678
10679 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
10680 PyObject *obj;
10681 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10682 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
10683 Py_INCREF(obj);
10684 return Py_BuildValue((char *)"");
10685 }
10686 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
10687 PyObject *resultobj = NULL;
10688 wxLog *arg1 = (wxLog *) 0 ;
10689 wxLogChain *result;
10690 PyObject * obj0 = 0 ;
10691 char *kwnames[] = {
10692 (char *) "logger", NULL
10693 };
10694
10695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
10696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
10697 if (SWIG_arg_fail(1)) SWIG_fail;
10698 {
10699 PyThreadState* __tstate = wxPyBeginAllowThreads();
10700 result = (wxLogChain *)new wxLogChain(arg1);
10701
10702 wxPyEndAllowThreads(__tstate);
10703 if (PyErr_Occurred()) SWIG_fail;
10704 }
10705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
10706 return resultobj;
10707 fail:
10708 return NULL;
10709 }
10710
10711
10712 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
10713 PyObject *resultobj = NULL;
10714 wxLogChain *arg1 = (wxLogChain *) 0 ;
10715 wxLog *arg2 = (wxLog *) 0 ;
10716 PyObject * obj0 = 0 ;
10717 PyObject * obj1 = 0 ;
10718 char *kwnames[] = {
10719 (char *) "self",(char *) "logger", NULL
10720 };
10721
10722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
10723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10724 if (SWIG_arg_fail(1)) SWIG_fail;
10725 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
10726 if (SWIG_arg_fail(2)) SWIG_fail;
10727 {
10728 PyThreadState* __tstate = wxPyBeginAllowThreads();
10729 (arg1)->SetLog(arg2);
10730
10731 wxPyEndAllowThreads(__tstate);
10732 if (PyErr_Occurred()) SWIG_fail;
10733 }
10734 Py_INCREF(Py_None); resultobj = Py_None;
10735 return resultobj;
10736 fail:
10737 return NULL;
10738 }
10739
10740
10741 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
10742 PyObject *resultobj = NULL;
10743 wxLogChain *arg1 = (wxLogChain *) 0 ;
10744 bool arg2 ;
10745 PyObject * obj0 = 0 ;
10746 PyObject * obj1 = 0 ;
10747 char *kwnames[] = {
10748 (char *) "self",(char *) "bDoPass", NULL
10749 };
10750
10751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
10752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10753 if (SWIG_arg_fail(1)) SWIG_fail;
10754 {
10755 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
10756 if (SWIG_arg_fail(2)) SWIG_fail;
10757 }
10758 {
10759 PyThreadState* __tstate = wxPyBeginAllowThreads();
10760 (arg1)->PassMessages(arg2);
10761
10762 wxPyEndAllowThreads(__tstate);
10763 if (PyErr_Occurred()) SWIG_fail;
10764 }
10765 Py_INCREF(Py_None); resultobj = Py_None;
10766 return resultobj;
10767 fail:
10768 return NULL;
10769 }
10770
10771
10772 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
10773 PyObject *resultobj = NULL;
10774 wxLogChain *arg1 = (wxLogChain *) 0 ;
10775 bool result;
10776 PyObject * obj0 = 0 ;
10777 char *kwnames[] = {
10778 (char *) "self", NULL
10779 };
10780
10781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
10782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10783 if (SWIG_arg_fail(1)) SWIG_fail;
10784 {
10785 PyThreadState* __tstate = wxPyBeginAllowThreads();
10786 result = (bool)(arg1)->IsPassingMessages();
10787
10788 wxPyEndAllowThreads(__tstate);
10789 if (PyErr_Occurred()) SWIG_fail;
10790 }
10791 {
10792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10793 }
10794 return resultobj;
10795 fail:
10796 return NULL;
10797 }
10798
10799
10800 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10801 PyObject *resultobj = NULL;
10802 wxLogChain *arg1 = (wxLogChain *) 0 ;
10803 wxLog *result;
10804 PyObject * obj0 = 0 ;
10805 char *kwnames[] = {
10806 (char *) "self", NULL
10807 };
10808
10809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
10810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10811 if (SWIG_arg_fail(1)) SWIG_fail;
10812 {
10813 PyThreadState* __tstate = wxPyBeginAllowThreads();
10814 result = (wxLog *)(arg1)->GetOldLog();
10815
10816 wxPyEndAllowThreads(__tstate);
10817 if (PyErr_Occurred()) SWIG_fail;
10818 }
10819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10820 return resultobj;
10821 fail:
10822 return NULL;
10823 }
10824
10825
10826 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
10827 PyObject *obj;
10828 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10829 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
10830 Py_INCREF(obj);
10831 return Py_BuildValue((char *)"");
10832 }
10833 static PyObject *_wrap_new_LogBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
10834 PyObject *resultobj = NULL;
10835 wxLogBuffer *result;
10836 char *kwnames[] = {
10837 NULL
10838 };
10839
10840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogBuffer",kwnames)) goto fail;
10841 {
10842 PyThreadState* __tstate = wxPyBeginAllowThreads();
10843 result = (wxLogBuffer *)new wxLogBuffer();
10844
10845 wxPyEndAllowThreads(__tstate);
10846 if (PyErr_Occurred()) SWIG_fail;
10847 }
10848 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogBuffer, 1);
10849 return resultobj;
10850 fail:
10851 return NULL;
10852 }
10853
10854
10855 static PyObject *_wrap_LogBuffer_GetBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
10856 PyObject *resultobj = NULL;
10857 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
10858 wxString *result;
10859 PyObject * obj0 = 0 ;
10860 char *kwnames[] = {
10861 (char *) "self", NULL
10862 };
10863
10864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogBuffer_GetBuffer",kwnames,&obj0)) goto fail;
10865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_EXCEPTION | 0);
10866 if (SWIG_arg_fail(1)) SWIG_fail;
10867 {
10868 PyThreadState* __tstate = wxPyBeginAllowThreads();
10869 {
10870 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
10871 result = (wxString *) &_result_ref;
10872 }
10873
10874 wxPyEndAllowThreads(__tstate);
10875 if (PyErr_Occurred()) SWIG_fail;
10876 }
10877 {
10878 #if wxUSE_UNICODE
10879 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10880 #else
10881 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10882 #endif
10883 }
10884 return resultobj;
10885 fail:
10886 return NULL;
10887 }
10888
10889
10890 static PyObject *_wrap_LogBuffer_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
10891 PyObject *resultobj = NULL;
10892 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
10893 PyObject * obj0 = 0 ;
10894 char *kwnames[] = {
10895 (char *) "self", NULL
10896 };
10897
10898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogBuffer_Flush",kwnames,&obj0)) goto fail;
10899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_EXCEPTION | 0);
10900 if (SWIG_arg_fail(1)) SWIG_fail;
10901 {
10902 PyThreadState* __tstate = wxPyBeginAllowThreads();
10903 (arg1)->Flush();
10904
10905 wxPyEndAllowThreads(__tstate);
10906 if (PyErr_Occurred()) SWIG_fail;
10907 }
10908 Py_INCREF(Py_None); resultobj = Py_None;
10909 return resultobj;
10910 fail:
10911 return NULL;
10912 }
10913
10914
10915 static PyObject * LogBuffer_swigregister(PyObject *, PyObject *args) {
10916 PyObject *obj;
10917 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10918 SWIG_TypeClientData(SWIGTYPE_p_wxLogBuffer, obj);
10919 Py_INCREF(obj);
10920 return Py_BuildValue((char *)"");
10921 }
10922 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10923 PyObject *resultobj = NULL;
10924 unsigned long result;
10925 char *kwnames[] = {
10926 NULL
10927 };
10928
10929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10930 {
10931 PyThreadState* __tstate = wxPyBeginAllowThreads();
10932 result = (unsigned long)wxSysErrorCode();
10933
10934 wxPyEndAllowThreads(__tstate);
10935 if (PyErr_Occurred()) SWIG_fail;
10936 }
10937 {
10938 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10939 }
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10947 PyObject *resultobj = NULL;
10948 unsigned long arg1 = (unsigned long) 0 ;
10949 wxString result;
10950 PyObject * obj0 = 0 ;
10951 char *kwnames[] = {
10952 (char *) "nErrCode", NULL
10953 };
10954
10955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10956 if (obj0) {
10957 {
10958 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
10959 if (SWIG_arg_fail(1)) SWIG_fail;
10960 }
10961 }
10962 {
10963 PyThreadState* __tstate = wxPyBeginAllowThreads();
10964 result = wxSysErrorMsg(arg1);
10965
10966 wxPyEndAllowThreads(__tstate);
10967 if (PyErr_Occurred()) SWIG_fail;
10968 }
10969 {
10970 #if wxUSE_UNICODE
10971 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10972 #else
10973 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10974 #endif
10975 }
10976 return resultobj;
10977 fail:
10978 return NULL;
10979 }
10980
10981
10982 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10983 PyObject *resultobj = NULL;
10984 wxString *arg1 = 0 ;
10985 bool temp1 = false ;
10986 PyObject * obj0 = 0 ;
10987 char *kwnames[] = {
10988 (char *) "msg", NULL
10989 };
10990
10991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10992 {
10993 arg1 = wxString_in_helper(obj0);
10994 if (arg1 == NULL) SWIG_fail;
10995 temp1 = true;
10996 }
10997 {
10998 PyThreadState* __tstate = wxPyBeginAllowThreads();
10999 wxPyLogFatalError((wxString const &)*arg1);
11000
11001 wxPyEndAllowThreads(__tstate);
11002 if (PyErr_Occurred()) SWIG_fail;
11003 }
11004 Py_INCREF(Py_None); resultobj = Py_None;
11005 {
11006 if (temp1)
11007 delete arg1;
11008 }
11009 return resultobj;
11010 fail:
11011 {
11012 if (temp1)
11013 delete arg1;
11014 }
11015 return NULL;
11016 }
11017
11018
11019 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
11020 PyObject *resultobj = NULL;
11021 wxString *arg1 = 0 ;
11022 bool temp1 = false ;
11023 PyObject * obj0 = 0 ;
11024 char *kwnames[] = {
11025 (char *) "msg", NULL
11026 };
11027
11028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
11029 {
11030 arg1 = wxString_in_helper(obj0);
11031 if (arg1 == NULL) SWIG_fail;
11032 temp1 = true;
11033 }
11034 {
11035 PyThreadState* __tstate = wxPyBeginAllowThreads();
11036 wxPyLogError((wxString const &)*arg1);
11037
11038 wxPyEndAllowThreads(__tstate);
11039 if (PyErr_Occurred()) SWIG_fail;
11040 }
11041 Py_INCREF(Py_None); resultobj = Py_None;
11042 {
11043 if (temp1)
11044 delete arg1;
11045 }
11046 return resultobj;
11047 fail:
11048 {
11049 if (temp1)
11050 delete arg1;
11051 }
11052 return NULL;
11053 }
11054
11055
11056 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
11057 PyObject *resultobj = NULL;
11058 wxString *arg1 = 0 ;
11059 bool temp1 = false ;
11060 PyObject * obj0 = 0 ;
11061 char *kwnames[] = {
11062 (char *) "msg", NULL
11063 };
11064
11065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
11066 {
11067 arg1 = wxString_in_helper(obj0);
11068 if (arg1 == NULL) SWIG_fail;
11069 temp1 = true;
11070 }
11071 {
11072 PyThreadState* __tstate = wxPyBeginAllowThreads();
11073 wxPyLogWarning((wxString const &)*arg1);
11074
11075 wxPyEndAllowThreads(__tstate);
11076 if (PyErr_Occurred()) SWIG_fail;
11077 }
11078 Py_INCREF(Py_None); resultobj = Py_None;
11079 {
11080 if (temp1)
11081 delete arg1;
11082 }
11083 return resultobj;
11084 fail:
11085 {
11086 if (temp1)
11087 delete arg1;
11088 }
11089 return NULL;
11090 }
11091
11092
11093 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
11094 PyObject *resultobj = NULL;
11095 wxString *arg1 = 0 ;
11096 bool temp1 = false ;
11097 PyObject * obj0 = 0 ;
11098 char *kwnames[] = {
11099 (char *) "msg", NULL
11100 };
11101
11102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
11103 {
11104 arg1 = wxString_in_helper(obj0);
11105 if (arg1 == NULL) SWIG_fail;
11106 temp1 = true;
11107 }
11108 {
11109 PyThreadState* __tstate = wxPyBeginAllowThreads();
11110 wxPyLogMessage((wxString const &)*arg1);
11111
11112 wxPyEndAllowThreads(__tstate);
11113 if (PyErr_Occurred()) SWIG_fail;
11114 }
11115 Py_INCREF(Py_None); resultobj = Py_None;
11116 {
11117 if (temp1)
11118 delete arg1;
11119 }
11120 return resultobj;
11121 fail:
11122 {
11123 if (temp1)
11124 delete arg1;
11125 }
11126 return NULL;
11127 }
11128
11129
11130 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11131 PyObject *resultobj = NULL;
11132 wxString *arg1 = 0 ;
11133 bool temp1 = false ;
11134 PyObject * obj0 = 0 ;
11135 char *kwnames[] = {
11136 (char *) "msg", NULL
11137 };
11138
11139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
11140 {
11141 arg1 = wxString_in_helper(obj0);
11142 if (arg1 == NULL) SWIG_fail;
11143 temp1 = true;
11144 }
11145 {
11146 PyThreadState* __tstate = wxPyBeginAllowThreads();
11147 wxPyLogInfo((wxString const &)*arg1);
11148
11149 wxPyEndAllowThreads(__tstate);
11150 if (PyErr_Occurred()) SWIG_fail;
11151 }
11152 Py_INCREF(Py_None); resultobj = Py_None;
11153 {
11154 if (temp1)
11155 delete arg1;
11156 }
11157 return resultobj;
11158 fail:
11159 {
11160 if (temp1)
11161 delete arg1;
11162 }
11163 return NULL;
11164 }
11165
11166
11167 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
11168 PyObject *resultobj = NULL;
11169 wxString *arg1 = 0 ;
11170 bool temp1 = false ;
11171 PyObject * obj0 = 0 ;
11172 char *kwnames[] = {
11173 (char *) "msg", NULL
11174 };
11175
11176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
11177 {
11178 arg1 = wxString_in_helper(obj0);
11179 if (arg1 == NULL) SWIG_fail;
11180 temp1 = true;
11181 }
11182 {
11183 PyThreadState* __tstate = wxPyBeginAllowThreads();
11184 wxPyLogDebug((wxString const &)*arg1);
11185
11186 wxPyEndAllowThreads(__tstate);
11187 if (PyErr_Occurred()) SWIG_fail;
11188 }
11189 Py_INCREF(Py_None); resultobj = Py_None;
11190 {
11191 if (temp1)
11192 delete arg1;
11193 }
11194 return resultobj;
11195 fail:
11196 {
11197 if (temp1)
11198 delete arg1;
11199 }
11200 return NULL;
11201 }
11202
11203
11204 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
11205 PyObject *resultobj = NULL;
11206 wxString *arg1 = 0 ;
11207 bool temp1 = false ;
11208 PyObject * obj0 = 0 ;
11209 char *kwnames[] = {
11210 (char *) "msg", NULL
11211 };
11212
11213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
11214 {
11215 arg1 = wxString_in_helper(obj0);
11216 if (arg1 == NULL) SWIG_fail;
11217 temp1 = true;
11218 }
11219 {
11220 PyThreadState* __tstate = wxPyBeginAllowThreads();
11221 wxPyLogVerbose((wxString const &)*arg1);
11222
11223 wxPyEndAllowThreads(__tstate);
11224 if (PyErr_Occurred()) SWIG_fail;
11225 }
11226 Py_INCREF(Py_None); resultobj = Py_None;
11227 {
11228 if (temp1)
11229 delete arg1;
11230 }
11231 return resultobj;
11232 fail:
11233 {
11234 if (temp1)
11235 delete arg1;
11236 }
11237 return NULL;
11238 }
11239
11240
11241 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
11242 PyObject *resultobj = NULL;
11243 wxString *arg1 = 0 ;
11244 bool temp1 = false ;
11245 PyObject * obj0 = 0 ;
11246 char *kwnames[] = {
11247 (char *) "msg", NULL
11248 };
11249
11250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
11251 {
11252 arg1 = wxString_in_helper(obj0);
11253 if (arg1 == NULL) SWIG_fail;
11254 temp1 = true;
11255 }
11256 {
11257 PyThreadState* __tstate = wxPyBeginAllowThreads();
11258 wxPyLogStatus((wxString const &)*arg1);
11259
11260 wxPyEndAllowThreads(__tstate);
11261 if (PyErr_Occurred()) SWIG_fail;
11262 }
11263 Py_INCREF(Py_None); resultobj = Py_None;
11264 {
11265 if (temp1)
11266 delete arg1;
11267 }
11268 return resultobj;
11269 fail:
11270 {
11271 if (temp1)
11272 delete arg1;
11273 }
11274 return NULL;
11275 }
11276
11277
11278 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
11279 PyObject *resultobj = NULL;
11280 wxFrame *arg1 = (wxFrame *) 0 ;
11281 wxString *arg2 = 0 ;
11282 bool temp2 = false ;
11283 PyObject * obj0 = 0 ;
11284 PyObject * obj1 = 0 ;
11285 char *kwnames[] = {
11286 (char *) "pFrame",(char *) "msg", NULL
11287 };
11288
11289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
11290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
11291 if (SWIG_arg_fail(1)) SWIG_fail;
11292 {
11293 arg2 = wxString_in_helper(obj1);
11294 if (arg2 == NULL) SWIG_fail;
11295 temp2 = true;
11296 }
11297 {
11298 PyThreadState* __tstate = wxPyBeginAllowThreads();
11299 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
11300
11301 wxPyEndAllowThreads(__tstate);
11302 if (PyErr_Occurred()) SWIG_fail;
11303 }
11304 Py_INCREF(Py_None); resultobj = Py_None;
11305 {
11306 if (temp2)
11307 delete arg2;
11308 }
11309 return resultobj;
11310 fail:
11311 {
11312 if (temp2)
11313 delete arg2;
11314 }
11315 return NULL;
11316 }
11317
11318
11319 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
11320 PyObject *resultobj = NULL;
11321 wxString *arg1 = 0 ;
11322 bool temp1 = false ;
11323 PyObject * obj0 = 0 ;
11324 char *kwnames[] = {
11325 (char *) "msg", NULL
11326 };
11327
11328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
11329 {
11330 arg1 = wxString_in_helper(obj0);
11331 if (arg1 == NULL) SWIG_fail;
11332 temp1 = true;
11333 }
11334 {
11335 PyThreadState* __tstate = wxPyBeginAllowThreads();
11336 wxPyLogSysError((wxString const &)*arg1);
11337
11338 wxPyEndAllowThreads(__tstate);
11339 if (PyErr_Occurred()) SWIG_fail;
11340 }
11341 Py_INCREF(Py_None); resultobj = Py_None;
11342 {
11343 if (temp1)
11344 delete arg1;
11345 }
11346 return resultobj;
11347 fail:
11348 {
11349 if (temp1)
11350 delete arg1;
11351 }
11352 return NULL;
11353 }
11354
11355
11356 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
11357 PyObject *resultobj = NULL;
11358 unsigned long arg1 ;
11359 wxString *arg2 = 0 ;
11360 bool temp2 = false ;
11361 PyObject * obj0 = 0 ;
11362 PyObject * obj1 = 0 ;
11363 char *kwnames[] = {
11364 (char *) "level",(char *) "msg", NULL
11365 };
11366
11367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
11368 {
11369 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
11370 if (SWIG_arg_fail(1)) SWIG_fail;
11371 }
11372 {
11373 arg2 = wxString_in_helper(obj1);
11374 if (arg2 == NULL) SWIG_fail;
11375 temp2 = true;
11376 }
11377 {
11378 PyThreadState* __tstate = wxPyBeginAllowThreads();
11379 wxPyLogGeneric(arg1,(wxString const &)*arg2);
11380
11381 wxPyEndAllowThreads(__tstate);
11382 if (PyErr_Occurred()) SWIG_fail;
11383 }
11384 Py_INCREF(Py_None); resultobj = Py_None;
11385 {
11386 if (temp2)
11387 delete arg2;
11388 }
11389 return resultobj;
11390 fail:
11391 {
11392 if (temp2)
11393 delete arg2;
11394 }
11395 return NULL;
11396 }
11397
11398
11399 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
11400 PyObject *resultobj = NULL;
11401 unsigned long arg1 ;
11402 wxString *arg2 = 0 ;
11403 bool temp2 = false ;
11404 PyObject * obj0 = 0 ;
11405 PyObject * obj1 = 0 ;
11406
11407 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
11408 {
11409 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
11410 if (SWIG_arg_fail(1)) SWIG_fail;
11411 }
11412 {
11413 arg2 = wxString_in_helper(obj1);
11414 if (arg2 == NULL) SWIG_fail;
11415 temp2 = true;
11416 }
11417 {
11418 PyThreadState* __tstate = wxPyBeginAllowThreads();
11419 wxPyLogTrace(arg1,(wxString const &)*arg2);
11420
11421 wxPyEndAllowThreads(__tstate);
11422 if (PyErr_Occurred()) SWIG_fail;
11423 }
11424 Py_INCREF(Py_None); resultobj = Py_None;
11425 {
11426 if (temp2)
11427 delete arg2;
11428 }
11429 return resultobj;
11430 fail:
11431 {
11432 if (temp2)
11433 delete arg2;
11434 }
11435 return NULL;
11436 }
11437
11438
11439 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
11440 PyObject *resultobj = NULL;
11441 wxString *arg1 = 0 ;
11442 wxString *arg2 = 0 ;
11443 bool temp1 = false ;
11444 bool temp2 = false ;
11445 PyObject * obj0 = 0 ;
11446 PyObject * obj1 = 0 ;
11447
11448 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
11449 {
11450 arg1 = wxString_in_helper(obj0);
11451 if (arg1 == NULL) SWIG_fail;
11452 temp1 = true;
11453 }
11454 {
11455 arg2 = wxString_in_helper(obj1);
11456 if (arg2 == NULL) SWIG_fail;
11457 temp2 = true;
11458 }
11459 {
11460 PyThreadState* __tstate = wxPyBeginAllowThreads();
11461 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
11462
11463 wxPyEndAllowThreads(__tstate);
11464 if (PyErr_Occurred()) SWIG_fail;
11465 }
11466 Py_INCREF(Py_None); resultobj = Py_None;
11467 {
11468 if (temp1)
11469 delete arg1;
11470 }
11471 {
11472 if (temp2)
11473 delete arg2;
11474 }
11475 return resultobj;
11476 fail:
11477 {
11478 if (temp1)
11479 delete arg1;
11480 }
11481 {
11482 if (temp2)
11483 delete arg2;
11484 }
11485 return NULL;
11486 }
11487
11488
11489 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
11490 int argc;
11491 PyObject *argv[3];
11492 int ii;
11493
11494 argc = PyObject_Length(args);
11495 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
11496 argv[ii] = PyTuple_GetItem(args,ii);
11497 }
11498 if (argc == 2) {
11499 int _v;
11500 {
11501 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11502 }
11503 if (_v) {
11504 {
11505 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11506 }
11507 if (_v) {
11508 return _wrap_LogTrace__SWIG_1(self,args);
11509 }
11510 }
11511 }
11512 if (argc == 2) {
11513 int _v;
11514 _v = SWIG_Check_unsigned_SS_long(argv[0]);
11515 if (_v) {
11516 {
11517 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11518 }
11519 if (_v) {
11520 return _wrap_LogTrace__SWIG_0(self,args);
11521 }
11522 }
11523 }
11524
11525 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
11526 return NULL;
11527 }
11528
11529
11530 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
11531 PyObject *resultobj = NULL;
11532 wxString *arg1 = 0 ;
11533 wxString *arg2 = 0 ;
11534 bool temp1 = false ;
11535 bool temp2 = false ;
11536 PyObject * obj0 = 0 ;
11537 PyObject * obj1 = 0 ;
11538 char *kwnames[] = {
11539 (char *) "title",(char *) "text", NULL
11540 };
11541
11542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
11543 {
11544 arg1 = wxString_in_helper(obj0);
11545 if (arg1 == NULL) SWIG_fail;
11546 temp1 = true;
11547 }
11548 {
11549 arg2 = wxString_in_helper(obj1);
11550 if (arg2 == NULL) SWIG_fail;
11551 temp2 = true;
11552 }
11553 {
11554 PyThreadState* __tstate = wxPyBeginAllowThreads();
11555 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
11556
11557 wxPyEndAllowThreads(__tstate);
11558 if (PyErr_Occurred()) SWIG_fail;
11559 }
11560 Py_INCREF(Py_None); resultobj = Py_None;
11561 {
11562 if (temp1)
11563 delete arg1;
11564 }
11565 {
11566 if (temp2)
11567 delete arg2;
11568 }
11569 return resultobj;
11570 fail:
11571 {
11572 if (temp1)
11573 delete arg1;
11574 }
11575 {
11576 if (temp2)
11577 delete arg2;
11578 }
11579 return NULL;
11580 }
11581
11582
11583 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
11584 PyObject *resultobj = NULL;
11585 wxLogNull *result;
11586 char *kwnames[] = {
11587 NULL
11588 };
11589
11590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
11591 {
11592 PyThreadState* __tstate = wxPyBeginAllowThreads();
11593 result = (wxLogNull *)new wxLogNull();
11594
11595 wxPyEndAllowThreads(__tstate);
11596 if (PyErr_Occurred()) SWIG_fail;
11597 }
11598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
11599 return resultobj;
11600 fail:
11601 return NULL;
11602 }
11603
11604
11605 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
11606 PyObject *resultobj = NULL;
11607 wxLogNull *arg1 = (wxLogNull *) 0 ;
11608 PyObject * obj0 = 0 ;
11609 char *kwnames[] = {
11610 (char *) "self", NULL
11611 };
11612
11613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
11614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
11615 if (SWIG_arg_fail(1)) SWIG_fail;
11616 {
11617 PyThreadState* __tstate = wxPyBeginAllowThreads();
11618 delete arg1;
11619
11620 wxPyEndAllowThreads(__tstate);
11621 if (PyErr_Occurred()) SWIG_fail;
11622 }
11623 Py_INCREF(Py_None); resultobj = Py_None;
11624 return resultobj;
11625 fail:
11626 return NULL;
11627 }
11628
11629
11630 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
11631 PyObject *obj;
11632 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11633 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
11634 Py_INCREF(obj);
11635 return Py_BuildValue((char *)"");
11636 }
11637 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
11638 PyObject *resultobj = NULL;
11639 wxPyLog *result;
11640 char *kwnames[] = {
11641 NULL
11642 };
11643
11644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
11645 {
11646 PyThreadState* __tstate = wxPyBeginAllowThreads();
11647 result = (wxPyLog *)new wxPyLog();
11648
11649 wxPyEndAllowThreads(__tstate);
11650 if (PyErr_Occurred()) SWIG_fail;
11651 }
11652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
11653 return resultobj;
11654 fail:
11655 return NULL;
11656 }
11657
11658
11659 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11660 PyObject *resultobj = NULL;
11661 wxPyLog *arg1 = (wxPyLog *) 0 ;
11662 PyObject *arg2 = (PyObject *) 0 ;
11663 PyObject *arg3 = (PyObject *) 0 ;
11664 PyObject * obj0 = 0 ;
11665 PyObject * obj1 = 0 ;
11666 PyObject * obj2 = 0 ;
11667 char *kwnames[] = {
11668 (char *) "self",(char *) "self",(char *) "_class", NULL
11669 };
11670
11671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
11673 if (SWIG_arg_fail(1)) SWIG_fail;
11674 arg2 = obj1;
11675 arg3 = obj2;
11676 {
11677 PyThreadState* __tstate = wxPyBeginAllowThreads();
11678 (arg1)->_setCallbackInfo(arg2,arg3);
11679
11680 wxPyEndAllowThreads(__tstate);
11681 if (PyErr_Occurred()) SWIG_fail;
11682 }
11683 Py_INCREF(Py_None); resultobj = Py_None;
11684 return resultobj;
11685 fail:
11686 return NULL;
11687 }
11688
11689
11690 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
11691 PyObject *obj;
11692 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11693 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
11694 Py_INCREF(obj);
11695 return Py_BuildValue((char *)"");
11696 }
11697 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11698 PyObject *resultobj = NULL;
11699 int arg1 ;
11700 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11701 int arg3 = (int) wxKILL_NOCHILDREN ;
11702 wxKillError result;
11703 PyObject * obj0 = 0 ;
11704 PyObject * obj1 = 0 ;
11705 PyObject * obj2 = 0 ;
11706 char *kwnames[] = {
11707 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11708 };
11709
11710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11711 {
11712 arg1 = static_cast<int >(SWIG_As_int(obj0));
11713 if (SWIG_arg_fail(1)) SWIG_fail;
11714 }
11715 if (obj1) {
11716 {
11717 arg2 = static_cast<wxSignal >(SWIG_As_int(obj1));
11718 if (SWIG_arg_fail(2)) SWIG_fail;
11719 }
11720 }
11721 if (obj2) {
11722 {
11723 arg3 = static_cast<int >(SWIG_As_int(obj2));
11724 if (SWIG_arg_fail(3)) SWIG_fail;
11725 }
11726 }
11727 {
11728 PyThreadState* __tstate = wxPyBeginAllowThreads();
11729 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
11730
11731 wxPyEndAllowThreads(__tstate);
11732 if (PyErr_Occurred()) SWIG_fail;
11733 }
11734 resultobj = SWIG_From_int((result));
11735 return resultobj;
11736 fail:
11737 return NULL;
11738 }
11739
11740
11741 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
11742 PyObject *resultobj = NULL;
11743 int arg1 ;
11744 bool result;
11745 PyObject * obj0 = 0 ;
11746 char *kwnames[] = {
11747 (char *) "pid", NULL
11748 };
11749
11750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
11751 {
11752 arg1 = static_cast<int >(SWIG_As_int(obj0));
11753 if (SWIG_arg_fail(1)) SWIG_fail;
11754 }
11755 {
11756 PyThreadState* __tstate = wxPyBeginAllowThreads();
11757 result = (bool)wxPyProcess::Exists(arg1);
11758
11759 wxPyEndAllowThreads(__tstate);
11760 if (PyErr_Occurred()) SWIG_fail;
11761 }
11762 {
11763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11764 }
11765 return resultobj;
11766 fail:
11767 return NULL;
11768 }
11769
11770
11771 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
11772 PyObject *resultobj = NULL;
11773 wxString *arg1 = 0 ;
11774 int arg2 = (int) wxEXEC_ASYNC ;
11775 wxPyProcess *result;
11776 bool temp1 = false ;
11777 PyObject * obj0 = 0 ;
11778 PyObject * obj1 = 0 ;
11779 char *kwnames[] = {
11780 (char *) "cmd",(char *) "flags", NULL
11781 };
11782
11783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
11784 {
11785 arg1 = wxString_in_helper(obj0);
11786 if (arg1 == NULL) SWIG_fail;
11787 temp1 = true;
11788 }
11789 if (obj1) {
11790 {
11791 arg2 = static_cast<int >(SWIG_As_int(obj1));
11792 if (SWIG_arg_fail(2)) SWIG_fail;
11793 }
11794 }
11795 {
11796 PyThreadState* __tstate = wxPyBeginAllowThreads();
11797 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
11798
11799 wxPyEndAllowThreads(__tstate);
11800 if (PyErr_Occurred()) SWIG_fail;
11801 }
11802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
11803 {
11804 if (temp1)
11805 delete arg1;
11806 }
11807 return resultobj;
11808 fail:
11809 {
11810 if (temp1)
11811 delete arg1;
11812 }
11813 return NULL;
11814 }
11815
11816
11817 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
11818 PyObject *resultobj = NULL;
11819 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11820 int arg2 = (int) -1 ;
11821 wxPyProcess *result;
11822 PyObject * obj0 = 0 ;
11823 PyObject * obj1 = 0 ;
11824 char *kwnames[] = {
11825 (char *) "parent",(char *) "id", NULL
11826 };
11827
11828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
11829 if (obj0) {
11830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
11831 if (SWIG_arg_fail(1)) SWIG_fail;
11832 }
11833 if (obj1) {
11834 {
11835 arg2 = static_cast<int >(SWIG_As_int(obj1));
11836 if (SWIG_arg_fail(2)) SWIG_fail;
11837 }
11838 }
11839 {
11840 PyThreadState* __tstate = wxPyBeginAllowThreads();
11841 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
11842
11843 wxPyEndAllowThreads(__tstate);
11844 if (PyErr_Occurred()) SWIG_fail;
11845 }
11846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
11847 return resultobj;
11848 fail:
11849 return NULL;
11850 }
11851
11852
11853 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11854 PyObject *resultobj = NULL;
11855 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11856 PyObject *arg2 = (PyObject *) 0 ;
11857 PyObject *arg3 = (PyObject *) 0 ;
11858 PyObject * obj0 = 0 ;
11859 PyObject * obj1 = 0 ;
11860 PyObject * obj2 = 0 ;
11861 char *kwnames[] = {
11862 (char *) "self",(char *) "self",(char *) "_class", NULL
11863 };
11864
11865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11867 if (SWIG_arg_fail(1)) SWIG_fail;
11868 arg2 = obj1;
11869 arg3 = obj2;
11870 {
11871 PyThreadState* __tstate = wxPyBeginAllowThreads();
11872 (arg1)->_setCallbackInfo(arg2,arg3);
11873
11874 wxPyEndAllowThreads(__tstate);
11875 if (PyErr_Occurred()) SWIG_fail;
11876 }
11877 Py_INCREF(Py_None); resultobj = Py_None;
11878 return resultobj;
11879 fail:
11880 return NULL;
11881 }
11882
11883
11884 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
11885 PyObject *resultobj = NULL;
11886 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11887 int arg2 ;
11888 int arg3 ;
11889 PyObject * obj0 = 0 ;
11890 PyObject * obj1 = 0 ;
11891 PyObject * obj2 = 0 ;
11892 char *kwnames[] = {
11893 (char *) "self",(char *) "pid",(char *) "status", NULL
11894 };
11895
11896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
11897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11898 if (SWIG_arg_fail(1)) SWIG_fail;
11899 {
11900 arg2 = static_cast<int >(SWIG_As_int(obj1));
11901 if (SWIG_arg_fail(2)) SWIG_fail;
11902 }
11903 {
11904 arg3 = static_cast<int >(SWIG_As_int(obj2));
11905 if (SWIG_arg_fail(3)) SWIG_fail;
11906 }
11907 {
11908 PyThreadState* __tstate = wxPyBeginAllowThreads();
11909 (arg1)->base_OnTerminate(arg2,arg3);
11910
11911 wxPyEndAllowThreads(__tstate);
11912 if (PyErr_Occurred()) SWIG_fail;
11913 }
11914 Py_INCREF(Py_None); resultobj = Py_None;
11915 return resultobj;
11916 fail:
11917 return NULL;
11918 }
11919
11920
11921 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11922 PyObject *resultobj = NULL;
11923 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11924 PyObject * obj0 = 0 ;
11925 char *kwnames[] = {
11926 (char *) "self", NULL
11927 };
11928
11929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11931 if (SWIG_arg_fail(1)) SWIG_fail;
11932 {
11933 PyThreadState* __tstate = wxPyBeginAllowThreads();
11934 (arg1)->Redirect();
11935
11936 wxPyEndAllowThreads(__tstate);
11937 if (PyErr_Occurred()) SWIG_fail;
11938 }
11939 Py_INCREF(Py_None); resultobj = Py_None;
11940 return resultobj;
11941 fail:
11942 return NULL;
11943 }
11944
11945
11946 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11947 PyObject *resultobj = NULL;
11948 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11949 bool result;
11950 PyObject * obj0 = 0 ;
11951 char *kwnames[] = {
11952 (char *) "self", NULL
11953 };
11954
11955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11957 if (SWIG_arg_fail(1)) SWIG_fail;
11958 {
11959 PyThreadState* __tstate = wxPyBeginAllowThreads();
11960 result = (bool)(arg1)->IsRedirected();
11961
11962 wxPyEndAllowThreads(__tstate);
11963 if (PyErr_Occurred()) SWIG_fail;
11964 }
11965 {
11966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11967 }
11968 return resultobj;
11969 fail:
11970 return NULL;
11971 }
11972
11973
11974 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11975 PyObject *resultobj = NULL;
11976 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11977 PyObject * obj0 = 0 ;
11978 char *kwnames[] = {
11979 (char *) "self", NULL
11980 };
11981
11982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11984 if (SWIG_arg_fail(1)) SWIG_fail;
11985 {
11986 PyThreadState* __tstate = wxPyBeginAllowThreads();
11987 (arg1)->Detach();
11988
11989 wxPyEndAllowThreads(__tstate);
11990 if (PyErr_Occurred()) SWIG_fail;
11991 }
11992 Py_INCREF(Py_None); resultobj = Py_None;
11993 return resultobj;
11994 fail:
11995 return NULL;
11996 }
11997
11998
11999 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
12000 PyObject *resultobj = NULL;
12001 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12002 wxInputStream *result;
12003 PyObject * obj0 = 0 ;
12004 char *kwnames[] = {
12005 (char *) "self", NULL
12006 };
12007
12008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
12009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12010 if (SWIG_arg_fail(1)) SWIG_fail;
12011 {
12012 PyThreadState* __tstate = wxPyBeginAllowThreads();
12013 result = (wxInputStream *)(arg1)->GetInputStream();
12014
12015 wxPyEndAllowThreads(__tstate);
12016 if (PyErr_Occurred()) SWIG_fail;
12017 }
12018 {
12019 wxPyInputStream * _ptr = NULL;
12020
12021 if (result) {
12022 _ptr = new wxPyInputStream(result);
12023 }
12024 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12025 }
12026 return resultobj;
12027 fail:
12028 return NULL;
12029 }
12030
12031
12032 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
12033 PyObject *resultobj = NULL;
12034 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12035 wxInputStream *result;
12036 PyObject * obj0 = 0 ;
12037 char *kwnames[] = {
12038 (char *) "self", NULL
12039 };
12040
12041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
12042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12043 if (SWIG_arg_fail(1)) SWIG_fail;
12044 {
12045 PyThreadState* __tstate = wxPyBeginAllowThreads();
12046 result = (wxInputStream *)(arg1)->GetErrorStream();
12047
12048 wxPyEndAllowThreads(__tstate);
12049 if (PyErr_Occurred()) SWIG_fail;
12050 }
12051 {
12052 wxPyInputStream * _ptr = NULL;
12053
12054 if (result) {
12055 _ptr = new wxPyInputStream(result);
12056 }
12057 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12058 }
12059 return resultobj;
12060 fail:
12061 return NULL;
12062 }
12063
12064
12065 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
12066 PyObject *resultobj = NULL;
12067 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12068 wxOutputStream *result;
12069 PyObject * obj0 = 0 ;
12070 char *kwnames[] = {
12071 (char *) "self", NULL
12072 };
12073
12074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
12075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12076 if (SWIG_arg_fail(1)) SWIG_fail;
12077 {
12078 PyThreadState* __tstate = wxPyBeginAllowThreads();
12079 result = (wxOutputStream *)(arg1)->GetOutputStream();
12080
12081 wxPyEndAllowThreads(__tstate);
12082 if (PyErr_Occurred()) SWIG_fail;
12083 }
12084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
12085 return resultobj;
12086 fail:
12087 return NULL;
12088 }
12089
12090
12091 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
12092 PyObject *resultobj = NULL;
12093 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12094 PyObject * obj0 = 0 ;
12095 char *kwnames[] = {
12096 (char *) "self", NULL
12097 };
12098
12099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
12100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12101 if (SWIG_arg_fail(1)) SWIG_fail;
12102 {
12103 PyThreadState* __tstate = wxPyBeginAllowThreads();
12104 (arg1)->CloseOutput();
12105
12106 wxPyEndAllowThreads(__tstate);
12107 if (PyErr_Occurred()) SWIG_fail;
12108 }
12109 Py_INCREF(Py_None); resultobj = Py_None;
12110 return resultobj;
12111 fail:
12112 return NULL;
12113 }
12114
12115
12116 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
12117 PyObject *resultobj = NULL;
12118 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12119 bool result;
12120 PyObject * obj0 = 0 ;
12121 char *kwnames[] = {
12122 (char *) "self", NULL
12123 };
12124
12125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
12126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12127 if (SWIG_arg_fail(1)) SWIG_fail;
12128 {
12129 PyThreadState* __tstate = wxPyBeginAllowThreads();
12130 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
12131
12132 wxPyEndAllowThreads(__tstate);
12133 if (PyErr_Occurred()) SWIG_fail;
12134 }
12135 {
12136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12137 }
12138 return resultobj;
12139 fail:
12140 return NULL;
12141 }
12142
12143
12144 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
12145 PyObject *resultobj = NULL;
12146 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12147 bool result;
12148 PyObject * obj0 = 0 ;
12149 char *kwnames[] = {
12150 (char *) "self", NULL
12151 };
12152
12153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
12154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12155 if (SWIG_arg_fail(1)) SWIG_fail;
12156 {
12157 PyThreadState* __tstate = wxPyBeginAllowThreads();
12158 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
12159
12160 wxPyEndAllowThreads(__tstate);
12161 if (PyErr_Occurred()) SWIG_fail;
12162 }
12163 {
12164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12165 }
12166 return resultobj;
12167 fail:
12168 return NULL;
12169 }
12170
12171
12172 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
12173 PyObject *resultobj = NULL;
12174 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12175 bool result;
12176 PyObject * obj0 = 0 ;
12177 char *kwnames[] = {
12178 (char *) "self", NULL
12179 };
12180
12181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
12182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12183 if (SWIG_arg_fail(1)) SWIG_fail;
12184 {
12185 PyThreadState* __tstate = wxPyBeginAllowThreads();
12186 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
12187
12188 wxPyEndAllowThreads(__tstate);
12189 if (PyErr_Occurred()) SWIG_fail;
12190 }
12191 {
12192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12193 }
12194 return resultobj;
12195 fail:
12196 return NULL;
12197 }
12198
12199
12200 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
12201 PyObject *obj;
12202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12203 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
12204 Py_INCREF(obj);
12205 return Py_BuildValue((char *)"");
12206 }
12207 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12208 PyObject *resultobj = NULL;
12209 int arg1 = (int) 0 ;
12210 int arg2 = (int) 0 ;
12211 int arg3 = (int) 0 ;
12212 wxProcessEvent *result;
12213 PyObject * obj0 = 0 ;
12214 PyObject * obj1 = 0 ;
12215 PyObject * obj2 = 0 ;
12216 char *kwnames[] = {
12217 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
12218 };
12219
12220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
12221 if (obj0) {
12222 {
12223 arg1 = static_cast<int >(SWIG_As_int(obj0));
12224 if (SWIG_arg_fail(1)) SWIG_fail;
12225 }
12226 }
12227 if (obj1) {
12228 {
12229 arg2 = static_cast<int >(SWIG_As_int(obj1));
12230 if (SWIG_arg_fail(2)) SWIG_fail;
12231 }
12232 }
12233 if (obj2) {
12234 {
12235 arg3 = static_cast<int >(SWIG_As_int(obj2));
12236 if (SWIG_arg_fail(3)) SWIG_fail;
12237 }
12238 }
12239 {
12240 PyThreadState* __tstate = wxPyBeginAllowThreads();
12241 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
12242
12243 wxPyEndAllowThreads(__tstate);
12244 if (PyErr_Occurred()) SWIG_fail;
12245 }
12246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
12247 return resultobj;
12248 fail:
12249 return NULL;
12250 }
12251
12252
12253 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
12254 PyObject *resultobj = NULL;
12255 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12256 int result;
12257 PyObject * obj0 = 0 ;
12258 char *kwnames[] = {
12259 (char *) "self", NULL
12260 };
12261
12262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
12263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12264 if (SWIG_arg_fail(1)) SWIG_fail;
12265 {
12266 PyThreadState* __tstate = wxPyBeginAllowThreads();
12267 result = (int)(arg1)->GetPid();
12268
12269 wxPyEndAllowThreads(__tstate);
12270 if (PyErr_Occurred()) SWIG_fail;
12271 }
12272 {
12273 resultobj = SWIG_From_int(static_cast<int >(result));
12274 }
12275 return resultobj;
12276 fail:
12277 return NULL;
12278 }
12279
12280
12281 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
12282 PyObject *resultobj = NULL;
12283 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12284 int result;
12285 PyObject * obj0 = 0 ;
12286 char *kwnames[] = {
12287 (char *) "self", NULL
12288 };
12289
12290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
12291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12292 if (SWIG_arg_fail(1)) SWIG_fail;
12293 {
12294 PyThreadState* __tstate = wxPyBeginAllowThreads();
12295 result = (int)(arg1)->GetExitCode();
12296
12297 wxPyEndAllowThreads(__tstate);
12298 if (PyErr_Occurred()) SWIG_fail;
12299 }
12300 {
12301 resultobj = SWIG_From_int(static_cast<int >(result));
12302 }
12303 return resultobj;
12304 fail:
12305 return NULL;
12306 }
12307
12308
12309 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
12310 PyObject *resultobj = NULL;
12311 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12312 int arg2 ;
12313 PyObject * obj0 = 0 ;
12314 PyObject * obj1 = 0 ;
12315 char *kwnames[] = {
12316 (char *) "self",(char *) "m_pid", NULL
12317 };
12318
12319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
12320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12321 if (SWIG_arg_fail(1)) SWIG_fail;
12322 {
12323 arg2 = static_cast<int >(SWIG_As_int(obj1));
12324 if (SWIG_arg_fail(2)) SWIG_fail;
12325 }
12326 if (arg1) (arg1)->m_pid = arg2;
12327
12328 Py_INCREF(Py_None); resultobj = Py_None;
12329 return resultobj;
12330 fail:
12331 return NULL;
12332 }
12333
12334
12335 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
12336 PyObject *resultobj = NULL;
12337 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12338 int result;
12339 PyObject * obj0 = 0 ;
12340 char *kwnames[] = {
12341 (char *) "self", NULL
12342 };
12343
12344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
12345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12346 if (SWIG_arg_fail(1)) SWIG_fail;
12347 result = (int) ((arg1)->m_pid);
12348
12349 {
12350 resultobj = SWIG_From_int(static_cast<int >(result));
12351 }
12352 return resultobj;
12353 fail:
12354 return NULL;
12355 }
12356
12357
12358 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
12359 PyObject *resultobj = NULL;
12360 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12361 int arg2 ;
12362 PyObject * obj0 = 0 ;
12363 PyObject * obj1 = 0 ;
12364 char *kwnames[] = {
12365 (char *) "self",(char *) "m_exitcode", NULL
12366 };
12367
12368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
12369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12370 if (SWIG_arg_fail(1)) SWIG_fail;
12371 {
12372 arg2 = static_cast<int >(SWIG_As_int(obj1));
12373 if (SWIG_arg_fail(2)) SWIG_fail;
12374 }
12375 if (arg1) (arg1)->m_exitcode = arg2;
12376
12377 Py_INCREF(Py_None); resultobj = Py_None;
12378 return resultobj;
12379 fail:
12380 return NULL;
12381 }
12382
12383
12384 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
12385 PyObject *resultobj = NULL;
12386 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12387 int result;
12388 PyObject * obj0 = 0 ;
12389 char *kwnames[] = {
12390 (char *) "self", NULL
12391 };
12392
12393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
12394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12395 if (SWIG_arg_fail(1)) SWIG_fail;
12396 result = (int) ((arg1)->m_exitcode);
12397
12398 {
12399 resultobj = SWIG_From_int(static_cast<int >(result));
12400 }
12401 return resultobj;
12402 fail:
12403 return NULL;
12404 }
12405
12406
12407 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
12408 PyObject *obj;
12409 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12410 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
12411 Py_INCREF(obj);
12412 return Py_BuildValue((char *)"");
12413 }
12414 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj = NULL;
12416 wxString *arg1 = 0 ;
12417 int arg2 = (int) wxEXEC_ASYNC ;
12418 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
12419 long result;
12420 bool temp1 = false ;
12421 PyObject * obj0 = 0 ;
12422 PyObject * obj1 = 0 ;
12423 PyObject * obj2 = 0 ;
12424 char *kwnames[] = {
12425 (char *) "command",(char *) "flags",(char *) "process", NULL
12426 };
12427
12428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
12429 {
12430 arg1 = wxString_in_helper(obj0);
12431 if (arg1 == NULL) SWIG_fail;
12432 temp1 = true;
12433 }
12434 if (obj1) {
12435 {
12436 arg2 = static_cast<int >(SWIG_As_int(obj1));
12437 if (SWIG_arg_fail(2)) SWIG_fail;
12438 }
12439 }
12440 if (obj2) {
12441 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12442 if (SWIG_arg_fail(3)) SWIG_fail;
12443 }
12444 {
12445 if (!wxPyCheckForApp()) SWIG_fail;
12446 PyThreadState* __tstate = wxPyBeginAllowThreads();
12447 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
12448
12449 wxPyEndAllowThreads(__tstate);
12450 if (PyErr_Occurred()) SWIG_fail;
12451 }
12452 {
12453 resultobj = SWIG_From_long(static_cast<long >(result));
12454 }
12455 {
12456 if (temp1)
12457 delete arg1;
12458 }
12459 return resultobj;
12460 fail:
12461 {
12462 if (temp1)
12463 delete arg1;
12464 }
12465 return NULL;
12466 }
12467
12468
12469 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
12470 PyObject *resultobj = NULL;
12471 long arg1 ;
12472 wxSignal arg2 = (wxSignal) wxSIGTERM ;
12473 wxKillError *arg3 = (wxKillError *) 0 ;
12474 int arg4 = (int) wxKILL_NOCHILDREN ;
12475 int result;
12476 wxKillError temp3 ;
12477 PyObject * obj0 = 0 ;
12478 PyObject * obj1 = 0 ;
12479 PyObject * obj2 = 0 ;
12480 char *kwnames[] = {
12481 (char *) "pid",(char *) "sig",(char *) "flags", NULL
12482 };
12483
12484 {
12485 arg3 = &temp3;
12486 }
12487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
12488 {
12489 arg1 = static_cast<long >(SWIG_As_long(obj0));
12490 if (SWIG_arg_fail(1)) SWIG_fail;
12491 }
12492 if (obj1) {
12493 {
12494 arg2 = static_cast<wxSignal >(SWIG_As_int(obj1));
12495 if (SWIG_arg_fail(2)) SWIG_fail;
12496 }
12497 }
12498 if (obj2) {
12499 {
12500 arg4 = static_cast<int >(SWIG_As_int(obj2));
12501 if (SWIG_arg_fail(4)) SWIG_fail;
12502 }
12503 }
12504 {
12505 PyThreadState* __tstate = wxPyBeginAllowThreads();
12506 result = (int)wxKill(arg1,arg2,arg3,arg4);
12507
12508 wxPyEndAllowThreads(__tstate);
12509 if (PyErr_Occurred()) SWIG_fail;
12510 }
12511 {
12512 resultobj = SWIG_From_int(static_cast<int >(result));
12513 }
12514 {
12515 PyObject* o;
12516 o = PyInt_FromLong((long) (*arg3));
12517
12518 resultobj = t_output_helper(resultobj, o);
12519
12520
12521
12522 }
12523 return resultobj;
12524 fail:
12525 return NULL;
12526 }
12527
12528
12529 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
12530 PyObject *resultobj = NULL;
12531 int arg1 = (int) wxJOYSTICK1 ;
12532 wxJoystick *result;
12533 PyObject * obj0 = 0 ;
12534 char *kwnames[] = {
12535 (char *) "joystick", NULL
12536 };
12537
12538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
12539 if (obj0) {
12540 {
12541 arg1 = static_cast<int >(SWIG_As_int(obj0));
12542 if (SWIG_arg_fail(1)) SWIG_fail;
12543 }
12544 }
12545 {
12546 if (!wxPyCheckForApp()) SWIG_fail;
12547 PyThreadState* __tstate = wxPyBeginAllowThreads();
12548 result = (wxJoystick *)new wxJoystick(arg1);
12549
12550 wxPyEndAllowThreads(__tstate);
12551 if (PyErr_Occurred()) SWIG_fail;
12552 }
12553 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
12554 return resultobj;
12555 fail:
12556 return NULL;
12557 }
12558
12559
12560 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
12561 PyObject *resultobj = NULL;
12562 wxJoystick *arg1 = (wxJoystick *) 0 ;
12563 PyObject * obj0 = 0 ;
12564 char *kwnames[] = {
12565 (char *) "self", NULL
12566 };
12567
12568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
12569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12570 if (SWIG_arg_fail(1)) SWIG_fail;
12571 {
12572 PyThreadState* __tstate = wxPyBeginAllowThreads();
12573 delete arg1;
12574
12575 wxPyEndAllowThreads(__tstate);
12576 if (PyErr_Occurred()) SWIG_fail;
12577 }
12578 Py_INCREF(Py_None); resultobj = Py_None;
12579 return resultobj;
12580 fail:
12581 return NULL;
12582 }
12583
12584
12585 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12586 PyObject *resultobj = NULL;
12587 wxJoystick *arg1 = (wxJoystick *) 0 ;
12588 wxPoint result;
12589 PyObject * obj0 = 0 ;
12590 char *kwnames[] = {
12591 (char *) "self", NULL
12592 };
12593
12594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
12595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12596 if (SWIG_arg_fail(1)) SWIG_fail;
12597 {
12598 PyThreadState* __tstate = wxPyBeginAllowThreads();
12599 result = (arg1)->GetPosition();
12600
12601 wxPyEndAllowThreads(__tstate);
12602 if (PyErr_Occurred()) SWIG_fail;
12603 }
12604 {
12605 wxPoint * resultptr;
12606 resultptr = new wxPoint(static_cast<wxPoint & >(result));
12607 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12608 }
12609 return resultobj;
12610 fail:
12611 return NULL;
12612 }
12613
12614
12615 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12616 PyObject *resultobj = NULL;
12617 wxJoystick *arg1 = (wxJoystick *) 0 ;
12618 int result;
12619 PyObject * obj0 = 0 ;
12620 char *kwnames[] = {
12621 (char *) "self", NULL
12622 };
12623
12624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
12625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12626 if (SWIG_arg_fail(1)) SWIG_fail;
12627 {
12628 PyThreadState* __tstate = wxPyBeginAllowThreads();
12629 result = (int)(arg1)->GetZPosition();
12630
12631 wxPyEndAllowThreads(__tstate);
12632 if (PyErr_Occurred()) SWIG_fail;
12633 }
12634 {
12635 resultobj = SWIG_From_int(static_cast<int >(result));
12636 }
12637 return resultobj;
12638 fail:
12639 return NULL;
12640 }
12641
12642
12643 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12644 PyObject *resultobj = NULL;
12645 wxJoystick *arg1 = (wxJoystick *) 0 ;
12646 int result;
12647 PyObject * obj0 = 0 ;
12648 char *kwnames[] = {
12649 (char *) "self", NULL
12650 };
12651
12652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
12653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12654 if (SWIG_arg_fail(1)) SWIG_fail;
12655 {
12656 PyThreadState* __tstate = wxPyBeginAllowThreads();
12657 result = (int)(arg1)->GetButtonState();
12658
12659 wxPyEndAllowThreads(__tstate);
12660 if (PyErr_Occurred()) SWIG_fail;
12661 }
12662 {
12663 resultobj = SWIG_From_int(static_cast<int >(result));
12664 }
12665 return resultobj;
12666 fail:
12667 return NULL;
12668 }
12669
12670
12671 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12672 PyObject *resultobj = NULL;
12673 wxJoystick *arg1 = (wxJoystick *) 0 ;
12674 int result;
12675 PyObject * obj0 = 0 ;
12676 char *kwnames[] = {
12677 (char *) "self", NULL
12678 };
12679
12680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
12681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12682 if (SWIG_arg_fail(1)) SWIG_fail;
12683 {
12684 PyThreadState* __tstate = wxPyBeginAllowThreads();
12685 result = (int)(arg1)->GetPOVPosition();
12686
12687 wxPyEndAllowThreads(__tstate);
12688 if (PyErr_Occurred()) SWIG_fail;
12689 }
12690 {
12691 resultobj = SWIG_From_int(static_cast<int >(result));
12692 }
12693 return resultobj;
12694 fail:
12695 return NULL;
12696 }
12697
12698
12699 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12700 PyObject *resultobj = NULL;
12701 wxJoystick *arg1 = (wxJoystick *) 0 ;
12702 int result;
12703 PyObject * obj0 = 0 ;
12704 char *kwnames[] = {
12705 (char *) "self", NULL
12706 };
12707
12708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
12709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12710 if (SWIG_arg_fail(1)) SWIG_fail;
12711 {
12712 PyThreadState* __tstate = wxPyBeginAllowThreads();
12713 result = (int)(arg1)->GetPOVCTSPosition();
12714
12715 wxPyEndAllowThreads(__tstate);
12716 if (PyErr_Occurred()) SWIG_fail;
12717 }
12718 {
12719 resultobj = SWIG_From_int(static_cast<int >(result));
12720 }
12721 return resultobj;
12722 fail:
12723 return NULL;
12724 }
12725
12726
12727 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12728 PyObject *resultobj = NULL;
12729 wxJoystick *arg1 = (wxJoystick *) 0 ;
12730 int result;
12731 PyObject * obj0 = 0 ;
12732 char *kwnames[] = {
12733 (char *) "self", NULL
12734 };
12735
12736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
12737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12738 if (SWIG_arg_fail(1)) SWIG_fail;
12739 {
12740 PyThreadState* __tstate = wxPyBeginAllowThreads();
12741 result = (int)(arg1)->GetRudderPosition();
12742
12743 wxPyEndAllowThreads(__tstate);
12744 if (PyErr_Occurred()) SWIG_fail;
12745 }
12746 {
12747 resultobj = SWIG_From_int(static_cast<int >(result));
12748 }
12749 return resultobj;
12750 fail:
12751 return NULL;
12752 }
12753
12754
12755 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12756 PyObject *resultobj = NULL;
12757 wxJoystick *arg1 = (wxJoystick *) 0 ;
12758 int result;
12759 PyObject * obj0 = 0 ;
12760 char *kwnames[] = {
12761 (char *) "self", NULL
12762 };
12763
12764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
12765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12766 if (SWIG_arg_fail(1)) SWIG_fail;
12767 {
12768 PyThreadState* __tstate = wxPyBeginAllowThreads();
12769 result = (int)(arg1)->GetUPosition();
12770
12771 wxPyEndAllowThreads(__tstate);
12772 if (PyErr_Occurred()) SWIG_fail;
12773 }
12774 {
12775 resultobj = SWIG_From_int(static_cast<int >(result));
12776 }
12777 return resultobj;
12778 fail:
12779 return NULL;
12780 }
12781
12782
12783 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12784 PyObject *resultobj = NULL;
12785 wxJoystick *arg1 = (wxJoystick *) 0 ;
12786 int result;
12787 PyObject * obj0 = 0 ;
12788 char *kwnames[] = {
12789 (char *) "self", NULL
12790 };
12791
12792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
12793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12794 if (SWIG_arg_fail(1)) SWIG_fail;
12795 {
12796 PyThreadState* __tstate = wxPyBeginAllowThreads();
12797 result = (int)(arg1)->GetVPosition();
12798
12799 wxPyEndAllowThreads(__tstate);
12800 if (PyErr_Occurred()) SWIG_fail;
12801 }
12802 {
12803 resultobj = SWIG_From_int(static_cast<int >(result));
12804 }
12805 return resultobj;
12806 fail:
12807 return NULL;
12808 }
12809
12810
12811 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
12812 PyObject *resultobj = NULL;
12813 wxJoystick *arg1 = (wxJoystick *) 0 ;
12814 int result;
12815 PyObject * obj0 = 0 ;
12816 char *kwnames[] = {
12817 (char *) "self", NULL
12818 };
12819
12820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
12821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12822 if (SWIG_arg_fail(1)) SWIG_fail;
12823 {
12824 PyThreadState* __tstate = wxPyBeginAllowThreads();
12825 result = (int)(arg1)->GetMovementThreshold();
12826
12827 wxPyEndAllowThreads(__tstate);
12828 if (PyErr_Occurred()) SWIG_fail;
12829 }
12830 {
12831 resultobj = SWIG_From_int(static_cast<int >(result));
12832 }
12833 return resultobj;
12834 fail:
12835 return NULL;
12836 }
12837
12838
12839 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
12840 PyObject *resultobj = NULL;
12841 wxJoystick *arg1 = (wxJoystick *) 0 ;
12842 int arg2 ;
12843 PyObject * obj0 = 0 ;
12844 PyObject * obj1 = 0 ;
12845 char *kwnames[] = {
12846 (char *) "self",(char *) "threshold", NULL
12847 };
12848
12849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
12850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12851 if (SWIG_arg_fail(1)) SWIG_fail;
12852 {
12853 arg2 = static_cast<int >(SWIG_As_int(obj1));
12854 if (SWIG_arg_fail(2)) SWIG_fail;
12855 }
12856 {
12857 PyThreadState* __tstate = wxPyBeginAllowThreads();
12858 (arg1)->SetMovementThreshold(arg2);
12859
12860 wxPyEndAllowThreads(__tstate);
12861 if (PyErr_Occurred()) SWIG_fail;
12862 }
12863 Py_INCREF(Py_None); resultobj = Py_None;
12864 return resultobj;
12865 fail:
12866 return NULL;
12867 }
12868
12869
12870 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
12871 PyObject *resultobj = NULL;
12872 wxJoystick *arg1 = (wxJoystick *) 0 ;
12873 bool result;
12874 PyObject * obj0 = 0 ;
12875 char *kwnames[] = {
12876 (char *) "self", NULL
12877 };
12878
12879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
12880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12881 if (SWIG_arg_fail(1)) SWIG_fail;
12882 {
12883 PyThreadState* __tstate = wxPyBeginAllowThreads();
12884 result = (bool)(arg1)->IsOk();
12885
12886 wxPyEndAllowThreads(__tstate);
12887 if (PyErr_Occurred()) SWIG_fail;
12888 }
12889 {
12890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12891 }
12892 return resultobj;
12893 fail:
12894 return NULL;
12895 }
12896
12897
12898 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
12899 PyObject *resultobj = NULL;
12900 wxJoystick *arg1 = (wxJoystick *) 0 ;
12901 int result;
12902 PyObject * obj0 = 0 ;
12903 char *kwnames[] = {
12904 (char *) "self", NULL
12905 };
12906
12907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
12908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12909 if (SWIG_arg_fail(1)) SWIG_fail;
12910 {
12911 PyThreadState* __tstate = wxPyBeginAllowThreads();
12912 result = (int)(arg1)->GetNumberJoysticks();
12913
12914 wxPyEndAllowThreads(__tstate);
12915 if (PyErr_Occurred()) SWIG_fail;
12916 }
12917 {
12918 resultobj = SWIG_From_int(static_cast<int >(result));
12919 }
12920 return resultobj;
12921 fail:
12922 return NULL;
12923 }
12924
12925
12926 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12927 PyObject *resultobj = NULL;
12928 wxJoystick *arg1 = (wxJoystick *) 0 ;
12929 int result;
12930 PyObject * obj0 = 0 ;
12931 char *kwnames[] = {
12932 (char *) "self", NULL
12933 };
12934
12935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12937 if (SWIG_arg_fail(1)) SWIG_fail;
12938 {
12939 PyThreadState* __tstate = wxPyBeginAllowThreads();
12940 result = (int)(arg1)->GetManufacturerId();
12941
12942 wxPyEndAllowThreads(__tstate);
12943 if (PyErr_Occurred()) SWIG_fail;
12944 }
12945 {
12946 resultobj = SWIG_From_int(static_cast<int >(result));
12947 }
12948 return resultobj;
12949 fail:
12950 return NULL;
12951 }
12952
12953
12954 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12955 PyObject *resultobj = NULL;
12956 wxJoystick *arg1 = (wxJoystick *) 0 ;
12957 int result;
12958 PyObject * obj0 = 0 ;
12959 char *kwnames[] = {
12960 (char *) "self", NULL
12961 };
12962
12963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12965 if (SWIG_arg_fail(1)) SWIG_fail;
12966 {
12967 PyThreadState* __tstate = wxPyBeginAllowThreads();
12968 result = (int)(arg1)->GetProductId();
12969
12970 wxPyEndAllowThreads(__tstate);
12971 if (PyErr_Occurred()) SWIG_fail;
12972 }
12973 {
12974 resultobj = SWIG_From_int(static_cast<int >(result));
12975 }
12976 return resultobj;
12977 fail:
12978 return NULL;
12979 }
12980
12981
12982 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12983 PyObject *resultobj = NULL;
12984 wxJoystick *arg1 = (wxJoystick *) 0 ;
12985 wxString result;
12986 PyObject * obj0 = 0 ;
12987 char *kwnames[] = {
12988 (char *) "self", NULL
12989 };
12990
12991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12993 if (SWIG_arg_fail(1)) SWIG_fail;
12994 {
12995 PyThreadState* __tstate = wxPyBeginAllowThreads();
12996 result = (arg1)->GetProductName();
12997
12998 wxPyEndAllowThreads(__tstate);
12999 if (PyErr_Occurred()) SWIG_fail;
13000 }
13001 {
13002 #if wxUSE_UNICODE
13003 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13004 #else
13005 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13006 #endif
13007 }
13008 return resultobj;
13009 fail:
13010 return NULL;
13011 }
13012
13013
13014 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
13015 PyObject *resultobj = NULL;
13016 wxJoystick *arg1 = (wxJoystick *) 0 ;
13017 int result;
13018 PyObject * obj0 = 0 ;
13019 char *kwnames[] = {
13020 (char *) "self", NULL
13021 };
13022
13023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
13024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13025 if (SWIG_arg_fail(1)) SWIG_fail;
13026 {
13027 PyThreadState* __tstate = wxPyBeginAllowThreads();
13028 result = (int)(arg1)->GetXMin();
13029
13030 wxPyEndAllowThreads(__tstate);
13031 if (PyErr_Occurred()) SWIG_fail;
13032 }
13033 {
13034 resultobj = SWIG_From_int(static_cast<int >(result));
13035 }
13036 return resultobj;
13037 fail:
13038 return NULL;
13039 }
13040
13041
13042 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
13043 PyObject *resultobj = NULL;
13044 wxJoystick *arg1 = (wxJoystick *) 0 ;
13045 int result;
13046 PyObject * obj0 = 0 ;
13047 char *kwnames[] = {
13048 (char *) "self", NULL
13049 };
13050
13051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
13052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13053 if (SWIG_arg_fail(1)) SWIG_fail;
13054 {
13055 PyThreadState* __tstate = wxPyBeginAllowThreads();
13056 result = (int)(arg1)->GetYMin();
13057
13058 wxPyEndAllowThreads(__tstate);
13059 if (PyErr_Occurred()) SWIG_fail;
13060 }
13061 {
13062 resultobj = SWIG_From_int(static_cast<int >(result));
13063 }
13064 return resultobj;
13065 fail:
13066 return NULL;
13067 }
13068
13069
13070 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
13071 PyObject *resultobj = NULL;
13072 wxJoystick *arg1 = (wxJoystick *) 0 ;
13073 int result;
13074 PyObject * obj0 = 0 ;
13075 char *kwnames[] = {
13076 (char *) "self", NULL
13077 };
13078
13079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
13080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13081 if (SWIG_arg_fail(1)) SWIG_fail;
13082 {
13083 PyThreadState* __tstate = wxPyBeginAllowThreads();
13084 result = (int)(arg1)->GetZMin();
13085
13086 wxPyEndAllowThreads(__tstate);
13087 if (PyErr_Occurred()) SWIG_fail;
13088 }
13089 {
13090 resultobj = SWIG_From_int(static_cast<int >(result));
13091 }
13092 return resultobj;
13093 fail:
13094 return NULL;
13095 }
13096
13097
13098 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
13099 PyObject *resultobj = NULL;
13100 wxJoystick *arg1 = (wxJoystick *) 0 ;
13101 int result;
13102 PyObject * obj0 = 0 ;
13103 char *kwnames[] = {
13104 (char *) "self", NULL
13105 };
13106
13107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
13108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13109 if (SWIG_arg_fail(1)) SWIG_fail;
13110 {
13111 PyThreadState* __tstate = wxPyBeginAllowThreads();
13112 result = (int)(arg1)->GetXMax();
13113
13114 wxPyEndAllowThreads(__tstate);
13115 if (PyErr_Occurred()) SWIG_fail;
13116 }
13117 {
13118 resultobj = SWIG_From_int(static_cast<int >(result));
13119 }
13120 return resultobj;
13121 fail:
13122 return NULL;
13123 }
13124
13125
13126 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
13127 PyObject *resultobj = NULL;
13128 wxJoystick *arg1 = (wxJoystick *) 0 ;
13129 int result;
13130 PyObject * obj0 = 0 ;
13131 char *kwnames[] = {
13132 (char *) "self", NULL
13133 };
13134
13135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
13136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13137 if (SWIG_arg_fail(1)) SWIG_fail;
13138 {
13139 PyThreadState* __tstate = wxPyBeginAllowThreads();
13140 result = (int)(arg1)->GetYMax();
13141
13142 wxPyEndAllowThreads(__tstate);
13143 if (PyErr_Occurred()) SWIG_fail;
13144 }
13145 {
13146 resultobj = SWIG_From_int(static_cast<int >(result));
13147 }
13148 return resultobj;
13149 fail:
13150 return NULL;
13151 }
13152
13153
13154 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
13155 PyObject *resultobj = NULL;
13156 wxJoystick *arg1 = (wxJoystick *) 0 ;
13157 int result;
13158 PyObject * obj0 = 0 ;
13159 char *kwnames[] = {
13160 (char *) "self", NULL
13161 };
13162
13163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
13164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13165 if (SWIG_arg_fail(1)) SWIG_fail;
13166 {
13167 PyThreadState* __tstate = wxPyBeginAllowThreads();
13168 result = (int)(arg1)->GetZMax();
13169
13170 wxPyEndAllowThreads(__tstate);
13171 if (PyErr_Occurred()) SWIG_fail;
13172 }
13173 {
13174 resultobj = SWIG_From_int(static_cast<int >(result));
13175 }
13176 return resultobj;
13177 fail:
13178 return NULL;
13179 }
13180
13181
13182 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
13183 PyObject *resultobj = NULL;
13184 wxJoystick *arg1 = (wxJoystick *) 0 ;
13185 int result;
13186 PyObject * obj0 = 0 ;
13187 char *kwnames[] = {
13188 (char *) "self", NULL
13189 };
13190
13191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
13192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13193 if (SWIG_arg_fail(1)) SWIG_fail;
13194 {
13195 PyThreadState* __tstate = wxPyBeginAllowThreads();
13196 result = (int)(arg1)->GetNumberButtons();
13197
13198 wxPyEndAllowThreads(__tstate);
13199 if (PyErr_Occurred()) SWIG_fail;
13200 }
13201 {
13202 resultobj = SWIG_From_int(static_cast<int >(result));
13203 }
13204 return resultobj;
13205 fail:
13206 return NULL;
13207 }
13208
13209
13210 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
13211 PyObject *resultobj = NULL;
13212 wxJoystick *arg1 = (wxJoystick *) 0 ;
13213 int result;
13214 PyObject * obj0 = 0 ;
13215 char *kwnames[] = {
13216 (char *) "self", NULL
13217 };
13218
13219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
13220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13221 if (SWIG_arg_fail(1)) SWIG_fail;
13222 {
13223 PyThreadState* __tstate = wxPyBeginAllowThreads();
13224 result = (int)(arg1)->GetNumberAxes();
13225
13226 wxPyEndAllowThreads(__tstate);
13227 if (PyErr_Occurred()) SWIG_fail;
13228 }
13229 {
13230 resultobj = SWIG_From_int(static_cast<int >(result));
13231 }
13232 return resultobj;
13233 fail:
13234 return NULL;
13235 }
13236
13237
13238 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
13239 PyObject *resultobj = NULL;
13240 wxJoystick *arg1 = (wxJoystick *) 0 ;
13241 int result;
13242 PyObject * obj0 = 0 ;
13243 char *kwnames[] = {
13244 (char *) "self", NULL
13245 };
13246
13247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
13248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13249 if (SWIG_arg_fail(1)) SWIG_fail;
13250 {
13251 PyThreadState* __tstate = wxPyBeginAllowThreads();
13252 result = (int)(arg1)->GetMaxButtons();
13253
13254 wxPyEndAllowThreads(__tstate);
13255 if (PyErr_Occurred()) SWIG_fail;
13256 }
13257 {
13258 resultobj = SWIG_From_int(static_cast<int >(result));
13259 }
13260 return resultobj;
13261 fail:
13262 return NULL;
13263 }
13264
13265
13266 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
13267 PyObject *resultobj = NULL;
13268 wxJoystick *arg1 = (wxJoystick *) 0 ;
13269 int result;
13270 PyObject * obj0 = 0 ;
13271 char *kwnames[] = {
13272 (char *) "self", NULL
13273 };
13274
13275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
13276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13277 if (SWIG_arg_fail(1)) SWIG_fail;
13278 {
13279 PyThreadState* __tstate = wxPyBeginAllowThreads();
13280 result = (int)(arg1)->GetMaxAxes();
13281
13282 wxPyEndAllowThreads(__tstate);
13283 if (PyErr_Occurred()) SWIG_fail;
13284 }
13285 {
13286 resultobj = SWIG_From_int(static_cast<int >(result));
13287 }
13288 return resultobj;
13289 fail:
13290 return NULL;
13291 }
13292
13293
13294 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
13295 PyObject *resultobj = NULL;
13296 wxJoystick *arg1 = (wxJoystick *) 0 ;
13297 int result;
13298 PyObject * obj0 = 0 ;
13299 char *kwnames[] = {
13300 (char *) "self", NULL
13301 };
13302
13303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
13304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13305 if (SWIG_arg_fail(1)) SWIG_fail;
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 result = (int)(arg1)->GetPollingMin();
13309
13310 wxPyEndAllowThreads(__tstate);
13311 if (PyErr_Occurred()) SWIG_fail;
13312 }
13313 {
13314 resultobj = SWIG_From_int(static_cast<int >(result));
13315 }
13316 return resultobj;
13317 fail:
13318 return NULL;
13319 }
13320
13321
13322 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
13323 PyObject *resultobj = NULL;
13324 wxJoystick *arg1 = (wxJoystick *) 0 ;
13325 int result;
13326 PyObject * obj0 = 0 ;
13327 char *kwnames[] = {
13328 (char *) "self", NULL
13329 };
13330
13331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
13332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13333 if (SWIG_arg_fail(1)) SWIG_fail;
13334 {
13335 PyThreadState* __tstate = wxPyBeginAllowThreads();
13336 result = (int)(arg1)->GetPollingMax();
13337
13338 wxPyEndAllowThreads(__tstate);
13339 if (PyErr_Occurred()) SWIG_fail;
13340 }
13341 {
13342 resultobj = SWIG_From_int(static_cast<int >(result));
13343 }
13344 return resultobj;
13345 fail:
13346 return NULL;
13347 }
13348
13349
13350 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
13351 PyObject *resultobj = NULL;
13352 wxJoystick *arg1 = (wxJoystick *) 0 ;
13353 int result;
13354 PyObject * obj0 = 0 ;
13355 char *kwnames[] = {
13356 (char *) "self", NULL
13357 };
13358
13359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
13360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13361 if (SWIG_arg_fail(1)) SWIG_fail;
13362 {
13363 PyThreadState* __tstate = wxPyBeginAllowThreads();
13364 result = (int)(arg1)->GetRudderMin();
13365
13366 wxPyEndAllowThreads(__tstate);
13367 if (PyErr_Occurred()) SWIG_fail;
13368 }
13369 {
13370 resultobj = SWIG_From_int(static_cast<int >(result));
13371 }
13372 return resultobj;
13373 fail:
13374 return NULL;
13375 }
13376
13377
13378 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
13379 PyObject *resultobj = NULL;
13380 wxJoystick *arg1 = (wxJoystick *) 0 ;
13381 int result;
13382 PyObject * obj0 = 0 ;
13383 char *kwnames[] = {
13384 (char *) "self", NULL
13385 };
13386
13387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
13388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13389 if (SWIG_arg_fail(1)) SWIG_fail;
13390 {
13391 PyThreadState* __tstate = wxPyBeginAllowThreads();
13392 result = (int)(arg1)->GetRudderMax();
13393
13394 wxPyEndAllowThreads(__tstate);
13395 if (PyErr_Occurred()) SWIG_fail;
13396 }
13397 {
13398 resultobj = SWIG_From_int(static_cast<int >(result));
13399 }
13400 return resultobj;
13401 fail:
13402 return NULL;
13403 }
13404
13405
13406 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
13407 PyObject *resultobj = NULL;
13408 wxJoystick *arg1 = (wxJoystick *) 0 ;
13409 int result;
13410 PyObject * obj0 = 0 ;
13411 char *kwnames[] = {
13412 (char *) "self", NULL
13413 };
13414
13415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
13416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13417 if (SWIG_arg_fail(1)) SWIG_fail;
13418 {
13419 PyThreadState* __tstate = wxPyBeginAllowThreads();
13420 result = (int)(arg1)->GetUMin();
13421
13422 wxPyEndAllowThreads(__tstate);
13423 if (PyErr_Occurred()) SWIG_fail;
13424 }
13425 {
13426 resultobj = SWIG_From_int(static_cast<int >(result));
13427 }
13428 return resultobj;
13429 fail:
13430 return NULL;
13431 }
13432
13433
13434 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
13435 PyObject *resultobj = NULL;
13436 wxJoystick *arg1 = (wxJoystick *) 0 ;
13437 int result;
13438 PyObject * obj0 = 0 ;
13439 char *kwnames[] = {
13440 (char *) "self", NULL
13441 };
13442
13443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
13444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13445 if (SWIG_arg_fail(1)) SWIG_fail;
13446 {
13447 PyThreadState* __tstate = wxPyBeginAllowThreads();
13448 result = (int)(arg1)->GetUMax();
13449
13450 wxPyEndAllowThreads(__tstate);
13451 if (PyErr_Occurred()) SWIG_fail;
13452 }
13453 {
13454 resultobj = SWIG_From_int(static_cast<int >(result));
13455 }
13456 return resultobj;
13457 fail:
13458 return NULL;
13459 }
13460
13461
13462 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
13463 PyObject *resultobj = NULL;
13464 wxJoystick *arg1 = (wxJoystick *) 0 ;
13465 int result;
13466 PyObject * obj0 = 0 ;
13467 char *kwnames[] = {
13468 (char *) "self", NULL
13469 };
13470
13471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
13472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13473 if (SWIG_arg_fail(1)) SWIG_fail;
13474 {
13475 PyThreadState* __tstate = wxPyBeginAllowThreads();
13476 result = (int)(arg1)->GetVMin();
13477
13478 wxPyEndAllowThreads(__tstate);
13479 if (PyErr_Occurred()) SWIG_fail;
13480 }
13481 {
13482 resultobj = SWIG_From_int(static_cast<int >(result));
13483 }
13484 return resultobj;
13485 fail:
13486 return NULL;
13487 }
13488
13489
13490 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
13491 PyObject *resultobj = NULL;
13492 wxJoystick *arg1 = (wxJoystick *) 0 ;
13493 int result;
13494 PyObject * obj0 = 0 ;
13495 char *kwnames[] = {
13496 (char *) "self", NULL
13497 };
13498
13499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
13500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13501 if (SWIG_arg_fail(1)) SWIG_fail;
13502 {
13503 PyThreadState* __tstate = wxPyBeginAllowThreads();
13504 result = (int)(arg1)->GetVMax();
13505
13506 wxPyEndAllowThreads(__tstate);
13507 if (PyErr_Occurred()) SWIG_fail;
13508 }
13509 {
13510 resultobj = SWIG_From_int(static_cast<int >(result));
13511 }
13512 return resultobj;
13513 fail:
13514 return NULL;
13515 }
13516
13517
13518 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
13519 PyObject *resultobj = NULL;
13520 wxJoystick *arg1 = (wxJoystick *) 0 ;
13521 bool result;
13522 PyObject * obj0 = 0 ;
13523 char *kwnames[] = {
13524 (char *) "self", NULL
13525 };
13526
13527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
13528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13529 if (SWIG_arg_fail(1)) SWIG_fail;
13530 {
13531 PyThreadState* __tstate = wxPyBeginAllowThreads();
13532 result = (bool)(arg1)->HasRudder();
13533
13534 wxPyEndAllowThreads(__tstate);
13535 if (PyErr_Occurred()) SWIG_fail;
13536 }
13537 {
13538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13539 }
13540 return resultobj;
13541 fail:
13542 return NULL;
13543 }
13544
13545
13546 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
13547 PyObject *resultobj = NULL;
13548 wxJoystick *arg1 = (wxJoystick *) 0 ;
13549 bool result;
13550 PyObject * obj0 = 0 ;
13551 char *kwnames[] = {
13552 (char *) "self", NULL
13553 };
13554
13555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
13556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13557 if (SWIG_arg_fail(1)) SWIG_fail;
13558 {
13559 PyThreadState* __tstate = wxPyBeginAllowThreads();
13560 result = (bool)(arg1)->HasZ();
13561
13562 wxPyEndAllowThreads(__tstate);
13563 if (PyErr_Occurred()) SWIG_fail;
13564 }
13565 {
13566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13567 }
13568 return resultobj;
13569 fail:
13570 return NULL;
13571 }
13572
13573
13574 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
13575 PyObject *resultobj = NULL;
13576 wxJoystick *arg1 = (wxJoystick *) 0 ;
13577 bool result;
13578 PyObject * obj0 = 0 ;
13579 char *kwnames[] = {
13580 (char *) "self", NULL
13581 };
13582
13583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
13584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13585 if (SWIG_arg_fail(1)) SWIG_fail;
13586 {
13587 PyThreadState* __tstate = wxPyBeginAllowThreads();
13588 result = (bool)(arg1)->HasU();
13589
13590 wxPyEndAllowThreads(__tstate);
13591 if (PyErr_Occurred()) SWIG_fail;
13592 }
13593 {
13594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13595 }
13596 return resultobj;
13597 fail:
13598 return NULL;
13599 }
13600
13601
13602 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
13603 PyObject *resultobj = NULL;
13604 wxJoystick *arg1 = (wxJoystick *) 0 ;
13605 bool result;
13606 PyObject * obj0 = 0 ;
13607 char *kwnames[] = {
13608 (char *) "self", NULL
13609 };
13610
13611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
13612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13613 if (SWIG_arg_fail(1)) SWIG_fail;
13614 {
13615 PyThreadState* __tstate = wxPyBeginAllowThreads();
13616 result = (bool)(arg1)->HasV();
13617
13618 wxPyEndAllowThreads(__tstate);
13619 if (PyErr_Occurred()) SWIG_fail;
13620 }
13621 {
13622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13623 }
13624 return resultobj;
13625 fail:
13626 return NULL;
13627 }
13628
13629
13630 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
13631 PyObject *resultobj = NULL;
13632 wxJoystick *arg1 = (wxJoystick *) 0 ;
13633 bool result;
13634 PyObject * obj0 = 0 ;
13635 char *kwnames[] = {
13636 (char *) "self", NULL
13637 };
13638
13639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
13640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13641 if (SWIG_arg_fail(1)) SWIG_fail;
13642 {
13643 PyThreadState* __tstate = wxPyBeginAllowThreads();
13644 result = (bool)(arg1)->HasPOV();
13645
13646 wxPyEndAllowThreads(__tstate);
13647 if (PyErr_Occurred()) SWIG_fail;
13648 }
13649 {
13650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13651 }
13652 return resultobj;
13653 fail:
13654 return NULL;
13655 }
13656
13657
13658 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
13659 PyObject *resultobj = NULL;
13660 wxJoystick *arg1 = (wxJoystick *) 0 ;
13661 bool result;
13662 PyObject * obj0 = 0 ;
13663 char *kwnames[] = {
13664 (char *) "self", NULL
13665 };
13666
13667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
13668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13669 if (SWIG_arg_fail(1)) SWIG_fail;
13670 {
13671 PyThreadState* __tstate = wxPyBeginAllowThreads();
13672 result = (bool)(arg1)->HasPOV4Dir();
13673
13674 wxPyEndAllowThreads(__tstate);
13675 if (PyErr_Occurred()) SWIG_fail;
13676 }
13677 {
13678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13679 }
13680 return resultobj;
13681 fail:
13682 return NULL;
13683 }
13684
13685
13686 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
13687 PyObject *resultobj = NULL;
13688 wxJoystick *arg1 = (wxJoystick *) 0 ;
13689 bool result;
13690 PyObject * obj0 = 0 ;
13691 char *kwnames[] = {
13692 (char *) "self", NULL
13693 };
13694
13695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
13696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13697 if (SWIG_arg_fail(1)) SWIG_fail;
13698 {
13699 PyThreadState* __tstate = wxPyBeginAllowThreads();
13700 result = (bool)(arg1)->HasPOVCTS();
13701
13702 wxPyEndAllowThreads(__tstate);
13703 if (PyErr_Occurred()) SWIG_fail;
13704 }
13705 {
13706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13707 }
13708 return resultobj;
13709 fail:
13710 return NULL;
13711 }
13712
13713
13714 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
13715 PyObject *resultobj = NULL;
13716 wxJoystick *arg1 = (wxJoystick *) 0 ;
13717 wxWindow *arg2 = (wxWindow *) 0 ;
13718 int arg3 = (int) 0 ;
13719 bool result;
13720 PyObject * obj0 = 0 ;
13721 PyObject * obj1 = 0 ;
13722 PyObject * obj2 = 0 ;
13723 char *kwnames[] = {
13724 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
13725 };
13726
13727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
13728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13729 if (SWIG_arg_fail(1)) SWIG_fail;
13730 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13731 if (SWIG_arg_fail(2)) SWIG_fail;
13732 if (obj2) {
13733 {
13734 arg3 = static_cast<int >(SWIG_As_int(obj2));
13735 if (SWIG_arg_fail(3)) SWIG_fail;
13736 }
13737 }
13738 {
13739 PyThreadState* __tstate = wxPyBeginAllowThreads();
13740 result = (bool)(arg1)->SetCapture(arg2,arg3);
13741
13742 wxPyEndAllowThreads(__tstate);
13743 if (PyErr_Occurred()) SWIG_fail;
13744 }
13745 {
13746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13747 }
13748 return resultobj;
13749 fail:
13750 return NULL;
13751 }
13752
13753
13754 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
13755 PyObject *resultobj = NULL;
13756 wxJoystick *arg1 = (wxJoystick *) 0 ;
13757 bool result;
13758 PyObject * obj0 = 0 ;
13759 char *kwnames[] = {
13760 (char *) "self", NULL
13761 };
13762
13763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
13764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13765 if (SWIG_arg_fail(1)) SWIG_fail;
13766 {
13767 PyThreadState* __tstate = wxPyBeginAllowThreads();
13768 result = (bool)(arg1)->ReleaseCapture();
13769
13770 wxPyEndAllowThreads(__tstate);
13771 if (PyErr_Occurred()) SWIG_fail;
13772 }
13773 {
13774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13775 }
13776 return resultobj;
13777 fail:
13778 return NULL;
13779 }
13780
13781
13782 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
13783 PyObject *obj;
13784 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13785 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
13786 Py_INCREF(obj);
13787 return Py_BuildValue((char *)"");
13788 }
13789 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
13790 PyObject *resultobj = NULL;
13791 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
13792 int arg2 = (int) 0 ;
13793 int arg3 = (int) wxJOYSTICK1 ;
13794 int arg4 = (int) 0 ;
13795 wxJoystickEvent *result;
13796 PyObject * obj0 = 0 ;
13797 PyObject * obj1 = 0 ;
13798 PyObject * obj2 = 0 ;
13799 PyObject * obj3 = 0 ;
13800 char *kwnames[] = {
13801 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
13802 };
13803
13804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13805 if (obj0) {
13806 {
13807 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
13808 if (SWIG_arg_fail(1)) SWIG_fail;
13809 }
13810 }
13811 if (obj1) {
13812 {
13813 arg2 = static_cast<int >(SWIG_As_int(obj1));
13814 if (SWIG_arg_fail(2)) SWIG_fail;
13815 }
13816 }
13817 if (obj2) {
13818 {
13819 arg3 = static_cast<int >(SWIG_As_int(obj2));
13820 if (SWIG_arg_fail(3)) SWIG_fail;
13821 }
13822 }
13823 if (obj3) {
13824 {
13825 arg4 = static_cast<int >(SWIG_As_int(obj3));
13826 if (SWIG_arg_fail(4)) SWIG_fail;
13827 }
13828 }
13829 {
13830 PyThreadState* __tstate = wxPyBeginAllowThreads();
13831 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
13832
13833 wxPyEndAllowThreads(__tstate);
13834 if (PyErr_Occurred()) SWIG_fail;
13835 }
13836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
13837 return resultobj;
13838 fail:
13839 return NULL;
13840 }
13841
13842
13843 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13844 PyObject *resultobj = NULL;
13845 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13846 wxPoint result;
13847 PyObject * obj0 = 0 ;
13848 char *kwnames[] = {
13849 (char *) "self", NULL
13850 };
13851
13852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
13853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13854 if (SWIG_arg_fail(1)) SWIG_fail;
13855 {
13856 PyThreadState* __tstate = wxPyBeginAllowThreads();
13857 result = ((wxJoystickEvent const *)arg1)->GetPosition();
13858
13859 wxPyEndAllowThreads(__tstate);
13860 if (PyErr_Occurred()) SWIG_fail;
13861 }
13862 {
13863 wxPoint * resultptr;
13864 resultptr = new wxPoint(static_cast<wxPoint & >(result));
13865 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
13866 }
13867 return resultobj;
13868 fail:
13869 return NULL;
13870 }
13871
13872
13873 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13874 PyObject *resultobj = NULL;
13875 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13876 int result;
13877 PyObject * obj0 = 0 ;
13878 char *kwnames[] = {
13879 (char *) "self", NULL
13880 };
13881
13882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
13883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13884 if (SWIG_arg_fail(1)) SWIG_fail;
13885 {
13886 PyThreadState* __tstate = wxPyBeginAllowThreads();
13887 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
13888
13889 wxPyEndAllowThreads(__tstate);
13890 if (PyErr_Occurred()) SWIG_fail;
13891 }
13892 {
13893 resultobj = SWIG_From_int(static_cast<int >(result));
13894 }
13895 return resultobj;
13896 fail:
13897 return NULL;
13898 }
13899
13900
13901 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13902 PyObject *resultobj = NULL;
13903 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13904 int result;
13905 PyObject * obj0 = 0 ;
13906 char *kwnames[] = {
13907 (char *) "self", NULL
13908 };
13909
13910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13912 if (SWIG_arg_fail(1)) SWIG_fail;
13913 {
13914 PyThreadState* __tstate = wxPyBeginAllowThreads();
13915 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13916
13917 wxPyEndAllowThreads(__tstate);
13918 if (PyErr_Occurred()) SWIG_fail;
13919 }
13920 {
13921 resultobj = SWIG_From_int(static_cast<int >(result));
13922 }
13923 return resultobj;
13924 fail:
13925 return NULL;
13926 }
13927
13928
13929 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13930 PyObject *resultobj = NULL;
13931 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13932 int result;
13933 PyObject * obj0 = 0 ;
13934 char *kwnames[] = {
13935 (char *) "self", NULL
13936 };
13937
13938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13940 if (SWIG_arg_fail(1)) SWIG_fail;
13941 {
13942 PyThreadState* __tstate = wxPyBeginAllowThreads();
13943 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13944
13945 wxPyEndAllowThreads(__tstate);
13946 if (PyErr_Occurred()) SWIG_fail;
13947 }
13948 {
13949 resultobj = SWIG_From_int(static_cast<int >(result));
13950 }
13951 return resultobj;
13952 fail:
13953 return NULL;
13954 }
13955
13956
13957 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13958 PyObject *resultobj = NULL;
13959 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13960 int result;
13961 PyObject * obj0 = 0 ;
13962 char *kwnames[] = {
13963 (char *) "self", NULL
13964 };
13965
13966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13968 if (SWIG_arg_fail(1)) SWIG_fail;
13969 {
13970 PyThreadState* __tstate = wxPyBeginAllowThreads();
13971 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13972
13973 wxPyEndAllowThreads(__tstate);
13974 if (PyErr_Occurred()) SWIG_fail;
13975 }
13976 {
13977 resultobj = SWIG_From_int(static_cast<int >(result));
13978 }
13979 return resultobj;
13980 fail:
13981 return NULL;
13982 }
13983
13984
13985 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13986 PyObject *resultobj = NULL;
13987 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13988 int arg2 ;
13989 PyObject * obj0 = 0 ;
13990 PyObject * obj1 = 0 ;
13991 char *kwnames[] = {
13992 (char *) "self",(char *) "stick", NULL
13993 };
13994
13995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13997 if (SWIG_arg_fail(1)) SWIG_fail;
13998 {
13999 arg2 = static_cast<int >(SWIG_As_int(obj1));
14000 if (SWIG_arg_fail(2)) SWIG_fail;
14001 }
14002 {
14003 PyThreadState* __tstate = wxPyBeginAllowThreads();
14004 (arg1)->SetJoystick(arg2);
14005
14006 wxPyEndAllowThreads(__tstate);
14007 if (PyErr_Occurred()) SWIG_fail;
14008 }
14009 Py_INCREF(Py_None); resultobj = Py_None;
14010 return resultobj;
14011 fail:
14012 return NULL;
14013 }
14014
14015
14016 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
14017 PyObject *resultobj = NULL;
14018 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14019 int arg2 ;
14020 PyObject * obj0 = 0 ;
14021 PyObject * obj1 = 0 ;
14022 char *kwnames[] = {
14023 (char *) "self",(char *) "state", NULL
14024 };
14025
14026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
14027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14028 if (SWIG_arg_fail(1)) SWIG_fail;
14029 {
14030 arg2 = static_cast<int >(SWIG_As_int(obj1));
14031 if (SWIG_arg_fail(2)) SWIG_fail;
14032 }
14033 {
14034 PyThreadState* __tstate = wxPyBeginAllowThreads();
14035 (arg1)->SetButtonState(arg2);
14036
14037 wxPyEndAllowThreads(__tstate);
14038 if (PyErr_Occurred()) SWIG_fail;
14039 }
14040 Py_INCREF(Py_None); resultobj = Py_None;
14041 return resultobj;
14042 fail:
14043 return NULL;
14044 }
14045
14046
14047 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
14048 PyObject *resultobj = NULL;
14049 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14050 int arg2 ;
14051 PyObject * obj0 = 0 ;
14052 PyObject * obj1 = 0 ;
14053 char *kwnames[] = {
14054 (char *) "self",(char *) "change", NULL
14055 };
14056
14057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
14058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14059 if (SWIG_arg_fail(1)) SWIG_fail;
14060 {
14061 arg2 = static_cast<int >(SWIG_As_int(obj1));
14062 if (SWIG_arg_fail(2)) SWIG_fail;
14063 }
14064 {
14065 PyThreadState* __tstate = wxPyBeginAllowThreads();
14066 (arg1)->SetButtonChange(arg2);
14067
14068 wxPyEndAllowThreads(__tstate);
14069 if (PyErr_Occurred()) SWIG_fail;
14070 }
14071 Py_INCREF(Py_None); resultobj = Py_None;
14072 return resultobj;
14073 fail:
14074 return NULL;
14075 }
14076
14077
14078 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
14079 PyObject *resultobj = NULL;
14080 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14081 wxPoint *arg2 = 0 ;
14082 wxPoint temp2 ;
14083 PyObject * obj0 = 0 ;
14084 PyObject * obj1 = 0 ;
14085 char *kwnames[] = {
14086 (char *) "self",(char *) "pos", NULL
14087 };
14088
14089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
14090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14091 if (SWIG_arg_fail(1)) SWIG_fail;
14092 {
14093 arg2 = &temp2;
14094 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14095 }
14096 {
14097 PyThreadState* __tstate = wxPyBeginAllowThreads();
14098 (arg1)->SetPosition((wxPoint const &)*arg2);
14099
14100 wxPyEndAllowThreads(__tstate);
14101 if (PyErr_Occurred()) SWIG_fail;
14102 }
14103 Py_INCREF(Py_None); resultobj = Py_None;
14104 return resultobj;
14105 fail:
14106 return NULL;
14107 }
14108
14109
14110 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
14111 PyObject *resultobj = NULL;
14112 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14113 int arg2 ;
14114 PyObject * obj0 = 0 ;
14115 PyObject * obj1 = 0 ;
14116 char *kwnames[] = {
14117 (char *) "self",(char *) "zPos", NULL
14118 };
14119
14120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
14121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14122 if (SWIG_arg_fail(1)) SWIG_fail;
14123 {
14124 arg2 = static_cast<int >(SWIG_As_int(obj1));
14125 if (SWIG_arg_fail(2)) SWIG_fail;
14126 }
14127 {
14128 PyThreadState* __tstate = wxPyBeginAllowThreads();
14129 (arg1)->SetZPosition(arg2);
14130
14131 wxPyEndAllowThreads(__tstate);
14132 if (PyErr_Occurred()) SWIG_fail;
14133 }
14134 Py_INCREF(Py_None); resultobj = Py_None;
14135 return resultobj;
14136 fail:
14137 return NULL;
14138 }
14139
14140
14141 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
14142 PyObject *resultobj = NULL;
14143 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14144 bool result;
14145 PyObject * obj0 = 0 ;
14146 char *kwnames[] = {
14147 (char *) "self", NULL
14148 };
14149
14150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
14151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14152 if (SWIG_arg_fail(1)) SWIG_fail;
14153 {
14154 PyThreadState* __tstate = wxPyBeginAllowThreads();
14155 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
14156
14157 wxPyEndAllowThreads(__tstate);
14158 if (PyErr_Occurred()) SWIG_fail;
14159 }
14160 {
14161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14162 }
14163 return resultobj;
14164 fail:
14165 return NULL;
14166 }
14167
14168
14169 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
14170 PyObject *resultobj = NULL;
14171 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14172 bool result;
14173 PyObject * obj0 = 0 ;
14174 char *kwnames[] = {
14175 (char *) "self", NULL
14176 };
14177
14178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
14179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14180 if (SWIG_arg_fail(1)) SWIG_fail;
14181 {
14182 PyThreadState* __tstate = wxPyBeginAllowThreads();
14183 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
14184
14185 wxPyEndAllowThreads(__tstate);
14186 if (PyErr_Occurred()) SWIG_fail;
14187 }
14188 {
14189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14190 }
14191 return resultobj;
14192 fail:
14193 return NULL;
14194 }
14195
14196
14197 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
14198 PyObject *resultobj = NULL;
14199 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14200 bool result;
14201 PyObject * obj0 = 0 ;
14202 char *kwnames[] = {
14203 (char *) "self", NULL
14204 };
14205
14206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
14207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14208 if (SWIG_arg_fail(1)) SWIG_fail;
14209 {
14210 PyThreadState* __tstate = wxPyBeginAllowThreads();
14211 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
14212
14213 wxPyEndAllowThreads(__tstate);
14214 if (PyErr_Occurred()) SWIG_fail;
14215 }
14216 {
14217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14218 }
14219 return resultobj;
14220 fail:
14221 return NULL;
14222 }
14223
14224
14225 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
14226 PyObject *resultobj = NULL;
14227 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14228 int arg2 = (int) wxJOY_BUTTON_ANY ;
14229 bool result;
14230 PyObject * obj0 = 0 ;
14231 PyObject * obj1 = 0 ;
14232 char *kwnames[] = {
14233 (char *) "self",(char *) "but", NULL
14234 };
14235
14236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
14237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14238 if (SWIG_arg_fail(1)) SWIG_fail;
14239 if (obj1) {
14240 {
14241 arg2 = static_cast<int >(SWIG_As_int(obj1));
14242 if (SWIG_arg_fail(2)) SWIG_fail;
14243 }
14244 }
14245 {
14246 PyThreadState* __tstate = wxPyBeginAllowThreads();
14247 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
14248
14249 wxPyEndAllowThreads(__tstate);
14250 if (PyErr_Occurred()) SWIG_fail;
14251 }
14252 {
14253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14254 }
14255 return resultobj;
14256 fail:
14257 return NULL;
14258 }
14259
14260
14261 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
14262 PyObject *resultobj = NULL;
14263 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14264 int arg2 = (int) wxJOY_BUTTON_ANY ;
14265 bool result;
14266 PyObject * obj0 = 0 ;
14267 PyObject * obj1 = 0 ;
14268 char *kwnames[] = {
14269 (char *) "self",(char *) "but", NULL
14270 };
14271
14272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
14273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14274 if (SWIG_arg_fail(1)) SWIG_fail;
14275 if (obj1) {
14276 {
14277 arg2 = static_cast<int >(SWIG_As_int(obj1));
14278 if (SWIG_arg_fail(2)) SWIG_fail;
14279 }
14280 }
14281 {
14282 PyThreadState* __tstate = wxPyBeginAllowThreads();
14283 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
14284
14285 wxPyEndAllowThreads(__tstate);
14286 if (PyErr_Occurred()) SWIG_fail;
14287 }
14288 {
14289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14290 }
14291 return resultobj;
14292 fail:
14293 return NULL;
14294 }
14295
14296
14297 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
14298 PyObject *resultobj = NULL;
14299 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14300 int arg2 = (int) wxJOY_BUTTON_ANY ;
14301 bool result;
14302 PyObject * obj0 = 0 ;
14303 PyObject * obj1 = 0 ;
14304 char *kwnames[] = {
14305 (char *) "self",(char *) "but", NULL
14306 };
14307
14308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
14309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14310 if (SWIG_arg_fail(1)) SWIG_fail;
14311 if (obj1) {
14312 {
14313 arg2 = static_cast<int >(SWIG_As_int(obj1));
14314 if (SWIG_arg_fail(2)) SWIG_fail;
14315 }
14316 }
14317 {
14318 PyThreadState* __tstate = wxPyBeginAllowThreads();
14319 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
14320
14321 wxPyEndAllowThreads(__tstate);
14322 if (PyErr_Occurred()) SWIG_fail;
14323 }
14324 {
14325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14326 }
14327 return resultobj;
14328 fail:
14329 return NULL;
14330 }
14331
14332
14333 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
14334 PyObject *obj;
14335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14336 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
14337 Py_INCREF(obj);
14338 return Py_BuildValue((char *)"");
14339 }
14340 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
14341 PyObject *resultobj = NULL;
14342 wxString const &arg1_defvalue = wxPyEmptyString ;
14343 wxString *arg1 = (wxString *) &arg1_defvalue ;
14344 wxSound *result;
14345 bool temp1 = false ;
14346 PyObject * obj0 = 0 ;
14347 char *kwnames[] = {
14348 (char *) "fileName", NULL
14349 };
14350
14351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
14352 if (obj0) {
14353 {
14354 arg1 = wxString_in_helper(obj0);
14355 if (arg1 == NULL) SWIG_fail;
14356 temp1 = true;
14357 }
14358 }
14359 {
14360 if (!wxPyCheckForApp()) SWIG_fail;
14361 PyThreadState* __tstate = wxPyBeginAllowThreads();
14362 result = (wxSound *)new_wxSound((wxString const &)*arg1);
14363
14364 wxPyEndAllowThreads(__tstate);
14365 if (PyErr_Occurred()) SWIG_fail;
14366 }
14367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
14368 {
14369 if (temp1)
14370 delete arg1;
14371 }
14372 return resultobj;
14373 fail:
14374 {
14375 if (temp1)
14376 delete arg1;
14377 }
14378 return NULL;
14379 }
14380
14381
14382 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
14383 PyObject *resultobj = NULL;
14384 PyObject *arg1 = (PyObject *) 0 ;
14385 wxSound *result;
14386 PyObject * obj0 = 0 ;
14387 char *kwnames[] = {
14388 (char *) "data", NULL
14389 };
14390
14391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
14392 arg1 = obj0;
14393 {
14394 if (!wxPyCheckForApp()) SWIG_fail;
14395 PyThreadState* __tstate = wxPyBeginAllowThreads();
14396 result = (wxSound *)new_wxSound(arg1);
14397
14398 wxPyEndAllowThreads(__tstate);
14399 if (PyErr_Occurred()) SWIG_fail;
14400 }
14401 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
14402 return resultobj;
14403 fail:
14404 return NULL;
14405 }
14406
14407
14408 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
14409 PyObject *resultobj = NULL;
14410 wxSound *arg1 = (wxSound *) 0 ;
14411 PyObject * obj0 = 0 ;
14412 char *kwnames[] = {
14413 (char *) "self", NULL
14414 };
14415
14416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
14417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14418 if (SWIG_arg_fail(1)) SWIG_fail;
14419 {
14420 PyThreadState* __tstate = wxPyBeginAllowThreads();
14421 delete arg1;
14422
14423 wxPyEndAllowThreads(__tstate);
14424 if (PyErr_Occurred()) SWIG_fail;
14425 }
14426 Py_INCREF(Py_None); resultobj = Py_None;
14427 return resultobj;
14428 fail:
14429 return NULL;
14430 }
14431
14432
14433 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
14434 PyObject *resultobj = NULL;
14435 wxSound *arg1 = (wxSound *) 0 ;
14436 wxString *arg2 = 0 ;
14437 bool result;
14438 bool temp2 = false ;
14439 PyObject * obj0 = 0 ;
14440 PyObject * obj1 = 0 ;
14441 char *kwnames[] = {
14442 (char *) "self",(char *) "fileName", NULL
14443 };
14444
14445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
14446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14447 if (SWIG_arg_fail(1)) SWIG_fail;
14448 {
14449 arg2 = wxString_in_helper(obj1);
14450 if (arg2 == NULL) SWIG_fail;
14451 temp2 = true;
14452 }
14453 {
14454 PyThreadState* __tstate = wxPyBeginAllowThreads();
14455 result = (bool)(arg1)->Create((wxString const &)*arg2);
14456
14457 wxPyEndAllowThreads(__tstate);
14458 if (PyErr_Occurred()) SWIG_fail;
14459 }
14460 {
14461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14462 }
14463 {
14464 if (temp2)
14465 delete arg2;
14466 }
14467 return resultobj;
14468 fail:
14469 {
14470 if (temp2)
14471 delete arg2;
14472 }
14473 return NULL;
14474 }
14475
14476
14477 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
14478 PyObject *resultobj = NULL;
14479 wxSound *arg1 = (wxSound *) 0 ;
14480 PyObject *arg2 = (PyObject *) 0 ;
14481 bool result;
14482 PyObject * obj0 = 0 ;
14483 PyObject * obj1 = 0 ;
14484 char *kwnames[] = {
14485 (char *) "self",(char *) "data", NULL
14486 };
14487
14488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
14489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14490 if (SWIG_arg_fail(1)) SWIG_fail;
14491 arg2 = obj1;
14492 {
14493 PyThreadState* __tstate = wxPyBeginAllowThreads();
14494 result = (bool)wxSound_CreateFromData(arg1,arg2);
14495
14496 wxPyEndAllowThreads(__tstate);
14497 if (PyErr_Occurred()) SWIG_fail;
14498 }
14499 {
14500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14501 }
14502 return resultobj;
14503 fail:
14504 return NULL;
14505 }
14506
14507
14508 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
14509 PyObject *resultobj = NULL;
14510 wxSound *arg1 = (wxSound *) 0 ;
14511 bool result;
14512 PyObject * obj0 = 0 ;
14513 char *kwnames[] = {
14514 (char *) "self", NULL
14515 };
14516
14517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
14518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14519 if (SWIG_arg_fail(1)) SWIG_fail;
14520 {
14521 PyThreadState* __tstate = wxPyBeginAllowThreads();
14522 result = (bool)(arg1)->IsOk();
14523
14524 wxPyEndAllowThreads(__tstate);
14525 if (PyErr_Occurred()) SWIG_fail;
14526 }
14527 {
14528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14529 }
14530 return resultobj;
14531 fail:
14532 return NULL;
14533 }
14534
14535
14536 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
14537 PyObject *resultobj = NULL;
14538 wxSound *arg1 = (wxSound *) 0 ;
14539 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
14540 bool result;
14541 PyObject * obj0 = 0 ;
14542 PyObject * obj1 = 0 ;
14543 char *kwnames[] = {
14544 (char *) "self",(char *) "flags", NULL
14545 };
14546
14547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
14548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14549 if (SWIG_arg_fail(1)) SWIG_fail;
14550 if (obj1) {
14551 {
14552 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
14553 if (SWIG_arg_fail(2)) SWIG_fail;
14554 }
14555 }
14556 {
14557 if (!wxPyCheckForApp()) SWIG_fail;
14558 PyThreadState* __tstate = wxPyBeginAllowThreads();
14559 result = (bool)((wxSound const *)arg1)->Play(arg2);
14560
14561 wxPyEndAllowThreads(__tstate);
14562 if (PyErr_Occurred()) SWIG_fail;
14563 }
14564 {
14565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14566 }
14567 return resultobj;
14568 fail:
14569 return NULL;
14570 }
14571
14572
14573 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
14574 PyObject *resultobj = NULL;
14575 wxString *arg1 = 0 ;
14576 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
14577 bool result;
14578 bool temp1 = false ;
14579 PyObject * obj0 = 0 ;
14580 PyObject * obj1 = 0 ;
14581 char *kwnames[] = {
14582 (char *) "filename",(char *) "flags", NULL
14583 };
14584
14585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
14586 {
14587 arg1 = wxString_in_helper(obj0);
14588 if (arg1 == NULL) SWIG_fail;
14589 temp1 = true;
14590 }
14591 if (obj1) {
14592 {
14593 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
14594 if (SWIG_arg_fail(2)) SWIG_fail;
14595 }
14596 }
14597 {
14598 if (!wxPyCheckForApp()) SWIG_fail;
14599 PyThreadState* __tstate = wxPyBeginAllowThreads();
14600 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
14601
14602 wxPyEndAllowThreads(__tstate);
14603 if (PyErr_Occurred()) SWIG_fail;
14604 }
14605 {
14606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14607 }
14608 {
14609 if (temp1)
14610 delete arg1;
14611 }
14612 return resultobj;
14613 fail:
14614 {
14615 if (temp1)
14616 delete arg1;
14617 }
14618 return NULL;
14619 }
14620
14621
14622 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
14623 PyObject *resultobj = NULL;
14624 char *kwnames[] = {
14625 NULL
14626 };
14627
14628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
14629 {
14630 if (!wxPyCheckForApp()) SWIG_fail;
14631 PyThreadState* __tstate = wxPyBeginAllowThreads();
14632 wxSound::Stop();
14633
14634 wxPyEndAllowThreads(__tstate);
14635 if (PyErr_Occurred()) SWIG_fail;
14636 }
14637 Py_INCREF(Py_None); resultobj = Py_None;
14638 return resultobj;
14639 fail:
14640 return NULL;
14641 }
14642
14643
14644 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
14645 PyObject *obj;
14646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14647 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
14648 Py_INCREF(obj);
14649 return Py_BuildValue((char *)"");
14650 }
14651 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14652 PyObject *resultobj = NULL;
14653 wxString *arg1 = 0 ;
14654 wxString *arg2 = 0 ;
14655 wxString *arg3 = 0 ;
14656 wxString *arg4 = 0 ;
14657 wxFileTypeInfo *result;
14658 bool temp1 = false ;
14659 bool temp2 = false ;
14660 bool temp3 = false ;
14661 bool temp4 = false ;
14662 PyObject * obj0 = 0 ;
14663 PyObject * obj1 = 0 ;
14664 PyObject * obj2 = 0 ;
14665 PyObject * obj3 = 0 ;
14666 char *kwnames[] = {
14667 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
14668 };
14669
14670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14671 {
14672 arg1 = wxString_in_helper(obj0);
14673 if (arg1 == NULL) SWIG_fail;
14674 temp1 = true;
14675 }
14676 {
14677 arg2 = wxString_in_helper(obj1);
14678 if (arg2 == NULL) SWIG_fail;
14679 temp2 = true;
14680 }
14681 {
14682 arg3 = wxString_in_helper(obj2);
14683 if (arg3 == NULL) SWIG_fail;
14684 temp3 = true;
14685 }
14686 {
14687 arg4 = wxString_in_helper(obj3);
14688 if (arg4 == NULL) SWIG_fail;
14689 temp4 = true;
14690 }
14691 {
14692 PyThreadState* __tstate = wxPyBeginAllowThreads();
14693 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
14694
14695 wxPyEndAllowThreads(__tstate);
14696 if (PyErr_Occurred()) SWIG_fail;
14697 }
14698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
14699 {
14700 if (temp1)
14701 delete arg1;
14702 }
14703 {
14704 if (temp2)
14705 delete arg2;
14706 }
14707 {
14708 if (temp3)
14709 delete arg3;
14710 }
14711 {
14712 if (temp4)
14713 delete arg4;
14714 }
14715 return resultobj;
14716 fail:
14717 {
14718 if (temp1)
14719 delete arg1;
14720 }
14721 {
14722 if (temp2)
14723 delete arg2;
14724 }
14725 {
14726 if (temp3)
14727 delete arg3;
14728 }
14729 {
14730 if (temp4)
14731 delete arg4;
14732 }
14733 return NULL;
14734 }
14735
14736
14737 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
14738 PyObject *resultobj = NULL;
14739 wxArrayString *arg1 = 0 ;
14740 wxFileTypeInfo *result;
14741 bool temp1 = false ;
14742 PyObject * obj0 = 0 ;
14743 char *kwnames[] = {
14744 (char *) "sArray", NULL
14745 };
14746
14747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
14748 {
14749 if (! PySequence_Check(obj0)) {
14750 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
14751 SWIG_fail;
14752 }
14753 arg1 = new wxArrayString;
14754 temp1 = true;
14755 int i, len=PySequence_Length(obj0);
14756 for (i=0; i<len; i++) {
14757 PyObject* item = PySequence_GetItem(obj0, i);
14758 wxString* s = wxString_in_helper(item);
14759 if (PyErr_Occurred()) SWIG_fail;
14760 arg1->Add(*s);
14761 delete s;
14762 Py_DECREF(item);
14763 }
14764 }
14765 {
14766 PyThreadState* __tstate = wxPyBeginAllowThreads();
14767 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
14768
14769 wxPyEndAllowThreads(__tstate);
14770 if (PyErr_Occurred()) SWIG_fail;
14771 }
14772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
14773 {
14774 if (temp1) delete arg1;
14775 }
14776 return resultobj;
14777 fail:
14778 {
14779 if (temp1) delete arg1;
14780 }
14781 return NULL;
14782 }
14783
14784
14785 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14786 PyObject *resultobj = NULL;
14787 wxFileTypeInfo *result;
14788 char *kwnames[] = {
14789 NULL
14790 };
14791
14792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
14793 {
14794 PyThreadState* __tstate = wxPyBeginAllowThreads();
14795 result = (wxFileTypeInfo *)new wxFileTypeInfo();
14796
14797 wxPyEndAllowThreads(__tstate);
14798 if (PyErr_Occurred()) SWIG_fail;
14799 }
14800 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
14801 return resultobj;
14802 fail:
14803 return NULL;
14804 }
14805
14806
14807 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
14808 PyObject *resultobj = NULL;
14809 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14810 bool result;
14811 PyObject * obj0 = 0 ;
14812 char *kwnames[] = {
14813 (char *) "self", NULL
14814 };
14815
14816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
14817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14818 if (SWIG_arg_fail(1)) SWIG_fail;
14819 {
14820 PyThreadState* __tstate = wxPyBeginAllowThreads();
14821 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
14822
14823 wxPyEndAllowThreads(__tstate);
14824 if (PyErr_Occurred()) SWIG_fail;
14825 }
14826 {
14827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14828 }
14829 return resultobj;
14830 fail:
14831 return NULL;
14832 }
14833
14834
14835 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14836 PyObject *resultobj = NULL;
14837 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14838 wxString *arg2 = 0 ;
14839 int arg3 = (int) 0 ;
14840 bool temp2 = false ;
14841 PyObject * obj0 = 0 ;
14842 PyObject * obj1 = 0 ;
14843 PyObject * obj2 = 0 ;
14844 char *kwnames[] = {
14845 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
14846 };
14847
14848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14850 if (SWIG_arg_fail(1)) SWIG_fail;
14851 {
14852 arg2 = wxString_in_helper(obj1);
14853 if (arg2 == NULL) SWIG_fail;
14854 temp2 = true;
14855 }
14856 if (obj2) {
14857 {
14858 arg3 = static_cast<int >(SWIG_As_int(obj2));
14859 if (SWIG_arg_fail(3)) SWIG_fail;
14860 }
14861 }
14862 {
14863 PyThreadState* __tstate = wxPyBeginAllowThreads();
14864 (arg1)->SetIcon((wxString const &)*arg2,arg3);
14865
14866 wxPyEndAllowThreads(__tstate);
14867 if (PyErr_Occurred()) SWIG_fail;
14868 }
14869 Py_INCREF(Py_None); resultobj = Py_None;
14870 {
14871 if (temp2)
14872 delete arg2;
14873 }
14874 return resultobj;
14875 fail:
14876 {
14877 if (temp2)
14878 delete arg2;
14879 }
14880 return NULL;
14881 }
14882
14883
14884 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14885 PyObject *resultobj = NULL;
14886 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14887 wxString *arg2 = 0 ;
14888 bool temp2 = false ;
14889 PyObject * obj0 = 0 ;
14890 PyObject * obj1 = 0 ;
14891 char *kwnames[] = {
14892 (char *) "self",(char *) "shortDesc", NULL
14893 };
14894
14895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
14896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14897 if (SWIG_arg_fail(1)) SWIG_fail;
14898 {
14899 arg2 = wxString_in_helper(obj1);
14900 if (arg2 == NULL) SWIG_fail;
14901 temp2 = true;
14902 }
14903 {
14904 PyThreadState* __tstate = wxPyBeginAllowThreads();
14905 (arg1)->SetShortDesc((wxString const &)*arg2);
14906
14907 wxPyEndAllowThreads(__tstate);
14908 if (PyErr_Occurred()) SWIG_fail;
14909 }
14910 Py_INCREF(Py_None); resultobj = Py_None;
14911 {
14912 if (temp2)
14913 delete arg2;
14914 }
14915 return resultobj;
14916 fail:
14917 {
14918 if (temp2)
14919 delete arg2;
14920 }
14921 return NULL;
14922 }
14923
14924
14925 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14926 PyObject *resultobj = NULL;
14927 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14928 wxString *result;
14929 PyObject * obj0 = 0 ;
14930 char *kwnames[] = {
14931 (char *) "self", NULL
14932 };
14933
14934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14936 if (SWIG_arg_fail(1)) SWIG_fail;
14937 {
14938 PyThreadState* __tstate = wxPyBeginAllowThreads();
14939 {
14940 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14941 result = (wxString *) &_result_ref;
14942 }
14943
14944 wxPyEndAllowThreads(__tstate);
14945 if (PyErr_Occurred()) SWIG_fail;
14946 }
14947 {
14948 #if wxUSE_UNICODE
14949 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14950 #else
14951 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14952 #endif
14953 }
14954 return resultobj;
14955 fail:
14956 return NULL;
14957 }
14958
14959
14960 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14961 PyObject *resultobj = NULL;
14962 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14963 wxString *result;
14964 PyObject * obj0 = 0 ;
14965 char *kwnames[] = {
14966 (char *) "self", NULL
14967 };
14968
14969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14971 if (SWIG_arg_fail(1)) SWIG_fail;
14972 {
14973 PyThreadState* __tstate = wxPyBeginAllowThreads();
14974 {
14975 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14976 result = (wxString *) &_result_ref;
14977 }
14978
14979 wxPyEndAllowThreads(__tstate);
14980 if (PyErr_Occurred()) SWIG_fail;
14981 }
14982 {
14983 #if wxUSE_UNICODE
14984 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14985 #else
14986 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14987 #endif
14988 }
14989 return resultobj;
14990 fail:
14991 return NULL;
14992 }
14993
14994
14995 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14996 PyObject *resultobj = NULL;
14997 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14998 wxString *result;
14999 PyObject * obj0 = 0 ;
15000 char *kwnames[] = {
15001 (char *) "self", NULL
15002 };
15003
15004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
15005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15006 if (SWIG_arg_fail(1)) SWIG_fail;
15007 {
15008 PyThreadState* __tstate = wxPyBeginAllowThreads();
15009 {
15010 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
15011 result = (wxString *) &_result_ref;
15012 }
15013
15014 wxPyEndAllowThreads(__tstate);
15015 if (PyErr_Occurred()) SWIG_fail;
15016 }
15017 {
15018 #if wxUSE_UNICODE
15019 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15020 #else
15021 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15022 #endif
15023 }
15024 return resultobj;
15025 fail:
15026 return NULL;
15027 }
15028
15029
15030 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
15031 PyObject *resultobj = NULL;
15032 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15033 wxString *result;
15034 PyObject * obj0 = 0 ;
15035 char *kwnames[] = {
15036 (char *) "self", NULL
15037 };
15038
15039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
15040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15041 if (SWIG_arg_fail(1)) SWIG_fail;
15042 {
15043 PyThreadState* __tstate = wxPyBeginAllowThreads();
15044 {
15045 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
15046 result = (wxString *) &_result_ref;
15047 }
15048
15049 wxPyEndAllowThreads(__tstate);
15050 if (PyErr_Occurred()) SWIG_fail;
15051 }
15052 {
15053 #if wxUSE_UNICODE
15054 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15055 #else
15056 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15057 #endif
15058 }
15059 return resultobj;
15060 fail:
15061 return NULL;
15062 }
15063
15064
15065 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
15066 PyObject *resultobj = NULL;
15067 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15068 wxString *result;
15069 PyObject * obj0 = 0 ;
15070 char *kwnames[] = {
15071 (char *) "self", NULL
15072 };
15073
15074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
15075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15076 if (SWIG_arg_fail(1)) SWIG_fail;
15077 {
15078 PyThreadState* __tstate = wxPyBeginAllowThreads();
15079 {
15080 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
15081 result = (wxString *) &_result_ref;
15082 }
15083
15084 wxPyEndAllowThreads(__tstate);
15085 if (PyErr_Occurred()) SWIG_fail;
15086 }
15087 {
15088 #if wxUSE_UNICODE
15089 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15090 #else
15091 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15092 #endif
15093 }
15094 return resultobj;
15095 fail:
15096 return NULL;
15097 }
15098
15099
15100 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
15101 PyObject *resultobj = NULL;
15102 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15103 wxArrayString *result;
15104 PyObject * obj0 = 0 ;
15105 char *kwnames[] = {
15106 (char *) "self", NULL
15107 };
15108
15109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
15110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15111 if (SWIG_arg_fail(1)) SWIG_fail;
15112 {
15113 PyThreadState* __tstate = wxPyBeginAllowThreads();
15114 {
15115 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
15116 result = (wxArrayString *) &_result_ref;
15117 }
15118
15119 wxPyEndAllowThreads(__tstate);
15120 if (PyErr_Occurred()) SWIG_fail;
15121 }
15122 {
15123 resultobj = wxArrayString2PyList_helper(*result);
15124 }
15125 return resultobj;
15126 fail:
15127 return NULL;
15128 }
15129
15130
15131 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
15132 PyObject *resultobj = NULL;
15133 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15134 int result;
15135 PyObject * obj0 = 0 ;
15136 char *kwnames[] = {
15137 (char *) "self", NULL
15138 };
15139
15140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
15141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15142 if (SWIG_arg_fail(1)) SWIG_fail;
15143 {
15144 PyThreadState* __tstate = wxPyBeginAllowThreads();
15145 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
15146
15147 wxPyEndAllowThreads(__tstate);
15148 if (PyErr_Occurred()) SWIG_fail;
15149 }
15150 {
15151 resultobj = SWIG_From_int(static_cast<int >(result));
15152 }
15153 return resultobj;
15154 fail:
15155 return NULL;
15156 }
15157
15158
15159 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
15160 PyObject *resultobj = NULL;
15161 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15162 wxString *result;
15163 PyObject * obj0 = 0 ;
15164 char *kwnames[] = {
15165 (char *) "self", NULL
15166 };
15167
15168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
15169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15170 if (SWIG_arg_fail(1)) SWIG_fail;
15171 {
15172 PyThreadState* __tstate = wxPyBeginAllowThreads();
15173 {
15174 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
15175 result = (wxString *) &_result_ref;
15176 }
15177
15178 wxPyEndAllowThreads(__tstate);
15179 if (PyErr_Occurred()) SWIG_fail;
15180 }
15181 {
15182 #if wxUSE_UNICODE
15183 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15184 #else
15185 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15186 #endif
15187 }
15188 return resultobj;
15189 fail:
15190 return NULL;
15191 }
15192
15193
15194 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
15195 PyObject *resultobj = NULL;
15196 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15197 int result;
15198 PyObject * obj0 = 0 ;
15199 char *kwnames[] = {
15200 (char *) "self", NULL
15201 };
15202
15203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
15204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15205 if (SWIG_arg_fail(1)) SWIG_fail;
15206 {
15207 PyThreadState* __tstate = wxPyBeginAllowThreads();
15208 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
15209
15210 wxPyEndAllowThreads(__tstate);
15211 if (PyErr_Occurred()) SWIG_fail;
15212 }
15213 {
15214 resultobj = SWIG_From_int(static_cast<int >(result));
15215 }
15216 return resultobj;
15217 fail:
15218 return NULL;
15219 }
15220
15221
15222 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
15223 PyObject *obj;
15224 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15225 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
15226 Py_INCREF(obj);
15227 return Py_BuildValue((char *)"");
15228 }
15229 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
15230 PyObject *resultobj = NULL;
15231 wxFileTypeInfo *arg1 = 0 ;
15232 wxFileType *result;
15233 PyObject * obj0 = 0 ;
15234 char *kwnames[] = {
15235 (char *) "ftInfo", NULL
15236 };
15237
15238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
15239 {
15240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15241 if (SWIG_arg_fail(1)) SWIG_fail;
15242 if (arg1 == NULL) {
15243 SWIG_null_ref("wxFileTypeInfo");
15244 }
15245 if (SWIG_arg_fail(1)) SWIG_fail;
15246 }
15247 {
15248 PyThreadState* __tstate = wxPyBeginAllowThreads();
15249 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
15250
15251 wxPyEndAllowThreads(__tstate);
15252 if (PyErr_Occurred()) SWIG_fail;
15253 }
15254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15255 return resultobj;
15256 fail:
15257 return NULL;
15258 }
15259
15260
15261 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
15262 PyObject *resultobj = NULL;
15263 wxFileType *arg1 = (wxFileType *) 0 ;
15264 PyObject * obj0 = 0 ;
15265 char *kwnames[] = {
15266 (char *) "self", NULL
15267 };
15268
15269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
15270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15271 if (SWIG_arg_fail(1)) SWIG_fail;
15272 {
15273 PyThreadState* __tstate = wxPyBeginAllowThreads();
15274 delete arg1;
15275
15276 wxPyEndAllowThreads(__tstate);
15277 if (PyErr_Occurred()) SWIG_fail;
15278 }
15279 Py_INCREF(Py_None); resultobj = Py_None;
15280 return resultobj;
15281 fail:
15282 return NULL;
15283 }
15284
15285
15286 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15287 PyObject *resultobj = NULL;
15288 wxFileType *arg1 = (wxFileType *) 0 ;
15289 PyObject *result;
15290 PyObject * obj0 = 0 ;
15291 char *kwnames[] = {
15292 (char *) "self", NULL
15293 };
15294
15295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
15296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15297 if (SWIG_arg_fail(1)) SWIG_fail;
15298 {
15299 PyThreadState* __tstate = wxPyBeginAllowThreads();
15300 result = (PyObject *)wxFileType_GetMimeType(arg1);
15301
15302 wxPyEndAllowThreads(__tstate);
15303 if (PyErr_Occurred()) SWIG_fail;
15304 }
15305 resultobj = result;
15306 return resultobj;
15307 fail:
15308 return NULL;
15309 }
15310
15311
15312 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15313 PyObject *resultobj = NULL;
15314 wxFileType *arg1 = (wxFileType *) 0 ;
15315 PyObject *result;
15316 PyObject * obj0 = 0 ;
15317 char *kwnames[] = {
15318 (char *) "self", NULL
15319 };
15320
15321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
15322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15323 if (SWIG_arg_fail(1)) SWIG_fail;
15324 {
15325 PyThreadState* __tstate = wxPyBeginAllowThreads();
15326 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
15327
15328 wxPyEndAllowThreads(__tstate);
15329 if (PyErr_Occurred()) SWIG_fail;
15330 }
15331 resultobj = result;
15332 return resultobj;
15333 fail:
15334 return NULL;
15335 }
15336
15337
15338 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
15339 PyObject *resultobj = NULL;
15340 wxFileType *arg1 = (wxFileType *) 0 ;
15341 PyObject *result;
15342 PyObject * obj0 = 0 ;
15343 char *kwnames[] = {
15344 (char *) "self", NULL
15345 };
15346
15347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
15348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15349 if (SWIG_arg_fail(1)) SWIG_fail;
15350 {
15351 PyThreadState* __tstate = wxPyBeginAllowThreads();
15352 result = (PyObject *)wxFileType_GetExtensions(arg1);
15353
15354 wxPyEndAllowThreads(__tstate);
15355 if (PyErr_Occurred()) SWIG_fail;
15356 }
15357 resultobj = result;
15358 return resultobj;
15359 fail:
15360 return NULL;
15361 }
15362
15363
15364 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
15365 PyObject *resultobj = NULL;
15366 wxFileType *arg1 = (wxFileType *) 0 ;
15367 wxIcon *result;
15368 PyObject * obj0 = 0 ;
15369 char *kwnames[] = {
15370 (char *) "self", NULL
15371 };
15372
15373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
15374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15375 if (SWIG_arg_fail(1)) SWIG_fail;
15376 {
15377 PyThreadState* __tstate = wxPyBeginAllowThreads();
15378 result = (wxIcon *)wxFileType_GetIcon(arg1);
15379
15380 wxPyEndAllowThreads(__tstate);
15381 if (PyErr_Occurred()) SWIG_fail;
15382 }
15383 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
15384 return resultobj;
15385 fail:
15386 return NULL;
15387 }
15388
15389
15390 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15391 PyObject *resultobj = NULL;
15392 wxFileType *arg1 = (wxFileType *) 0 ;
15393 PyObject *result;
15394 PyObject * obj0 = 0 ;
15395 char *kwnames[] = {
15396 (char *) "self", NULL
15397 };
15398
15399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
15400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15401 if (SWIG_arg_fail(1)) SWIG_fail;
15402 {
15403 PyThreadState* __tstate = wxPyBeginAllowThreads();
15404 result = (PyObject *)wxFileType_GetIconInfo(arg1);
15405
15406 wxPyEndAllowThreads(__tstate);
15407 if (PyErr_Occurred()) SWIG_fail;
15408 }
15409 resultobj = result;
15410 return resultobj;
15411 fail:
15412 return NULL;
15413 }
15414
15415
15416 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
15417 PyObject *resultobj = NULL;
15418 wxFileType *arg1 = (wxFileType *) 0 ;
15419 PyObject *result;
15420 PyObject * obj0 = 0 ;
15421 char *kwnames[] = {
15422 (char *) "self", NULL
15423 };
15424
15425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
15426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15427 if (SWIG_arg_fail(1)) SWIG_fail;
15428 {
15429 PyThreadState* __tstate = wxPyBeginAllowThreads();
15430 result = (PyObject *)wxFileType_GetDescription(arg1);
15431
15432 wxPyEndAllowThreads(__tstate);
15433 if (PyErr_Occurred()) SWIG_fail;
15434 }
15435 resultobj = result;
15436 return resultobj;
15437 fail:
15438 return NULL;
15439 }
15440
15441
15442 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15443 PyObject *resultobj = NULL;
15444 wxFileType *arg1 = (wxFileType *) 0 ;
15445 wxString *arg2 = 0 ;
15446 wxString const &arg3_defvalue = wxPyEmptyString ;
15447 wxString *arg3 = (wxString *) &arg3_defvalue ;
15448 PyObject *result;
15449 bool temp2 = false ;
15450 bool temp3 = false ;
15451 PyObject * obj0 = 0 ;
15452 PyObject * obj1 = 0 ;
15453 PyObject * obj2 = 0 ;
15454 char *kwnames[] = {
15455 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
15456 };
15457
15458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
15459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15460 if (SWIG_arg_fail(1)) SWIG_fail;
15461 {
15462 arg2 = wxString_in_helper(obj1);
15463 if (arg2 == NULL) SWIG_fail;
15464 temp2 = true;
15465 }
15466 if (obj2) {
15467 {
15468 arg3 = wxString_in_helper(obj2);
15469 if (arg3 == NULL) SWIG_fail;
15470 temp3 = true;
15471 }
15472 }
15473 {
15474 PyThreadState* __tstate = wxPyBeginAllowThreads();
15475 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15476
15477 wxPyEndAllowThreads(__tstate);
15478 if (PyErr_Occurred()) SWIG_fail;
15479 }
15480 resultobj = result;
15481 {
15482 if (temp2)
15483 delete arg2;
15484 }
15485 {
15486 if (temp3)
15487 delete arg3;
15488 }
15489 return resultobj;
15490 fail:
15491 {
15492 if (temp2)
15493 delete arg2;
15494 }
15495 {
15496 if (temp3)
15497 delete arg3;
15498 }
15499 return NULL;
15500 }
15501
15502
15503 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15504 PyObject *resultobj = NULL;
15505 wxFileType *arg1 = (wxFileType *) 0 ;
15506 wxString *arg2 = 0 ;
15507 wxString const &arg3_defvalue = wxPyEmptyString ;
15508 wxString *arg3 = (wxString *) &arg3_defvalue ;
15509 PyObject *result;
15510 bool temp2 = false ;
15511 bool temp3 = false ;
15512 PyObject * obj0 = 0 ;
15513 PyObject * obj1 = 0 ;
15514 PyObject * obj2 = 0 ;
15515 char *kwnames[] = {
15516 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
15517 };
15518
15519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
15520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15521 if (SWIG_arg_fail(1)) SWIG_fail;
15522 {
15523 arg2 = wxString_in_helper(obj1);
15524 if (arg2 == NULL) SWIG_fail;
15525 temp2 = true;
15526 }
15527 if (obj2) {
15528 {
15529 arg3 = wxString_in_helper(obj2);
15530 if (arg3 == NULL) SWIG_fail;
15531 temp3 = true;
15532 }
15533 }
15534 {
15535 PyThreadState* __tstate = wxPyBeginAllowThreads();
15536 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15537
15538 wxPyEndAllowThreads(__tstate);
15539 if (PyErr_Occurred()) SWIG_fail;
15540 }
15541 resultobj = result;
15542 {
15543 if (temp2)
15544 delete arg2;
15545 }
15546 {
15547 if (temp3)
15548 delete arg3;
15549 }
15550 return resultobj;
15551 fail:
15552 {
15553 if (temp2)
15554 delete arg2;
15555 }
15556 {
15557 if (temp3)
15558 delete arg3;
15559 }
15560 return NULL;
15561 }
15562
15563
15564 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
15565 PyObject *resultobj = NULL;
15566 wxFileType *arg1 = (wxFileType *) 0 ;
15567 wxString *arg2 = 0 ;
15568 wxString const &arg3_defvalue = wxPyEmptyString ;
15569 wxString *arg3 = (wxString *) &arg3_defvalue ;
15570 PyObject *result;
15571 bool temp2 = false ;
15572 bool temp3 = false ;
15573 PyObject * obj0 = 0 ;
15574 PyObject * obj1 = 0 ;
15575 PyObject * obj2 = 0 ;
15576 char *kwnames[] = {
15577 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
15578 };
15579
15580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
15581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15582 if (SWIG_arg_fail(1)) SWIG_fail;
15583 {
15584 arg2 = wxString_in_helper(obj1);
15585 if (arg2 == NULL) SWIG_fail;
15586 temp2 = true;
15587 }
15588 if (obj2) {
15589 {
15590 arg3 = wxString_in_helper(obj2);
15591 if (arg3 == NULL) SWIG_fail;
15592 temp3 = true;
15593 }
15594 }
15595 {
15596 PyThreadState* __tstate = wxPyBeginAllowThreads();
15597 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15598
15599 wxPyEndAllowThreads(__tstate);
15600 if (PyErr_Occurred()) SWIG_fail;
15601 }
15602 resultobj = result;
15603 {
15604 if (temp2)
15605 delete arg2;
15606 }
15607 {
15608 if (temp3)
15609 delete arg3;
15610 }
15611 return resultobj;
15612 fail:
15613 {
15614 if (temp2)
15615 delete arg2;
15616 }
15617 {
15618 if (temp3)
15619 delete arg3;
15620 }
15621 return NULL;
15622 }
15623
15624
15625 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15626 PyObject *resultobj = NULL;
15627 wxFileType *arg1 = (wxFileType *) 0 ;
15628 wxString *arg2 = 0 ;
15629 wxString *arg3 = 0 ;
15630 bool arg4 = (bool) true ;
15631 bool result;
15632 bool temp2 = false ;
15633 bool temp3 = false ;
15634 PyObject * obj0 = 0 ;
15635 PyObject * obj1 = 0 ;
15636 PyObject * obj2 = 0 ;
15637 PyObject * obj3 = 0 ;
15638 char *kwnames[] = {
15639 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
15640 };
15641
15642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15644 if (SWIG_arg_fail(1)) SWIG_fail;
15645 {
15646 arg2 = wxString_in_helper(obj1);
15647 if (arg2 == NULL) SWIG_fail;
15648 temp2 = true;
15649 }
15650 {
15651 arg3 = wxString_in_helper(obj2);
15652 if (arg3 == NULL) SWIG_fail;
15653 temp3 = true;
15654 }
15655 if (obj3) {
15656 {
15657 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
15658 if (SWIG_arg_fail(4)) SWIG_fail;
15659 }
15660 }
15661 {
15662 PyThreadState* __tstate = wxPyBeginAllowThreads();
15663 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
15664
15665 wxPyEndAllowThreads(__tstate);
15666 if (PyErr_Occurred()) SWIG_fail;
15667 }
15668 {
15669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15670 }
15671 {
15672 if (temp2)
15673 delete arg2;
15674 }
15675 {
15676 if (temp3)
15677 delete arg3;
15678 }
15679 return resultobj;
15680 fail:
15681 {
15682 if (temp2)
15683 delete arg2;
15684 }
15685 {
15686 if (temp3)
15687 delete arg3;
15688 }
15689 return NULL;
15690 }
15691
15692
15693 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
15694 PyObject *resultobj = NULL;
15695 wxFileType *arg1 = (wxFileType *) 0 ;
15696 wxString const &arg2_defvalue = wxPyEmptyString ;
15697 wxString *arg2 = (wxString *) &arg2_defvalue ;
15698 int arg3 = (int) 0 ;
15699 bool result;
15700 bool temp2 = false ;
15701 PyObject * obj0 = 0 ;
15702 PyObject * obj1 = 0 ;
15703 PyObject * obj2 = 0 ;
15704 char *kwnames[] = {
15705 (char *) "self",(char *) "cmd",(char *) "index", NULL
15706 };
15707
15708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
15709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15710 if (SWIG_arg_fail(1)) SWIG_fail;
15711 if (obj1) {
15712 {
15713 arg2 = wxString_in_helper(obj1);
15714 if (arg2 == NULL) SWIG_fail;
15715 temp2 = true;
15716 }
15717 }
15718 if (obj2) {
15719 {
15720 arg3 = static_cast<int >(SWIG_As_int(obj2));
15721 if (SWIG_arg_fail(3)) SWIG_fail;
15722 }
15723 }
15724 {
15725 PyThreadState* __tstate = wxPyBeginAllowThreads();
15726 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
15727
15728 wxPyEndAllowThreads(__tstate);
15729 if (PyErr_Occurred()) SWIG_fail;
15730 }
15731 {
15732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15733 }
15734 {
15735 if (temp2)
15736 delete arg2;
15737 }
15738 return resultobj;
15739 fail:
15740 {
15741 if (temp2)
15742 delete arg2;
15743 }
15744 return NULL;
15745 }
15746
15747
15748 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15749 PyObject *resultobj = NULL;
15750 wxFileType *arg1 = (wxFileType *) 0 ;
15751 bool result;
15752 PyObject * obj0 = 0 ;
15753 char *kwnames[] = {
15754 (char *) "self", NULL
15755 };
15756
15757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
15758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15759 if (SWIG_arg_fail(1)) SWIG_fail;
15760 {
15761 PyThreadState* __tstate = wxPyBeginAllowThreads();
15762 result = (bool)(arg1)->Unassociate();
15763
15764 wxPyEndAllowThreads(__tstate);
15765 if (PyErr_Occurred()) SWIG_fail;
15766 }
15767 {
15768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15769 }
15770 return resultobj;
15771 fail:
15772 return NULL;
15773 }
15774
15775
15776 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15777 PyObject *resultobj = NULL;
15778 wxString *arg1 = 0 ;
15779 wxString *arg2 = 0 ;
15780 wxString const &arg3_defvalue = wxPyEmptyString ;
15781 wxString *arg3 = (wxString *) &arg3_defvalue ;
15782 wxString result;
15783 bool temp1 = false ;
15784 bool temp2 = false ;
15785 bool temp3 = false ;
15786 PyObject * obj0 = 0 ;
15787 PyObject * obj1 = 0 ;
15788 PyObject * obj2 = 0 ;
15789 char *kwnames[] = {
15790 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
15791 };
15792
15793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
15794 {
15795 arg1 = wxString_in_helper(obj0);
15796 if (arg1 == NULL) SWIG_fail;
15797 temp1 = true;
15798 }
15799 {
15800 arg2 = wxString_in_helper(obj1);
15801 if (arg2 == NULL) SWIG_fail;
15802 temp2 = true;
15803 }
15804 if (obj2) {
15805 {
15806 arg3 = wxString_in_helper(obj2);
15807 if (arg3 == NULL) SWIG_fail;
15808 temp3 = true;
15809 }
15810 }
15811 {
15812 PyThreadState* __tstate = wxPyBeginAllowThreads();
15813 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15814
15815 wxPyEndAllowThreads(__tstate);
15816 if (PyErr_Occurred()) SWIG_fail;
15817 }
15818 {
15819 #if wxUSE_UNICODE
15820 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15821 #else
15822 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15823 #endif
15824 }
15825 {
15826 if (temp1)
15827 delete arg1;
15828 }
15829 {
15830 if (temp2)
15831 delete arg2;
15832 }
15833 {
15834 if (temp3)
15835 delete arg3;
15836 }
15837 return resultobj;
15838 fail:
15839 {
15840 if (temp1)
15841 delete arg1;
15842 }
15843 {
15844 if (temp2)
15845 delete arg2;
15846 }
15847 {
15848 if (temp3)
15849 delete arg3;
15850 }
15851 return NULL;
15852 }
15853
15854
15855 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
15856 PyObject *obj;
15857 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15858 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
15859 Py_INCREF(obj);
15860 return Py_BuildValue((char *)"");
15861 }
15862 static int _wrap_TheMimeTypesManager_set(PyObject *) {
15863 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
15864 return 1;
15865 }
15866
15867
15868 static PyObject *_wrap_TheMimeTypesManager_get(void) {
15869 PyObject *pyobj = NULL;
15870
15871 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
15872 return pyobj;
15873 }
15874
15875
15876 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
15877 PyObject *resultobj = NULL;
15878 wxString *arg1 = 0 ;
15879 wxString *arg2 = 0 ;
15880 bool result;
15881 bool temp1 = false ;
15882 bool temp2 = false ;
15883 PyObject * obj0 = 0 ;
15884 PyObject * obj1 = 0 ;
15885 char *kwnames[] = {
15886 (char *) "mimeType",(char *) "wildcard", NULL
15887 };
15888
15889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
15890 {
15891 arg1 = wxString_in_helper(obj0);
15892 if (arg1 == NULL) SWIG_fail;
15893 temp1 = true;
15894 }
15895 {
15896 arg2 = wxString_in_helper(obj1);
15897 if (arg2 == NULL) SWIG_fail;
15898 temp2 = true;
15899 }
15900 {
15901 PyThreadState* __tstate = wxPyBeginAllowThreads();
15902 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
15903
15904 wxPyEndAllowThreads(__tstate);
15905 if (PyErr_Occurred()) SWIG_fail;
15906 }
15907 {
15908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15909 }
15910 {
15911 if (temp1)
15912 delete arg1;
15913 }
15914 {
15915 if (temp2)
15916 delete arg2;
15917 }
15918 return resultobj;
15919 fail:
15920 {
15921 if (temp1)
15922 delete arg1;
15923 }
15924 {
15925 if (temp2)
15926 delete arg2;
15927 }
15928 return NULL;
15929 }
15930
15931
15932 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15933 PyObject *resultobj = NULL;
15934 wxMimeTypesManager *result;
15935 char *kwnames[] = {
15936 NULL
15937 };
15938
15939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15940 {
15941 PyThreadState* __tstate = wxPyBeginAllowThreads();
15942 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15943
15944 wxPyEndAllowThreads(__tstate);
15945 if (PyErr_Occurred()) SWIG_fail;
15946 }
15947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15948 return resultobj;
15949 fail:
15950 return NULL;
15951 }
15952
15953
15954 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15955 PyObject *resultobj = NULL;
15956 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15957 int arg2 = (int) wxMAILCAP_ALL ;
15958 wxString const &arg3_defvalue = wxPyEmptyString ;
15959 wxString *arg3 = (wxString *) &arg3_defvalue ;
15960 bool temp3 = false ;
15961 PyObject * obj0 = 0 ;
15962 PyObject * obj1 = 0 ;
15963 PyObject * obj2 = 0 ;
15964 char *kwnames[] = {
15965 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15966 };
15967
15968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15970 if (SWIG_arg_fail(1)) SWIG_fail;
15971 if (obj1) {
15972 {
15973 arg2 = static_cast<int >(SWIG_As_int(obj1));
15974 if (SWIG_arg_fail(2)) SWIG_fail;
15975 }
15976 }
15977 if (obj2) {
15978 {
15979 arg3 = wxString_in_helper(obj2);
15980 if (arg3 == NULL) SWIG_fail;
15981 temp3 = true;
15982 }
15983 }
15984 {
15985 PyThreadState* __tstate = wxPyBeginAllowThreads();
15986 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15987
15988 wxPyEndAllowThreads(__tstate);
15989 if (PyErr_Occurred()) SWIG_fail;
15990 }
15991 Py_INCREF(Py_None); resultobj = Py_None;
15992 {
15993 if (temp3)
15994 delete arg3;
15995 }
15996 return resultobj;
15997 fail:
15998 {
15999 if (temp3)
16000 delete arg3;
16001 }
16002 return NULL;
16003 }
16004
16005
16006 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
16007 PyObject *resultobj = NULL;
16008 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16009 PyObject * obj0 = 0 ;
16010 char *kwnames[] = {
16011 (char *) "self", NULL
16012 };
16013
16014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
16015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16016 if (SWIG_arg_fail(1)) SWIG_fail;
16017 {
16018 PyThreadState* __tstate = wxPyBeginAllowThreads();
16019 (arg1)->ClearData();
16020
16021 wxPyEndAllowThreads(__tstate);
16022 if (PyErr_Occurred()) SWIG_fail;
16023 }
16024 Py_INCREF(Py_None); resultobj = Py_None;
16025 return resultobj;
16026 fail:
16027 return NULL;
16028 }
16029
16030
16031 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
16032 PyObject *resultobj = NULL;
16033 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16034 wxString *arg2 = 0 ;
16035 wxFileType *result;
16036 bool temp2 = false ;
16037 PyObject * obj0 = 0 ;
16038 PyObject * obj1 = 0 ;
16039 char *kwnames[] = {
16040 (char *) "self",(char *) "ext", NULL
16041 };
16042
16043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
16044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16045 if (SWIG_arg_fail(1)) SWIG_fail;
16046 {
16047 arg2 = wxString_in_helper(obj1);
16048 if (arg2 == NULL) SWIG_fail;
16049 temp2 = true;
16050 }
16051 {
16052 PyThreadState* __tstate = wxPyBeginAllowThreads();
16053 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
16054
16055 wxPyEndAllowThreads(__tstate);
16056 if (PyErr_Occurred()) SWIG_fail;
16057 }
16058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
16059 {
16060 if (temp2)
16061 delete arg2;
16062 }
16063 return resultobj;
16064 fail:
16065 {
16066 if (temp2)
16067 delete arg2;
16068 }
16069 return NULL;
16070 }
16071
16072
16073 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
16074 PyObject *resultobj = NULL;
16075 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16076 wxString *arg2 = 0 ;
16077 wxFileType *result;
16078 bool temp2 = false ;
16079 PyObject * obj0 = 0 ;
16080 PyObject * obj1 = 0 ;
16081 char *kwnames[] = {
16082 (char *) "self",(char *) "mimeType", NULL
16083 };
16084
16085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
16086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16087 if (SWIG_arg_fail(1)) SWIG_fail;
16088 {
16089 arg2 = wxString_in_helper(obj1);
16090 if (arg2 == NULL) SWIG_fail;
16091 temp2 = true;
16092 }
16093 {
16094 PyThreadState* __tstate = wxPyBeginAllowThreads();
16095 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
16096
16097 wxPyEndAllowThreads(__tstate);
16098 if (PyErr_Occurred()) SWIG_fail;
16099 }
16100 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
16101 {
16102 if (temp2)
16103 delete arg2;
16104 }
16105 return resultobj;
16106 fail:
16107 {
16108 if (temp2)
16109 delete arg2;
16110 }
16111 return NULL;
16112 }
16113
16114
16115 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
16116 PyObject *resultobj = NULL;
16117 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16118 wxString *arg2 = 0 ;
16119 bool arg3 = (bool) false ;
16120 bool result;
16121 bool temp2 = false ;
16122 PyObject * obj0 = 0 ;
16123 PyObject * obj1 = 0 ;
16124 PyObject * obj2 = 0 ;
16125 char *kwnames[] = {
16126 (char *) "self",(char *) "filename",(char *) "fallback", NULL
16127 };
16128
16129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16131 if (SWIG_arg_fail(1)) SWIG_fail;
16132 {
16133 arg2 = wxString_in_helper(obj1);
16134 if (arg2 == NULL) SWIG_fail;
16135 temp2 = true;
16136 }
16137 if (obj2) {
16138 {
16139 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
16140 if (SWIG_arg_fail(3)) SWIG_fail;
16141 }
16142 }
16143 {
16144 PyThreadState* __tstate = wxPyBeginAllowThreads();
16145 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
16146
16147 wxPyEndAllowThreads(__tstate);
16148 if (PyErr_Occurred()) SWIG_fail;
16149 }
16150 {
16151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16152 }
16153 {
16154 if (temp2)
16155 delete arg2;
16156 }
16157 return resultobj;
16158 fail:
16159 {
16160 if (temp2)
16161 delete arg2;
16162 }
16163 return NULL;
16164 }
16165
16166
16167 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
16168 PyObject *resultobj = NULL;
16169 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16170 wxString *arg2 = 0 ;
16171 bool result;
16172 bool temp2 = false ;
16173 PyObject * obj0 = 0 ;
16174 PyObject * obj1 = 0 ;
16175 char *kwnames[] = {
16176 (char *) "self",(char *) "filename", NULL
16177 };
16178
16179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
16180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16181 if (SWIG_arg_fail(1)) SWIG_fail;
16182 {
16183 arg2 = wxString_in_helper(obj1);
16184 if (arg2 == NULL) SWIG_fail;
16185 temp2 = true;
16186 }
16187 {
16188 PyThreadState* __tstate = wxPyBeginAllowThreads();
16189 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
16190
16191 wxPyEndAllowThreads(__tstate);
16192 if (PyErr_Occurred()) SWIG_fail;
16193 }
16194 {
16195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16196 }
16197 {
16198 if (temp2)
16199 delete arg2;
16200 }
16201 return resultobj;
16202 fail:
16203 {
16204 if (temp2)
16205 delete arg2;
16206 }
16207 return NULL;
16208 }
16209
16210
16211 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
16212 PyObject *resultobj = NULL;
16213 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16214 PyObject *result;
16215 PyObject * obj0 = 0 ;
16216 char *kwnames[] = {
16217 (char *) "self", NULL
16218 };
16219
16220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
16221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16222 if (SWIG_arg_fail(1)) SWIG_fail;
16223 {
16224 PyThreadState* __tstate = wxPyBeginAllowThreads();
16225 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
16226
16227 wxPyEndAllowThreads(__tstate);
16228 if (PyErr_Occurred()) SWIG_fail;
16229 }
16230 resultobj = result;
16231 return resultobj;
16232 fail:
16233 return NULL;
16234 }
16235
16236
16237 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
16238 PyObject *resultobj = NULL;
16239 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16240 wxFileTypeInfo *arg2 = 0 ;
16241 PyObject * obj0 = 0 ;
16242 PyObject * obj1 = 0 ;
16243 char *kwnames[] = {
16244 (char *) "self",(char *) "ft", NULL
16245 };
16246
16247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
16248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16249 if (SWIG_arg_fail(1)) SWIG_fail;
16250 {
16251 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
16252 if (SWIG_arg_fail(2)) SWIG_fail;
16253 if (arg2 == NULL) {
16254 SWIG_null_ref("wxFileTypeInfo");
16255 }
16256 if (SWIG_arg_fail(2)) SWIG_fail;
16257 }
16258 {
16259 PyThreadState* __tstate = wxPyBeginAllowThreads();
16260 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
16261
16262 wxPyEndAllowThreads(__tstate);
16263 if (PyErr_Occurred()) SWIG_fail;
16264 }
16265 Py_INCREF(Py_None); resultobj = Py_None;
16266 return resultobj;
16267 fail:
16268 return NULL;
16269 }
16270
16271
16272 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
16273 PyObject *resultobj = NULL;
16274 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16275 wxFileTypeInfo *arg2 = 0 ;
16276 wxFileType *result;
16277 PyObject * obj0 = 0 ;
16278 PyObject * obj1 = 0 ;
16279 char *kwnames[] = {
16280 (char *) "self",(char *) "ftInfo", NULL
16281 };
16282
16283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
16284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16285 if (SWIG_arg_fail(1)) SWIG_fail;
16286 {
16287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
16288 if (SWIG_arg_fail(2)) SWIG_fail;
16289 if (arg2 == NULL) {
16290 SWIG_null_ref("wxFileTypeInfo");
16291 }
16292 if (SWIG_arg_fail(2)) SWIG_fail;
16293 }
16294 {
16295 PyThreadState* __tstate = wxPyBeginAllowThreads();
16296 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
16297
16298 wxPyEndAllowThreads(__tstate);
16299 if (PyErr_Occurred()) SWIG_fail;
16300 }
16301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
16302 return resultobj;
16303 fail:
16304 return NULL;
16305 }
16306
16307
16308 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
16309 PyObject *resultobj = NULL;
16310 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16311 wxFileType *arg2 = (wxFileType *) 0 ;
16312 bool result;
16313 PyObject * obj0 = 0 ;
16314 PyObject * obj1 = 0 ;
16315 char *kwnames[] = {
16316 (char *) "self",(char *) "ft", NULL
16317 };
16318
16319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
16320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16321 if (SWIG_arg_fail(1)) SWIG_fail;
16322 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
16323 if (SWIG_arg_fail(2)) SWIG_fail;
16324 {
16325 PyThreadState* __tstate = wxPyBeginAllowThreads();
16326 result = (bool)(arg1)->Unassociate(arg2);
16327
16328 wxPyEndAllowThreads(__tstate);
16329 if (PyErr_Occurred()) SWIG_fail;
16330 }
16331 {
16332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16333 }
16334 return resultobj;
16335 fail:
16336 return NULL;
16337 }
16338
16339
16340 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
16341 PyObject *resultobj = NULL;
16342 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16343 PyObject * obj0 = 0 ;
16344 char *kwnames[] = {
16345 (char *) "self", NULL
16346 };
16347
16348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
16349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16350 if (SWIG_arg_fail(1)) SWIG_fail;
16351 {
16352 PyThreadState* __tstate = wxPyBeginAllowThreads();
16353 delete arg1;
16354
16355 wxPyEndAllowThreads(__tstate);
16356 if (PyErr_Occurred()) SWIG_fail;
16357 }
16358 Py_INCREF(Py_None); resultobj = Py_None;
16359 return resultobj;
16360 fail:
16361 return NULL;
16362 }
16363
16364
16365 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
16366 PyObject *obj;
16367 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16368 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
16369 Py_INCREF(obj);
16370 return Py_BuildValue((char *)"");
16371 }
16372 static int _wrap_ART_TOOLBAR_set(PyObject *) {
16373 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
16374 return 1;
16375 }
16376
16377
16378 static PyObject *_wrap_ART_TOOLBAR_get(void) {
16379 PyObject *pyobj = NULL;
16380
16381 {
16382 #if wxUSE_UNICODE
16383 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
16384 #else
16385 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
16386 #endif
16387 }
16388 return pyobj;
16389 }
16390
16391
16392 static int _wrap_ART_MENU_set(PyObject *) {
16393 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
16394 return 1;
16395 }
16396
16397
16398 static PyObject *_wrap_ART_MENU_get(void) {
16399 PyObject *pyobj = NULL;
16400
16401 {
16402 #if wxUSE_UNICODE
16403 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
16404 #else
16405 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
16406 #endif
16407 }
16408 return pyobj;
16409 }
16410
16411
16412 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
16413 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
16414 return 1;
16415 }
16416
16417
16418 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
16419 PyObject *pyobj = NULL;
16420
16421 {
16422 #if wxUSE_UNICODE
16423 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
16424 #else
16425 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
16426 #endif
16427 }
16428 return pyobj;
16429 }
16430
16431
16432 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
16433 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
16434 return 1;
16435 }
16436
16437
16438 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
16439 PyObject *pyobj = NULL;
16440
16441 {
16442 #if wxUSE_UNICODE
16443 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
16444 #else
16445 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
16446 #endif
16447 }
16448 return pyobj;
16449 }
16450
16451
16452 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
16453 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
16454 return 1;
16455 }
16456
16457
16458 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
16459 PyObject *pyobj = NULL;
16460
16461 {
16462 #if wxUSE_UNICODE
16463 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
16464 #else
16465 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
16466 #endif
16467 }
16468 return pyobj;
16469 }
16470
16471
16472 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
16473 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
16474 return 1;
16475 }
16476
16477
16478 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
16479 PyObject *pyobj = NULL;
16480
16481 {
16482 #if wxUSE_UNICODE
16483 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
16484 #else
16485 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
16486 #endif
16487 }
16488 return pyobj;
16489 }
16490
16491
16492 static int _wrap_ART_BUTTON_set(PyObject *) {
16493 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
16494 return 1;
16495 }
16496
16497
16498 static PyObject *_wrap_ART_BUTTON_get(void) {
16499 PyObject *pyobj = NULL;
16500
16501 {
16502 #if wxUSE_UNICODE
16503 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
16504 #else
16505 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
16506 #endif
16507 }
16508 return pyobj;
16509 }
16510
16511
16512 static int _wrap_ART_OTHER_set(PyObject *) {
16513 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
16514 return 1;
16515 }
16516
16517
16518 static PyObject *_wrap_ART_OTHER_get(void) {
16519 PyObject *pyobj = NULL;
16520
16521 {
16522 #if wxUSE_UNICODE
16523 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
16524 #else
16525 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
16526 #endif
16527 }
16528 return pyobj;
16529 }
16530
16531
16532 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
16533 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
16534 return 1;
16535 }
16536
16537
16538 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
16539 PyObject *pyobj = NULL;
16540
16541 {
16542 #if wxUSE_UNICODE
16543 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
16544 #else
16545 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
16546 #endif
16547 }
16548 return pyobj;
16549 }
16550
16551
16552 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
16553 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
16554 return 1;
16555 }
16556
16557
16558 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
16559 PyObject *pyobj = NULL;
16560
16561 {
16562 #if wxUSE_UNICODE
16563 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
16564 #else
16565 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
16566 #endif
16567 }
16568 return pyobj;
16569 }
16570
16571
16572 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
16573 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
16574 return 1;
16575 }
16576
16577
16578 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
16579 PyObject *pyobj = NULL;
16580
16581 {
16582 #if wxUSE_UNICODE
16583 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
16584 #else
16585 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
16586 #endif
16587 }
16588 return pyobj;
16589 }
16590
16591
16592 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
16593 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
16594 return 1;
16595 }
16596
16597
16598 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
16599 PyObject *pyobj = NULL;
16600
16601 {
16602 #if wxUSE_UNICODE
16603 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
16604 #else
16605 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
16606 #endif
16607 }
16608 return pyobj;
16609 }
16610
16611
16612 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
16613 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
16614 return 1;
16615 }
16616
16617
16618 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
16619 PyObject *pyobj = NULL;
16620
16621 {
16622 #if wxUSE_UNICODE
16623 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
16624 #else
16625 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
16626 #endif
16627 }
16628 return pyobj;
16629 }
16630
16631
16632 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
16633 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
16634 return 1;
16635 }
16636
16637
16638 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
16639 PyObject *pyobj = NULL;
16640
16641 {
16642 #if wxUSE_UNICODE
16643 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
16644 #else
16645 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
16646 #endif
16647 }
16648 return pyobj;
16649 }
16650
16651
16652 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
16653 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
16654 return 1;
16655 }
16656
16657
16658 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
16659 PyObject *pyobj = NULL;
16660
16661 {
16662 #if wxUSE_UNICODE
16663 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
16664 #else
16665 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
16666 #endif
16667 }
16668 return pyobj;
16669 }
16670
16671
16672 static int _wrap_ART_GO_BACK_set(PyObject *) {
16673 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
16674 return 1;
16675 }
16676
16677
16678 static PyObject *_wrap_ART_GO_BACK_get(void) {
16679 PyObject *pyobj = NULL;
16680
16681 {
16682 #if wxUSE_UNICODE
16683 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
16684 #else
16685 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
16686 #endif
16687 }
16688 return pyobj;
16689 }
16690
16691
16692 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
16693 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
16694 return 1;
16695 }
16696
16697
16698 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
16699 PyObject *pyobj = NULL;
16700
16701 {
16702 #if wxUSE_UNICODE
16703 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
16704 #else
16705 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
16706 #endif
16707 }
16708 return pyobj;
16709 }
16710
16711
16712 static int _wrap_ART_GO_UP_set(PyObject *) {
16713 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
16714 return 1;
16715 }
16716
16717
16718 static PyObject *_wrap_ART_GO_UP_get(void) {
16719 PyObject *pyobj = NULL;
16720
16721 {
16722 #if wxUSE_UNICODE
16723 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
16724 #else
16725 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
16726 #endif
16727 }
16728 return pyobj;
16729 }
16730
16731
16732 static int _wrap_ART_GO_DOWN_set(PyObject *) {
16733 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
16734 return 1;
16735 }
16736
16737
16738 static PyObject *_wrap_ART_GO_DOWN_get(void) {
16739 PyObject *pyobj = NULL;
16740
16741 {
16742 #if wxUSE_UNICODE
16743 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
16744 #else
16745 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
16746 #endif
16747 }
16748 return pyobj;
16749 }
16750
16751
16752 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
16753 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
16754 return 1;
16755 }
16756
16757
16758 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
16759 PyObject *pyobj = NULL;
16760
16761 {
16762 #if wxUSE_UNICODE
16763 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
16764 #else
16765 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
16766 #endif
16767 }
16768 return pyobj;
16769 }
16770
16771
16772 static int _wrap_ART_GO_HOME_set(PyObject *) {
16773 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
16774 return 1;
16775 }
16776
16777
16778 static PyObject *_wrap_ART_GO_HOME_get(void) {
16779 PyObject *pyobj = NULL;
16780
16781 {
16782 #if wxUSE_UNICODE
16783 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
16784 #else
16785 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
16786 #endif
16787 }
16788 return pyobj;
16789 }
16790
16791
16792 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
16793 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
16794 return 1;
16795 }
16796
16797
16798 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
16799 PyObject *pyobj = NULL;
16800
16801 {
16802 #if wxUSE_UNICODE
16803 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
16804 #else
16805 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
16806 #endif
16807 }
16808 return pyobj;
16809 }
16810
16811
16812 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
16813 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
16814 return 1;
16815 }
16816
16817
16818 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
16819 PyObject *pyobj = NULL;
16820
16821 {
16822 #if wxUSE_UNICODE
16823 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
16824 #else
16825 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
16826 #endif
16827 }
16828 return pyobj;
16829 }
16830
16831
16832 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
16833 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
16834 return 1;
16835 }
16836
16837
16838 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
16839 PyObject *pyobj = NULL;
16840
16841 {
16842 #if wxUSE_UNICODE
16843 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
16844 #else
16845 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
16846 #endif
16847 }
16848 return pyobj;
16849 }
16850
16851
16852 static int _wrap_ART_PRINT_set(PyObject *) {
16853 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
16854 return 1;
16855 }
16856
16857
16858 static PyObject *_wrap_ART_PRINT_get(void) {
16859 PyObject *pyobj = NULL;
16860
16861 {
16862 #if wxUSE_UNICODE
16863 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16864 #else
16865 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16866 #endif
16867 }
16868 return pyobj;
16869 }
16870
16871
16872 static int _wrap_ART_HELP_set(PyObject *) {
16873 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
16874 return 1;
16875 }
16876
16877
16878 static PyObject *_wrap_ART_HELP_get(void) {
16879 PyObject *pyobj = NULL;
16880
16881 {
16882 #if wxUSE_UNICODE
16883 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16884 #else
16885 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16886 #endif
16887 }
16888 return pyobj;
16889 }
16890
16891
16892 static int _wrap_ART_TIP_set(PyObject *) {
16893 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
16894 return 1;
16895 }
16896
16897
16898 static PyObject *_wrap_ART_TIP_get(void) {
16899 PyObject *pyobj = NULL;
16900
16901 {
16902 #if wxUSE_UNICODE
16903 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16904 #else
16905 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16906 #endif
16907 }
16908 return pyobj;
16909 }
16910
16911
16912 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16913 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16914 return 1;
16915 }
16916
16917
16918 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16919 PyObject *pyobj = NULL;
16920
16921 {
16922 #if wxUSE_UNICODE
16923 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16924 #else
16925 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16926 #endif
16927 }
16928 return pyobj;
16929 }
16930
16931
16932 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16933 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16934 return 1;
16935 }
16936
16937
16938 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16939 PyObject *pyobj = NULL;
16940
16941 {
16942 #if wxUSE_UNICODE
16943 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16944 #else
16945 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16946 #endif
16947 }
16948 return pyobj;
16949 }
16950
16951
16952 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16953 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16954 return 1;
16955 }
16956
16957
16958 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16959 PyObject *pyobj = NULL;
16960
16961 {
16962 #if wxUSE_UNICODE
16963 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16964 #else
16965 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16966 #endif
16967 }
16968 return pyobj;
16969 }
16970
16971
16972 static int _wrap_ART_HARDDISK_set(PyObject *) {
16973 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16974 return 1;
16975 }
16976
16977
16978 static PyObject *_wrap_ART_HARDDISK_get(void) {
16979 PyObject *pyobj = NULL;
16980
16981 {
16982 #if wxUSE_UNICODE
16983 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16984 #else
16985 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16986 #endif
16987 }
16988 return pyobj;
16989 }
16990
16991
16992 static int _wrap_ART_FLOPPY_set(PyObject *) {
16993 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16994 return 1;
16995 }
16996
16997
16998 static PyObject *_wrap_ART_FLOPPY_get(void) {
16999 PyObject *pyobj = NULL;
17000
17001 {
17002 #if wxUSE_UNICODE
17003 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
17004 #else
17005 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
17006 #endif
17007 }
17008 return pyobj;
17009 }
17010
17011
17012 static int _wrap_ART_CDROM_set(PyObject *) {
17013 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
17014 return 1;
17015 }
17016
17017
17018 static PyObject *_wrap_ART_CDROM_get(void) {
17019 PyObject *pyobj = NULL;
17020
17021 {
17022 #if wxUSE_UNICODE
17023 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
17024 #else
17025 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
17026 #endif
17027 }
17028 return pyobj;
17029 }
17030
17031
17032 static int _wrap_ART_REMOVABLE_set(PyObject *) {
17033 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
17034 return 1;
17035 }
17036
17037
17038 static PyObject *_wrap_ART_REMOVABLE_get(void) {
17039 PyObject *pyobj = NULL;
17040
17041 {
17042 #if wxUSE_UNICODE
17043 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
17044 #else
17045 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
17046 #endif
17047 }
17048 return pyobj;
17049 }
17050
17051
17052 static int _wrap_ART_FOLDER_set(PyObject *) {
17053 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
17054 return 1;
17055 }
17056
17057
17058 static PyObject *_wrap_ART_FOLDER_get(void) {
17059 PyObject *pyobj = NULL;
17060
17061 {
17062 #if wxUSE_UNICODE
17063 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
17064 #else
17065 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
17066 #endif
17067 }
17068 return pyobj;
17069 }
17070
17071
17072 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
17073 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
17074 return 1;
17075 }
17076
17077
17078 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
17079 PyObject *pyobj = NULL;
17080
17081 {
17082 #if wxUSE_UNICODE
17083 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
17084 #else
17085 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
17086 #endif
17087 }
17088 return pyobj;
17089 }
17090
17091
17092 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
17093 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
17094 return 1;
17095 }
17096
17097
17098 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
17099 PyObject *pyobj = NULL;
17100
17101 {
17102 #if wxUSE_UNICODE
17103 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
17104 #else
17105 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
17106 #endif
17107 }
17108 return pyobj;
17109 }
17110
17111
17112 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
17113 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
17114 return 1;
17115 }
17116
17117
17118 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
17119 PyObject *pyobj = NULL;
17120
17121 {
17122 #if wxUSE_UNICODE
17123 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
17124 #else
17125 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
17126 #endif
17127 }
17128 return pyobj;
17129 }
17130
17131
17132 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
17133 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
17134 return 1;
17135 }
17136
17137
17138 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
17139 PyObject *pyobj = NULL;
17140
17141 {
17142 #if wxUSE_UNICODE
17143 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
17144 #else
17145 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
17146 #endif
17147 }
17148 return pyobj;
17149 }
17150
17151
17152 static int _wrap_ART_TICK_MARK_set(PyObject *) {
17153 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
17154 return 1;
17155 }
17156
17157
17158 static PyObject *_wrap_ART_TICK_MARK_get(void) {
17159 PyObject *pyobj = NULL;
17160
17161 {
17162 #if wxUSE_UNICODE
17163 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
17164 #else
17165 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
17166 #endif
17167 }
17168 return pyobj;
17169 }
17170
17171
17172 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
17173 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
17174 return 1;
17175 }
17176
17177
17178 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
17179 PyObject *pyobj = NULL;
17180
17181 {
17182 #if wxUSE_UNICODE
17183 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
17184 #else
17185 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
17186 #endif
17187 }
17188 return pyobj;
17189 }
17190
17191
17192 static int _wrap_ART_ERROR_set(PyObject *) {
17193 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
17194 return 1;
17195 }
17196
17197
17198 static PyObject *_wrap_ART_ERROR_get(void) {
17199 PyObject *pyobj = NULL;
17200
17201 {
17202 #if wxUSE_UNICODE
17203 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
17204 #else
17205 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
17206 #endif
17207 }
17208 return pyobj;
17209 }
17210
17211
17212 static int _wrap_ART_QUESTION_set(PyObject *) {
17213 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
17214 return 1;
17215 }
17216
17217
17218 static PyObject *_wrap_ART_QUESTION_get(void) {
17219 PyObject *pyobj = NULL;
17220
17221 {
17222 #if wxUSE_UNICODE
17223 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
17224 #else
17225 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
17226 #endif
17227 }
17228 return pyobj;
17229 }
17230
17231
17232 static int _wrap_ART_WARNING_set(PyObject *) {
17233 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
17234 return 1;
17235 }
17236
17237
17238 static PyObject *_wrap_ART_WARNING_get(void) {
17239 PyObject *pyobj = NULL;
17240
17241 {
17242 #if wxUSE_UNICODE
17243 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
17244 #else
17245 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
17246 #endif
17247 }
17248 return pyobj;
17249 }
17250
17251
17252 static int _wrap_ART_INFORMATION_set(PyObject *) {
17253 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
17254 return 1;
17255 }
17256
17257
17258 static PyObject *_wrap_ART_INFORMATION_get(void) {
17259 PyObject *pyobj = NULL;
17260
17261 {
17262 #if wxUSE_UNICODE
17263 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
17264 #else
17265 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
17266 #endif
17267 }
17268 return pyobj;
17269 }
17270
17271
17272 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
17273 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
17274 return 1;
17275 }
17276
17277
17278 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
17279 PyObject *pyobj = NULL;
17280
17281 {
17282 #if wxUSE_UNICODE
17283 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
17284 #else
17285 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
17286 #endif
17287 }
17288 return pyobj;
17289 }
17290
17291
17292 static int _wrap_ART_COPY_set(PyObject *) {
17293 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
17294 return 1;
17295 }
17296
17297
17298 static PyObject *_wrap_ART_COPY_get(void) {
17299 PyObject *pyobj = NULL;
17300
17301 {
17302 #if wxUSE_UNICODE
17303 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
17304 #else
17305 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
17306 #endif
17307 }
17308 return pyobj;
17309 }
17310
17311
17312 static int _wrap_ART_CUT_set(PyObject *) {
17313 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
17314 return 1;
17315 }
17316
17317
17318 static PyObject *_wrap_ART_CUT_get(void) {
17319 PyObject *pyobj = NULL;
17320
17321 {
17322 #if wxUSE_UNICODE
17323 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
17324 #else
17325 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
17326 #endif
17327 }
17328 return pyobj;
17329 }
17330
17331
17332 static int _wrap_ART_PASTE_set(PyObject *) {
17333 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
17334 return 1;
17335 }
17336
17337
17338 static PyObject *_wrap_ART_PASTE_get(void) {
17339 PyObject *pyobj = NULL;
17340
17341 {
17342 #if wxUSE_UNICODE
17343 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
17344 #else
17345 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
17346 #endif
17347 }
17348 return pyobj;
17349 }
17350
17351
17352 static int _wrap_ART_DELETE_set(PyObject *) {
17353 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
17354 return 1;
17355 }
17356
17357
17358 static PyObject *_wrap_ART_DELETE_get(void) {
17359 PyObject *pyobj = NULL;
17360
17361 {
17362 #if wxUSE_UNICODE
17363 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
17364 #else
17365 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
17366 #endif
17367 }
17368 return pyobj;
17369 }
17370
17371
17372 static int _wrap_ART_NEW_set(PyObject *) {
17373 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW is read-only.");
17374 return 1;
17375 }
17376
17377
17378 static PyObject *_wrap_ART_NEW_get(void) {
17379 PyObject *pyobj = NULL;
17380
17381 {
17382 #if wxUSE_UNICODE
17383 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
17384 #else
17385 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
17386 #endif
17387 }
17388 return pyobj;
17389 }
17390
17391
17392 static int _wrap_ART_UNDO_set(PyObject *) {
17393 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
17394 return 1;
17395 }
17396
17397
17398 static PyObject *_wrap_ART_UNDO_get(void) {
17399 PyObject *pyobj = NULL;
17400
17401 {
17402 #if wxUSE_UNICODE
17403 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
17404 #else
17405 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
17406 #endif
17407 }
17408 return pyobj;
17409 }
17410
17411
17412 static int _wrap_ART_REDO_set(PyObject *) {
17413 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
17414 return 1;
17415 }
17416
17417
17418 static PyObject *_wrap_ART_REDO_get(void) {
17419 PyObject *pyobj = NULL;
17420
17421 {
17422 #if wxUSE_UNICODE
17423 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
17424 #else
17425 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
17426 #endif
17427 }
17428 return pyobj;
17429 }
17430
17431
17432 static int _wrap_ART_QUIT_set(PyObject *) {
17433 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
17434 return 1;
17435 }
17436
17437
17438 static PyObject *_wrap_ART_QUIT_get(void) {
17439 PyObject *pyobj = NULL;
17440
17441 {
17442 #if wxUSE_UNICODE
17443 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
17444 #else
17445 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
17446 #endif
17447 }
17448 return pyobj;
17449 }
17450
17451
17452 static int _wrap_ART_FIND_set(PyObject *) {
17453 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
17454 return 1;
17455 }
17456
17457
17458 static PyObject *_wrap_ART_FIND_get(void) {
17459 PyObject *pyobj = NULL;
17460
17461 {
17462 #if wxUSE_UNICODE
17463 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
17464 #else
17465 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
17466 #endif
17467 }
17468 return pyobj;
17469 }
17470
17471
17472 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
17473 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
17474 return 1;
17475 }
17476
17477
17478 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
17479 PyObject *pyobj = NULL;
17480
17481 {
17482 #if wxUSE_UNICODE
17483 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
17484 #else
17485 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
17486 #endif
17487 }
17488 return pyobj;
17489 }
17490
17491
17492 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17493 PyObject *resultobj = NULL;
17494 wxPyArtProvider *result;
17495 char *kwnames[] = {
17496 NULL
17497 };
17498
17499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
17500 {
17501 if (!wxPyCheckForApp()) SWIG_fail;
17502 PyThreadState* __tstate = wxPyBeginAllowThreads();
17503 result = (wxPyArtProvider *)new wxPyArtProvider();
17504
17505 wxPyEndAllowThreads(__tstate);
17506 if (PyErr_Occurred()) SWIG_fail;
17507 }
17508 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
17509 return resultobj;
17510 fail:
17511 return NULL;
17512 }
17513
17514
17515 static PyObject *_wrap_delete_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17516 PyObject *resultobj = NULL;
17517 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17518 PyObject * obj0 = 0 ;
17519 char *kwnames[] = {
17520 (char *) "self", NULL
17521 };
17522
17523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ArtProvider",kwnames,&obj0)) goto fail;
17524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17525 if (SWIG_arg_fail(1)) SWIG_fail;
17526 {
17527 PyThreadState* __tstate = wxPyBeginAllowThreads();
17528 delete arg1;
17529
17530 wxPyEndAllowThreads(__tstate);
17531 if (PyErr_Occurred()) SWIG_fail;
17532 }
17533 Py_INCREF(Py_None); resultobj = Py_None;
17534 return resultobj;
17535 fail:
17536 return NULL;
17537 }
17538
17539
17540 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
17541 PyObject *resultobj = NULL;
17542 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17543 PyObject *arg2 = (PyObject *) 0 ;
17544 PyObject *arg3 = (PyObject *) 0 ;
17545 PyObject * obj0 = 0 ;
17546 PyObject * obj1 = 0 ;
17547 PyObject * obj2 = 0 ;
17548 char *kwnames[] = {
17549 (char *) "self",(char *) "self",(char *) "_class", NULL
17550 };
17551
17552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
17553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17554 if (SWIG_arg_fail(1)) SWIG_fail;
17555 arg2 = obj1;
17556 arg3 = obj2;
17557 {
17558 PyThreadState* __tstate = wxPyBeginAllowThreads();
17559 (arg1)->_setCallbackInfo(arg2,arg3);
17560
17561 wxPyEndAllowThreads(__tstate);
17562 if (PyErr_Occurred()) SWIG_fail;
17563 }
17564 Py_INCREF(Py_None); resultobj = Py_None;
17565 return resultobj;
17566 fail:
17567 return NULL;
17568 }
17569
17570
17571 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17572 PyObject *resultobj = NULL;
17573 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17574 PyObject * obj0 = 0 ;
17575 char *kwnames[] = {
17576 (char *) "provider", NULL
17577 };
17578
17579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
17580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
17581 if (SWIG_arg_fail(1)) SWIG_fail;
17582 {
17583 PyThreadState* __tstate = wxPyBeginAllowThreads();
17584 wxPyArtProvider::PushProvider(arg1);
17585
17586 wxPyEndAllowThreads(__tstate);
17587 if (PyErr_Occurred()) SWIG_fail;
17588 }
17589 Py_INCREF(Py_None); resultobj = Py_None;
17590 return resultobj;
17591 fail:
17592 return NULL;
17593 }
17594
17595
17596 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17597 PyObject *resultobj = NULL;
17598 bool result;
17599 char *kwnames[] = {
17600 NULL
17601 };
17602
17603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
17604 {
17605 PyThreadState* __tstate = wxPyBeginAllowThreads();
17606 result = (bool)wxPyArtProvider::PopProvider();
17607
17608 wxPyEndAllowThreads(__tstate);
17609 if (PyErr_Occurred()) SWIG_fail;
17610 }
17611 {
17612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17613 }
17614 return resultobj;
17615 fail:
17616 return NULL;
17617 }
17618
17619
17620 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17621 PyObject *resultobj = NULL;
17622 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17623 bool result;
17624 PyObject * obj0 = 0 ;
17625 char *kwnames[] = {
17626 (char *) "provider", NULL
17627 };
17628
17629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
17630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17631 if (SWIG_arg_fail(1)) SWIG_fail;
17632 {
17633 PyThreadState* __tstate = wxPyBeginAllowThreads();
17634 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
17635
17636 wxPyEndAllowThreads(__tstate);
17637 if (PyErr_Occurred()) SWIG_fail;
17638 }
17639 {
17640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17641 }
17642 return resultobj;
17643 fail:
17644 return NULL;
17645 }
17646
17647
17648 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
17649 PyObject *resultobj = NULL;
17650 wxString *arg1 = 0 ;
17651 wxString const &arg2_defvalue = wxPyART_OTHER ;
17652 wxString *arg2 = (wxString *) &arg2_defvalue ;
17653 wxSize const &arg3_defvalue = wxDefaultSize ;
17654 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
17655 wxBitmap result;
17656 bool temp1 = false ;
17657 bool temp2 = false ;
17658 wxSize temp3 ;
17659 PyObject * obj0 = 0 ;
17660 PyObject * obj1 = 0 ;
17661 PyObject * obj2 = 0 ;
17662 char *kwnames[] = {
17663 (char *) "id",(char *) "client",(char *) "size", NULL
17664 };
17665
17666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
17667 {
17668 arg1 = wxString_in_helper(obj0);
17669 if (arg1 == NULL) SWIG_fail;
17670 temp1 = true;
17671 }
17672 if (obj1) {
17673 {
17674 arg2 = wxString_in_helper(obj1);
17675 if (arg2 == NULL) SWIG_fail;
17676 temp2 = true;
17677 }
17678 }
17679 if (obj2) {
17680 {
17681 arg3 = &temp3;
17682 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
17683 }
17684 }
17685 {
17686 if (!wxPyCheckForApp()) SWIG_fail;
17687 PyThreadState* __tstate = wxPyBeginAllowThreads();
17688 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
17689
17690 wxPyEndAllowThreads(__tstate);
17691 if (PyErr_Occurred()) SWIG_fail;
17692 }
17693 {
17694 wxBitmap * resultptr;
17695 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
17696 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
17697 }
17698 {
17699 if (temp1)
17700 delete arg1;
17701 }
17702 {
17703 if (temp2)
17704 delete arg2;
17705 }
17706 return resultobj;
17707 fail:
17708 {
17709 if (temp1)
17710 delete arg1;
17711 }
17712 {
17713 if (temp2)
17714 delete arg2;
17715 }
17716 return NULL;
17717 }
17718
17719
17720 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
17721 PyObject *resultobj = NULL;
17722 wxString *arg1 = 0 ;
17723 wxString const &arg2_defvalue = wxPyART_OTHER ;
17724 wxString *arg2 = (wxString *) &arg2_defvalue ;
17725 wxSize const &arg3_defvalue = wxDefaultSize ;
17726 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
17727 wxIcon result;
17728 bool temp1 = false ;
17729 bool temp2 = false ;
17730 wxSize temp3 ;
17731 PyObject * obj0 = 0 ;
17732 PyObject * obj1 = 0 ;
17733 PyObject * obj2 = 0 ;
17734 char *kwnames[] = {
17735 (char *) "id",(char *) "client",(char *) "size", NULL
17736 };
17737
17738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
17739 {
17740 arg1 = wxString_in_helper(obj0);
17741 if (arg1 == NULL) SWIG_fail;
17742 temp1 = true;
17743 }
17744 if (obj1) {
17745 {
17746 arg2 = wxString_in_helper(obj1);
17747 if (arg2 == NULL) SWIG_fail;
17748 temp2 = true;
17749 }
17750 }
17751 if (obj2) {
17752 {
17753 arg3 = &temp3;
17754 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
17755 }
17756 }
17757 {
17758 if (!wxPyCheckForApp()) SWIG_fail;
17759 PyThreadState* __tstate = wxPyBeginAllowThreads();
17760 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
17761
17762 wxPyEndAllowThreads(__tstate);
17763 if (PyErr_Occurred()) SWIG_fail;
17764 }
17765 {
17766 wxIcon * resultptr;
17767 resultptr = new wxIcon(static_cast<wxIcon & >(result));
17768 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
17769 }
17770 {
17771 if (temp1)
17772 delete arg1;
17773 }
17774 {
17775 if (temp2)
17776 delete arg2;
17777 }
17778 return resultobj;
17779 fail:
17780 {
17781 if (temp1)
17782 delete arg1;
17783 }
17784 {
17785 if (temp2)
17786 delete arg2;
17787 }
17788 return NULL;
17789 }
17790
17791
17792 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
17793 PyObject *resultobj = NULL;
17794 wxString *arg1 = 0 ;
17795 bool arg2 = (bool) false ;
17796 wxSize result;
17797 bool temp1 = false ;
17798 PyObject * obj0 = 0 ;
17799 PyObject * obj1 = 0 ;
17800 char *kwnames[] = {
17801 (char *) "client",(char *) "platform_dependent", NULL
17802 };
17803
17804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
17805 {
17806 arg1 = wxString_in_helper(obj0);
17807 if (arg1 == NULL) SWIG_fail;
17808 temp1 = true;
17809 }
17810 if (obj1) {
17811 {
17812 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
17813 if (SWIG_arg_fail(2)) SWIG_fail;
17814 }
17815 }
17816 {
17817 PyThreadState* __tstate = wxPyBeginAllowThreads();
17818 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
17819
17820 wxPyEndAllowThreads(__tstate);
17821 if (PyErr_Occurred()) SWIG_fail;
17822 }
17823 {
17824 wxSize * resultptr;
17825 resultptr = new wxSize(static_cast<wxSize & >(result));
17826 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
17827 }
17828 {
17829 if (temp1)
17830 delete arg1;
17831 }
17832 return resultobj;
17833 fail:
17834 {
17835 if (temp1)
17836 delete arg1;
17837 }
17838 return NULL;
17839 }
17840
17841
17842 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
17843 PyObject *resultobj = NULL;
17844 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17845 PyObject * obj0 = 0 ;
17846 char *kwnames[] = {
17847 (char *) "self", NULL
17848 };
17849
17850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
17851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17852 if (SWIG_arg_fail(1)) SWIG_fail;
17853 {
17854 PyThreadState* __tstate = wxPyBeginAllowThreads();
17855 wxPyArtProvider_Destroy(arg1);
17856
17857 wxPyEndAllowThreads(__tstate);
17858 if (PyErr_Occurred()) SWIG_fail;
17859 }
17860 Py_INCREF(Py_None); resultobj = Py_None;
17861 return resultobj;
17862 fail:
17863 return NULL;
17864 }
17865
17866
17867 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
17868 PyObject *obj;
17869 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17870 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
17871 Py_INCREF(obj);
17872 return Py_BuildValue((char *)"");
17873 }
17874 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
17875 PyObject *resultobj = NULL;
17876 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17877 PyObject * obj0 = 0 ;
17878 char *kwnames[] = {
17879 (char *) "self", NULL
17880 };
17881
17882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
17883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17884 if (SWIG_arg_fail(1)) SWIG_fail;
17885 {
17886 PyThreadState* __tstate = wxPyBeginAllowThreads();
17887 delete arg1;
17888
17889 wxPyEndAllowThreads(__tstate);
17890 if (PyErr_Occurred()) SWIG_fail;
17891 }
17892 Py_INCREF(Py_None); resultobj = Py_None;
17893 return resultobj;
17894 fail:
17895 return NULL;
17896 }
17897
17898
17899 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
17900 PyObject *resultobj = NULL;
17901 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17902 wxConfigBase *result;
17903 PyObject * obj0 = 0 ;
17904 char *kwnames[] = {
17905 (char *) "config", NULL
17906 };
17907
17908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
17909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
17910 if (SWIG_arg_fail(1)) SWIG_fail;
17911 {
17912 PyThreadState* __tstate = wxPyBeginAllowThreads();
17913 result = (wxConfigBase *)wxConfigBase::Set(arg1);
17914
17915 wxPyEndAllowThreads(__tstate);
17916 if (PyErr_Occurred()) SWIG_fail;
17917 }
17918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17919 return resultobj;
17920 fail:
17921 return NULL;
17922 }
17923
17924
17925 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
17926 PyObject *resultobj = NULL;
17927 bool arg1 = (bool) true ;
17928 wxConfigBase *result;
17929 PyObject * obj0 = 0 ;
17930 char *kwnames[] = {
17931 (char *) "createOnDemand", NULL
17932 };
17933
17934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
17935 if (obj0) {
17936 {
17937 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
17938 if (SWIG_arg_fail(1)) SWIG_fail;
17939 }
17940 }
17941 {
17942 PyThreadState* __tstate = wxPyBeginAllowThreads();
17943 result = (wxConfigBase *)wxConfigBase::Get(arg1);
17944
17945 wxPyEndAllowThreads(__tstate);
17946 if (PyErr_Occurred()) SWIG_fail;
17947 }
17948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17949 return resultobj;
17950 fail:
17951 return NULL;
17952 }
17953
17954
17955 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17956 PyObject *resultobj = NULL;
17957 wxConfigBase *result;
17958 char *kwnames[] = {
17959 NULL
17960 };
17961
17962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
17963 {
17964 PyThreadState* __tstate = wxPyBeginAllowThreads();
17965 result = (wxConfigBase *)wxConfigBase::Create();
17966
17967 wxPyEndAllowThreads(__tstate);
17968 if (PyErr_Occurred()) SWIG_fail;
17969 }
17970 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17971 return resultobj;
17972 fail:
17973 return NULL;
17974 }
17975
17976
17977 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17978 PyObject *resultobj = NULL;
17979 char *kwnames[] = {
17980 NULL
17981 };
17982
17983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17984 {
17985 PyThreadState* __tstate = wxPyBeginAllowThreads();
17986 wxConfigBase::DontCreateOnDemand();
17987
17988 wxPyEndAllowThreads(__tstate);
17989 if (PyErr_Occurred()) SWIG_fail;
17990 }
17991 Py_INCREF(Py_None); resultobj = Py_None;
17992 return resultobj;
17993 fail:
17994 return NULL;
17995 }
17996
17997
17998 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17999 PyObject *resultobj = NULL;
18000 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18001 wxString *arg2 = 0 ;
18002 bool temp2 = false ;
18003 PyObject * obj0 = 0 ;
18004 PyObject * obj1 = 0 ;
18005 char *kwnames[] = {
18006 (char *) "self",(char *) "path", NULL
18007 };
18008
18009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
18010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18011 if (SWIG_arg_fail(1)) SWIG_fail;
18012 {
18013 arg2 = wxString_in_helper(obj1);
18014 if (arg2 == NULL) SWIG_fail;
18015 temp2 = true;
18016 }
18017 {
18018 PyThreadState* __tstate = wxPyBeginAllowThreads();
18019 (arg1)->SetPath((wxString const &)*arg2);
18020
18021 wxPyEndAllowThreads(__tstate);
18022 if (PyErr_Occurred()) SWIG_fail;
18023 }
18024 Py_INCREF(Py_None); resultobj = Py_None;
18025 {
18026 if (temp2)
18027 delete arg2;
18028 }
18029 return resultobj;
18030 fail:
18031 {
18032 if (temp2)
18033 delete arg2;
18034 }
18035 return NULL;
18036 }
18037
18038
18039 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
18040 PyObject *resultobj = NULL;
18041 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18042 wxString *result;
18043 PyObject * obj0 = 0 ;
18044 char *kwnames[] = {
18045 (char *) "self", NULL
18046 };
18047
18048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
18049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18050 if (SWIG_arg_fail(1)) SWIG_fail;
18051 {
18052 PyThreadState* __tstate = wxPyBeginAllowThreads();
18053 {
18054 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
18055 result = (wxString *) &_result_ref;
18056 }
18057
18058 wxPyEndAllowThreads(__tstate);
18059 if (PyErr_Occurred()) SWIG_fail;
18060 }
18061 {
18062 #if wxUSE_UNICODE
18063 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18064 #else
18065 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18066 #endif
18067 }
18068 return resultobj;
18069 fail:
18070 return NULL;
18071 }
18072
18073
18074 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18075 PyObject *resultobj = NULL;
18076 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18077 PyObject *result;
18078 PyObject * obj0 = 0 ;
18079 char *kwnames[] = {
18080 (char *) "self", NULL
18081 };
18082
18083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
18084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18085 if (SWIG_arg_fail(1)) SWIG_fail;
18086 {
18087 PyThreadState* __tstate = wxPyBeginAllowThreads();
18088 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
18089
18090 wxPyEndAllowThreads(__tstate);
18091 if (PyErr_Occurred()) SWIG_fail;
18092 }
18093 resultobj = result;
18094 return resultobj;
18095 fail:
18096 return NULL;
18097 }
18098
18099
18100 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18101 PyObject *resultobj = NULL;
18102 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18103 long arg2 ;
18104 PyObject *result;
18105 PyObject * obj0 = 0 ;
18106 PyObject * obj1 = 0 ;
18107 char *kwnames[] = {
18108 (char *) "self",(char *) "index", NULL
18109 };
18110
18111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
18112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18113 if (SWIG_arg_fail(1)) SWIG_fail;
18114 {
18115 arg2 = static_cast<long >(SWIG_As_long(obj1));
18116 if (SWIG_arg_fail(2)) SWIG_fail;
18117 }
18118 {
18119 PyThreadState* __tstate = wxPyBeginAllowThreads();
18120 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
18121
18122 wxPyEndAllowThreads(__tstate);
18123 if (PyErr_Occurred()) SWIG_fail;
18124 }
18125 resultobj = result;
18126 return resultobj;
18127 fail:
18128 return NULL;
18129 }
18130
18131
18132 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18133 PyObject *resultobj = NULL;
18134 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18135 PyObject *result;
18136 PyObject * obj0 = 0 ;
18137 char *kwnames[] = {
18138 (char *) "self", NULL
18139 };
18140
18141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
18142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18143 if (SWIG_arg_fail(1)) SWIG_fail;
18144 {
18145 PyThreadState* __tstate = wxPyBeginAllowThreads();
18146 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
18147
18148 wxPyEndAllowThreads(__tstate);
18149 if (PyErr_Occurred()) SWIG_fail;
18150 }
18151 resultobj = result;
18152 return resultobj;
18153 fail:
18154 return NULL;
18155 }
18156
18157
18158 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18159 PyObject *resultobj = NULL;
18160 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18161 long arg2 ;
18162 PyObject *result;
18163 PyObject * obj0 = 0 ;
18164 PyObject * obj1 = 0 ;
18165 char *kwnames[] = {
18166 (char *) "self",(char *) "index", NULL
18167 };
18168
18169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
18170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18171 if (SWIG_arg_fail(1)) SWIG_fail;
18172 {
18173 arg2 = static_cast<long >(SWIG_As_long(obj1));
18174 if (SWIG_arg_fail(2)) SWIG_fail;
18175 }
18176 {
18177 PyThreadState* __tstate = wxPyBeginAllowThreads();
18178 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
18179
18180 wxPyEndAllowThreads(__tstate);
18181 if (PyErr_Occurred()) SWIG_fail;
18182 }
18183 resultobj = result;
18184 return resultobj;
18185 fail:
18186 return NULL;
18187 }
18188
18189
18190 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
18191 PyObject *resultobj = NULL;
18192 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18193 bool arg2 = (bool) false ;
18194 size_t result;
18195 PyObject * obj0 = 0 ;
18196 PyObject * obj1 = 0 ;
18197 char *kwnames[] = {
18198 (char *) "self",(char *) "recursive", NULL
18199 };
18200
18201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
18202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18203 if (SWIG_arg_fail(1)) SWIG_fail;
18204 if (obj1) {
18205 {
18206 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18207 if (SWIG_arg_fail(2)) SWIG_fail;
18208 }
18209 }
18210 {
18211 PyThreadState* __tstate = wxPyBeginAllowThreads();
18212 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
18213
18214 wxPyEndAllowThreads(__tstate);
18215 if (PyErr_Occurred()) SWIG_fail;
18216 }
18217 {
18218 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
18219 }
18220 return resultobj;
18221 fail:
18222 return NULL;
18223 }
18224
18225
18226 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
18227 PyObject *resultobj = NULL;
18228 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18229 bool arg2 = (bool) false ;
18230 size_t result;
18231 PyObject * obj0 = 0 ;
18232 PyObject * obj1 = 0 ;
18233 char *kwnames[] = {
18234 (char *) "self",(char *) "recursive", NULL
18235 };
18236
18237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
18238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18239 if (SWIG_arg_fail(1)) SWIG_fail;
18240 if (obj1) {
18241 {
18242 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18243 if (SWIG_arg_fail(2)) SWIG_fail;
18244 }
18245 }
18246 {
18247 PyThreadState* __tstate = wxPyBeginAllowThreads();
18248 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
18249
18250 wxPyEndAllowThreads(__tstate);
18251 if (PyErr_Occurred()) SWIG_fail;
18252 }
18253 {
18254 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
18255 }
18256 return resultobj;
18257 fail:
18258 return NULL;
18259 }
18260
18261
18262 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18263 PyObject *resultobj = NULL;
18264 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18265 wxString *arg2 = 0 ;
18266 bool result;
18267 bool temp2 = false ;
18268 PyObject * obj0 = 0 ;
18269 PyObject * obj1 = 0 ;
18270 char *kwnames[] = {
18271 (char *) "self",(char *) "name", NULL
18272 };
18273
18274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
18275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18276 if (SWIG_arg_fail(1)) SWIG_fail;
18277 {
18278 arg2 = wxString_in_helper(obj1);
18279 if (arg2 == NULL) SWIG_fail;
18280 temp2 = true;
18281 }
18282 {
18283 PyThreadState* __tstate = wxPyBeginAllowThreads();
18284 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
18285
18286 wxPyEndAllowThreads(__tstate);
18287 if (PyErr_Occurred()) SWIG_fail;
18288 }
18289 {
18290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18291 }
18292 {
18293 if (temp2)
18294 delete arg2;
18295 }
18296 return resultobj;
18297 fail:
18298 {
18299 if (temp2)
18300 delete arg2;
18301 }
18302 return NULL;
18303 }
18304
18305
18306 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18307 PyObject *resultobj = NULL;
18308 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18309 wxString *arg2 = 0 ;
18310 bool result;
18311 bool temp2 = false ;
18312 PyObject * obj0 = 0 ;
18313 PyObject * obj1 = 0 ;
18314 char *kwnames[] = {
18315 (char *) "self",(char *) "name", NULL
18316 };
18317
18318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
18319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18320 if (SWIG_arg_fail(1)) SWIG_fail;
18321 {
18322 arg2 = wxString_in_helper(obj1);
18323 if (arg2 == NULL) SWIG_fail;
18324 temp2 = true;
18325 }
18326 {
18327 PyThreadState* __tstate = wxPyBeginAllowThreads();
18328 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
18329
18330 wxPyEndAllowThreads(__tstate);
18331 if (PyErr_Occurred()) SWIG_fail;
18332 }
18333 {
18334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18335 }
18336 {
18337 if (temp2)
18338 delete arg2;
18339 }
18340 return resultobj;
18341 fail:
18342 {
18343 if (temp2)
18344 delete arg2;
18345 }
18346 return NULL;
18347 }
18348
18349
18350 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
18351 PyObject *resultobj = NULL;
18352 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18353 wxString *arg2 = 0 ;
18354 bool result;
18355 bool temp2 = false ;
18356 PyObject * obj0 = 0 ;
18357 PyObject * obj1 = 0 ;
18358 char *kwnames[] = {
18359 (char *) "self",(char *) "name", NULL
18360 };
18361
18362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
18363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18364 if (SWIG_arg_fail(1)) SWIG_fail;
18365 {
18366 arg2 = wxString_in_helper(obj1);
18367 if (arg2 == NULL) SWIG_fail;
18368 temp2 = true;
18369 }
18370 {
18371 PyThreadState* __tstate = wxPyBeginAllowThreads();
18372 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
18373
18374 wxPyEndAllowThreads(__tstate);
18375 if (PyErr_Occurred()) SWIG_fail;
18376 }
18377 {
18378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18379 }
18380 {
18381 if (temp2)
18382 delete arg2;
18383 }
18384 return resultobj;
18385 fail:
18386 {
18387 if (temp2)
18388 delete arg2;
18389 }
18390 return NULL;
18391 }
18392
18393
18394 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
18395 PyObject *resultobj = NULL;
18396 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18397 wxString *arg2 = 0 ;
18398 wxConfigBase::EntryType result;
18399 bool temp2 = false ;
18400 PyObject * obj0 = 0 ;
18401 PyObject * obj1 = 0 ;
18402 char *kwnames[] = {
18403 (char *) "self",(char *) "name", NULL
18404 };
18405
18406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
18407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18408 if (SWIG_arg_fail(1)) SWIG_fail;
18409 {
18410 arg2 = wxString_in_helper(obj1);
18411 if (arg2 == NULL) SWIG_fail;
18412 temp2 = true;
18413 }
18414 {
18415 PyThreadState* __tstate = wxPyBeginAllowThreads();
18416 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
18417
18418 wxPyEndAllowThreads(__tstate);
18419 if (PyErr_Occurred()) SWIG_fail;
18420 }
18421 resultobj = SWIG_From_int((result));
18422 {
18423 if (temp2)
18424 delete arg2;
18425 }
18426 return resultobj;
18427 fail:
18428 {
18429 if (temp2)
18430 delete arg2;
18431 }
18432 return NULL;
18433 }
18434
18435
18436 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
18437 PyObject *resultobj = NULL;
18438 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18439 wxString *arg2 = 0 ;
18440 wxString const &arg3_defvalue = wxPyEmptyString ;
18441 wxString *arg3 = (wxString *) &arg3_defvalue ;
18442 wxString result;
18443 bool temp2 = false ;
18444 bool temp3 = false ;
18445 PyObject * obj0 = 0 ;
18446 PyObject * obj1 = 0 ;
18447 PyObject * obj2 = 0 ;
18448 char *kwnames[] = {
18449 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
18450 };
18451
18452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
18453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18454 if (SWIG_arg_fail(1)) SWIG_fail;
18455 {
18456 arg2 = wxString_in_helper(obj1);
18457 if (arg2 == NULL) SWIG_fail;
18458 temp2 = true;
18459 }
18460 if (obj2) {
18461 {
18462 arg3 = wxString_in_helper(obj2);
18463 if (arg3 == NULL) SWIG_fail;
18464 temp3 = true;
18465 }
18466 }
18467 {
18468 PyThreadState* __tstate = wxPyBeginAllowThreads();
18469 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
18470
18471 wxPyEndAllowThreads(__tstate);
18472 if (PyErr_Occurred()) SWIG_fail;
18473 }
18474 {
18475 #if wxUSE_UNICODE
18476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18477 #else
18478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18479 #endif
18480 }
18481 {
18482 if (temp2)
18483 delete arg2;
18484 }
18485 {
18486 if (temp3)
18487 delete arg3;
18488 }
18489 return resultobj;
18490 fail:
18491 {
18492 if (temp2)
18493 delete arg2;
18494 }
18495 {
18496 if (temp3)
18497 delete arg3;
18498 }
18499 return NULL;
18500 }
18501
18502
18503 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
18504 PyObject *resultobj = NULL;
18505 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18506 wxString *arg2 = 0 ;
18507 long arg3 = (long) 0 ;
18508 long result;
18509 bool temp2 = false ;
18510 PyObject * obj0 = 0 ;
18511 PyObject * obj1 = 0 ;
18512 PyObject * obj2 = 0 ;
18513 char *kwnames[] = {
18514 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
18515 };
18516
18517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
18518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18519 if (SWIG_arg_fail(1)) SWIG_fail;
18520 {
18521 arg2 = wxString_in_helper(obj1);
18522 if (arg2 == NULL) SWIG_fail;
18523 temp2 = true;
18524 }
18525 if (obj2) {
18526 {
18527 arg3 = static_cast<long >(SWIG_As_long(obj2));
18528 if (SWIG_arg_fail(3)) SWIG_fail;
18529 }
18530 }
18531 {
18532 PyThreadState* __tstate = wxPyBeginAllowThreads();
18533 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
18534
18535 wxPyEndAllowThreads(__tstate);
18536 if (PyErr_Occurred()) SWIG_fail;
18537 }
18538 {
18539 resultobj = SWIG_From_long(static_cast<long >(result));
18540 }
18541 {
18542 if (temp2)
18543 delete arg2;
18544 }
18545 return resultobj;
18546 fail:
18547 {
18548 if (temp2)
18549 delete arg2;
18550 }
18551 return NULL;
18552 }
18553
18554
18555 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
18556 PyObject *resultobj = NULL;
18557 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18558 wxString *arg2 = 0 ;
18559 double arg3 = (double) 0.0 ;
18560 double result;
18561 bool temp2 = false ;
18562 PyObject * obj0 = 0 ;
18563 PyObject * obj1 = 0 ;
18564 PyObject * obj2 = 0 ;
18565 char *kwnames[] = {
18566 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
18567 };
18568
18569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
18570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18571 if (SWIG_arg_fail(1)) SWIG_fail;
18572 {
18573 arg2 = wxString_in_helper(obj1);
18574 if (arg2 == NULL) SWIG_fail;
18575 temp2 = true;
18576 }
18577 if (obj2) {
18578 {
18579 arg3 = static_cast<double >(SWIG_As_double(obj2));
18580 if (SWIG_arg_fail(3)) SWIG_fail;
18581 }
18582 }
18583 {
18584 PyThreadState* __tstate = wxPyBeginAllowThreads();
18585 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
18586
18587 wxPyEndAllowThreads(__tstate);
18588 if (PyErr_Occurred()) SWIG_fail;
18589 }
18590 {
18591 resultobj = SWIG_From_double(static_cast<double >(result));
18592 }
18593 {
18594 if (temp2)
18595 delete arg2;
18596 }
18597 return resultobj;
18598 fail:
18599 {
18600 if (temp2)
18601 delete arg2;
18602 }
18603 return NULL;
18604 }
18605
18606
18607 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
18608 PyObject *resultobj = NULL;
18609 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18610 wxString *arg2 = 0 ;
18611 bool arg3 = (bool) false ;
18612 bool result;
18613 bool temp2 = false ;
18614 PyObject * obj0 = 0 ;
18615 PyObject * obj1 = 0 ;
18616 PyObject * obj2 = 0 ;
18617 char *kwnames[] = {
18618 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
18619 };
18620
18621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
18622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18623 if (SWIG_arg_fail(1)) SWIG_fail;
18624 {
18625 arg2 = wxString_in_helper(obj1);
18626 if (arg2 == NULL) SWIG_fail;
18627 temp2 = true;
18628 }
18629 if (obj2) {
18630 {
18631 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
18632 if (SWIG_arg_fail(3)) SWIG_fail;
18633 }
18634 }
18635 {
18636 PyThreadState* __tstate = wxPyBeginAllowThreads();
18637 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
18638
18639 wxPyEndAllowThreads(__tstate);
18640 if (PyErr_Occurred()) SWIG_fail;
18641 }
18642 {
18643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18644 }
18645 {
18646 if (temp2)
18647 delete arg2;
18648 }
18649 return resultobj;
18650 fail:
18651 {
18652 if (temp2)
18653 delete arg2;
18654 }
18655 return NULL;
18656 }
18657
18658
18659 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
18660 PyObject *resultobj = NULL;
18661 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18662 wxString *arg2 = 0 ;
18663 wxString *arg3 = 0 ;
18664 bool result;
18665 bool temp2 = false ;
18666 bool temp3 = false ;
18667 PyObject * obj0 = 0 ;
18668 PyObject * obj1 = 0 ;
18669 PyObject * obj2 = 0 ;
18670 char *kwnames[] = {
18671 (char *) "self",(char *) "key",(char *) "value", NULL
18672 };
18673
18674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
18675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18676 if (SWIG_arg_fail(1)) SWIG_fail;
18677 {
18678 arg2 = wxString_in_helper(obj1);
18679 if (arg2 == NULL) SWIG_fail;
18680 temp2 = true;
18681 }
18682 {
18683 arg3 = wxString_in_helper(obj2);
18684 if (arg3 == NULL) SWIG_fail;
18685 temp3 = true;
18686 }
18687 {
18688 PyThreadState* __tstate = wxPyBeginAllowThreads();
18689 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
18690
18691 wxPyEndAllowThreads(__tstate);
18692 if (PyErr_Occurred()) SWIG_fail;
18693 }
18694 {
18695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18696 }
18697 {
18698 if (temp2)
18699 delete arg2;
18700 }
18701 {
18702 if (temp3)
18703 delete arg3;
18704 }
18705 return resultobj;
18706 fail:
18707 {
18708 if (temp2)
18709 delete arg2;
18710 }
18711 {
18712 if (temp3)
18713 delete arg3;
18714 }
18715 return NULL;
18716 }
18717
18718
18719 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
18720 PyObject *resultobj = NULL;
18721 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18722 wxString *arg2 = 0 ;
18723 long arg3 ;
18724 bool result;
18725 bool temp2 = false ;
18726 PyObject * obj0 = 0 ;
18727 PyObject * obj1 = 0 ;
18728 PyObject * obj2 = 0 ;
18729 char *kwnames[] = {
18730 (char *) "self",(char *) "key",(char *) "value", NULL
18731 };
18732
18733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
18734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18735 if (SWIG_arg_fail(1)) SWIG_fail;
18736 {
18737 arg2 = wxString_in_helper(obj1);
18738 if (arg2 == NULL) SWIG_fail;
18739 temp2 = true;
18740 }
18741 {
18742 arg3 = static_cast<long >(SWIG_As_long(obj2));
18743 if (SWIG_arg_fail(3)) SWIG_fail;
18744 }
18745 {
18746 PyThreadState* __tstate = wxPyBeginAllowThreads();
18747 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
18748
18749 wxPyEndAllowThreads(__tstate);
18750 if (PyErr_Occurred()) SWIG_fail;
18751 }
18752 {
18753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18754 }
18755 {
18756 if (temp2)
18757 delete arg2;
18758 }
18759 return resultobj;
18760 fail:
18761 {
18762 if (temp2)
18763 delete arg2;
18764 }
18765 return NULL;
18766 }
18767
18768
18769 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
18770 PyObject *resultobj = NULL;
18771 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18772 wxString *arg2 = 0 ;
18773 double arg3 ;
18774 bool result;
18775 bool temp2 = false ;
18776 PyObject * obj0 = 0 ;
18777 PyObject * obj1 = 0 ;
18778 PyObject * obj2 = 0 ;
18779 char *kwnames[] = {
18780 (char *) "self",(char *) "key",(char *) "value", NULL
18781 };
18782
18783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
18784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18785 if (SWIG_arg_fail(1)) SWIG_fail;
18786 {
18787 arg2 = wxString_in_helper(obj1);
18788 if (arg2 == NULL) SWIG_fail;
18789 temp2 = true;
18790 }
18791 {
18792 arg3 = static_cast<double >(SWIG_As_double(obj2));
18793 if (SWIG_arg_fail(3)) SWIG_fail;
18794 }
18795 {
18796 PyThreadState* __tstate = wxPyBeginAllowThreads();
18797 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
18798
18799 wxPyEndAllowThreads(__tstate);
18800 if (PyErr_Occurred()) SWIG_fail;
18801 }
18802 {
18803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18804 }
18805 {
18806 if (temp2)
18807 delete arg2;
18808 }
18809 return resultobj;
18810 fail:
18811 {
18812 if (temp2)
18813 delete arg2;
18814 }
18815 return NULL;
18816 }
18817
18818
18819 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
18820 PyObject *resultobj = NULL;
18821 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18822 wxString *arg2 = 0 ;
18823 bool arg3 ;
18824 bool result;
18825 bool temp2 = false ;
18826 PyObject * obj0 = 0 ;
18827 PyObject * obj1 = 0 ;
18828 PyObject * obj2 = 0 ;
18829 char *kwnames[] = {
18830 (char *) "self",(char *) "key",(char *) "value", NULL
18831 };
18832
18833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
18834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18835 if (SWIG_arg_fail(1)) SWIG_fail;
18836 {
18837 arg2 = wxString_in_helper(obj1);
18838 if (arg2 == NULL) SWIG_fail;
18839 temp2 = true;
18840 }
18841 {
18842 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
18843 if (SWIG_arg_fail(3)) SWIG_fail;
18844 }
18845 {
18846 PyThreadState* __tstate = wxPyBeginAllowThreads();
18847 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
18848
18849 wxPyEndAllowThreads(__tstate);
18850 if (PyErr_Occurred()) SWIG_fail;
18851 }
18852 {
18853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18854 }
18855 {
18856 if (temp2)
18857 delete arg2;
18858 }
18859 return resultobj;
18860 fail:
18861 {
18862 if (temp2)
18863 delete arg2;
18864 }
18865 return NULL;
18866 }
18867
18868
18869 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
18870 PyObject *resultobj = NULL;
18871 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18872 bool arg2 = (bool) false ;
18873 bool result;
18874 PyObject * obj0 = 0 ;
18875 PyObject * obj1 = 0 ;
18876 char *kwnames[] = {
18877 (char *) "self",(char *) "currentOnly", NULL
18878 };
18879
18880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
18881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18882 if (SWIG_arg_fail(1)) SWIG_fail;
18883 if (obj1) {
18884 {
18885 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18886 if (SWIG_arg_fail(2)) SWIG_fail;
18887 }
18888 }
18889 {
18890 PyThreadState* __tstate = wxPyBeginAllowThreads();
18891 result = (bool)(arg1)->Flush(arg2);
18892
18893 wxPyEndAllowThreads(__tstate);
18894 if (PyErr_Occurred()) SWIG_fail;
18895 }
18896 {
18897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18898 }
18899 return resultobj;
18900 fail:
18901 return NULL;
18902 }
18903
18904
18905 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18906 PyObject *resultobj = NULL;
18907 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18908 wxString *arg2 = 0 ;
18909 wxString *arg3 = 0 ;
18910 bool result;
18911 bool temp2 = false ;
18912 bool temp3 = false ;
18913 PyObject * obj0 = 0 ;
18914 PyObject * obj1 = 0 ;
18915 PyObject * obj2 = 0 ;
18916 char *kwnames[] = {
18917 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18918 };
18919
18920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18922 if (SWIG_arg_fail(1)) SWIG_fail;
18923 {
18924 arg2 = wxString_in_helper(obj1);
18925 if (arg2 == NULL) SWIG_fail;
18926 temp2 = true;
18927 }
18928 {
18929 arg3 = wxString_in_helper(obj2);
18930 if (arg3 == NULL) SWIG_fail;
18931 temp3 = true;
18932 }
18933 {
18934 PyThreadState* __tstate = wxPyBeginAllowThreads();
18935 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
18936
18937 wxPyEndAllowThreads(__tstate);
18938 if (PyErr_Occurred()) SWIG_fail;
18939 }
18940 {
18941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18942 }
18943 {
18944 if (temp2)
18945 delete arg2;
18946 }
18947 {
18948 if (temp3)
18949 delete arg3;
18950 }
18951 return resultobj;
18952 fail:
18953 {
18954 if (temp2)
18955 delete arg2;
18956 }
18957 {
18958 if (temp3)
18959 delete arg3;
18960 }
18961 return NULL;
18962 }
18963
18964
18965 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18966 PyObject *resultobj = NULL;
18967 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18968 wxString *arg2 = 0 ;
18969 wxString *arg3 = 0 ;
18970 bool result;
18971 bool temp2 = false ;
18972 bool temp3 = false ;
18973 PyObject * obj0 = 0 ;
18974 PyObject * obj1 = 0 ;
18975 PyObject * obj2 = 0 ;
18976 char *kwnames[] = {
18977 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18978 };
18979
18980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18982 if (SWIG_arg_fail(1)) SWIG_fail;
18983 {
18984 arg2 = wxString_in_helper(obj1);
18985 if (arg2 == NULL) SWIG_fail;
18986 temp2 = true;
18987 }
18988 {
18989 arg3 = wxString_in_helper(obj2);
18990 if (arg3 == NULL) SWIG_fail;
18991 temp3 = true;
18992 }
18993 {
18994 PyThreadState* __tstate = wxPyBeginAllowThreads();
18995 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18996
18997 wxPyEndAllowThreads(__tstate);
18998 if (PyErr_Occurred()) SWIG_fail;
18999 }
19000 {
19001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19002 }
19003 {
19004 if (temp2)
19005 delete arg2;
19006 }
19007 {
19008 if (temp3)
19009 delete arg3;
19010 }
19011 return resultobj;
19012 fail:
19013 {
19014 if (temp2)
19015 delete arg2;
19016 }
19017 {
19018 if (temp3)
19019 delete arg3;
19020 }
19021 return NULL;
19022 }
19023
19024
19025 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
19026 PyObject *resultobj = NULL;
19027 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19028 wxString *arg2 = 0 ;
19029 bool arg3 = (bool) true ;
19030 bool result;
19031 bool temp2 = false ;
19032 PyObject * obj0 = 0 ;
19033 PyObject * obj1 = 0 ;
19034 PyObject * obj2 = 0 ;
19035 char *kwnames[] = {
19036 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
19037 };
19038
19039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
19040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19041 if (SWIG_arg_fail(1)) SWIG_fail;
19042 {
19043 arg2 = wxString_in_helper(obj1);
19044 if (arg2 == NULL) SWIG_fail;
19045 temp2 = true;
19046 }
19047 if (obj2) {
19048 {
19049 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
19050 if (SWIG_arg_fail(3)) SWIG_fail;
19051 }
19052 }
19053 {
19054 PyThreadState* __tstate = wxPyBeginAllowThreads();
19055 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
19056
19057 wxPyEndAllowThreads(__tstate);
19058 if (PyErr_Occurred()) SWIG_fail;
19059 }
19060 {
19061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19062 }
19063 {
19064 if (temp2)
19065 delete arg2;
19066 }
19067 return resultobj;
19068 fail:
19069 {
19070 if (temp2)
19071 delete arg2;
19072 }
19073 return NULL;
19074 }
19075
19076
19077 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
19078 PyObject *resultobj = NULL;
19079 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19080 wxString *arg2 = 0 ;
19081 bool result;
19082 bool temp2 = false ;
19083 PyObject * obj0 = 0 ;
19084 PyObject * obj1 = 0 ;
19085 char *kwnames[] = {
19086 (char *) "self",(char *) "key", NULL
19087 };
19088
19089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
19090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19091 if (SWIG_arg_fail(1)) SWIG_fail;
19092 {
19093 arg2 = wxString_in_helper(obj1);
19094 if (arg2 == NULL) SWIG_fail;
19095 temp2 = true;
19096 }
19097 {
19098 PyThreadState* __tstate = wxPyBeginAllowThreads();
19099 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
19100
19101 wxPyEndAllowThreads(__tstate);
19102 if (PyErr_Occurred()) SWIG_fail;
19103 }
19104 {
19105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19106 }
19107 {
19108 if (temp2)
19109 delete arg2;
19110 }
19111 return resultobj;
19112 fail:
19113 {
19114 if (temp2)
19115 delete arg2;
19116 }
19117 return NULL;
19118 }
19119
19120
19121 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
19122 PyObject *resultobj = NULL;
19123 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19124 bool result;
19125 PyObject * obj0 = 0 ;
19126 char *kwnames[] = {
19127 (char *) "self", NULL
19128 };
19129
19130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
19131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19132 if (SWIG_arg_fail(1)) SWIG_fail;
19133 {
19134 PyThreadState* __tstate = wxPyBeginAllowThreads();
19135 result = (bool)(arg1)->DeleteAll();
19136
19137 wxPyEndAllowThreads(__tstate);
19138 if (PyErr_Occurred()) SWIG_fail;
19139 }
19140 {
19141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19142 }
19143 return resultobj;
19144 fail:
19145 return NULL;
19146 }
19147
19148
19149 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19150 PyObject *resultobj = NULL;
19151 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19152 bool arg2 = (bool) true ;
19153 PyObject * obj0 = 0 ;
19154 PyObject * obj1 = 0 ;
19155 char *kwnames[] = {
19156 (char *) "self",(char *) "doIt", NULL
19157 };
19158
19159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
19160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19161 if (SWIG_arg_fail(1)) SWIG_fail;
19162 if (obj1) {
19163 {
19164 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19165 if (SWIG_arg_fail(2)) SWIG_fail;
19166 }
19167 }
19168 {
19169 PyThreadState* __tstate = wxPyBeginAllowThreads();
19170 (arg1)->SetExpandEnvVars(arg2);
19171
19172 wxPyEndAllowThreads(__tstate);
19173 if (PyErr_Occurred()) SWIG_fail;
19174 }
19175 Py_INCREF(Py_None); resultobj = Py_None;
19176 return resultobj;
19177 fail:
19178 return NULL;
19179 }
19180
19181
19182 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19183 PyObject *resultobj = NULL;
19184 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19185 bool result;
19186 PyObject * obj0 = 0 ;
19187 char *kwnames[] = {
19188 (char *) "self", NULL
19189 };
19190
19191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
19192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19193 if (SWIG_arg_fail(1)) SWIG_fail;
19194 {
19195 PyThreadState* __tstate = wxPyBeginAllowThreads();
19196 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
19197
19198 wxPyEndAllowThreads(__tstate);
19199 if (PyErr_Occurred()) SWIG_fail;
19200 }
19201 {
19202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19203 }
19204 return resultobj;
19205 fail:
19206 return NULL;
19207 }
19208
19209
19210 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
19211 PyObject *resultobj = NULL;
19212 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19213 bool arg2 = (bool) true ;
19214 PyObject * obj0 = 0 ;
19215 PyObject * obj1 = 0 ;
19216 char *kwnames[] = {
19217 (char *) "self",(char *) "doIt", NULL
19218 };
19219
19220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
19221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19222 if (SWIG_arg_fail(1)) SWIG_fail;
19223 if (obj1) {
19224 {
19225 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19226 if (SWIG_arg_fail(2)) SWIG_fail;
19227 }
19228 }
19229 {
19230 PyThreadState* __tstate = wxPyBeginAllowThreads();
19231 (arg1)->SetRecordDefaults(arg2);
19232
19233 wxPyEndAllowThreads(__tstate);
19234 if (PyErr_Occurred()) SWIG_fail;
19235 }
19236 Py_INCREF(Py_None); resultobj = Py_None;
19237 return resultobj;
19238 fail:
19239 return NULL;
19240 }
19241
19242
19243 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
19244 PyObject *resultobj = NULL;
19245 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19246 bool result;
19247 PyObject * obj0 = 0 ;
19248 char *kwnames[] = {
19249 (char *) "self", NULL
19250 };
19251
19252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
19253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19254 if (SWIG_arg_fail(1)) SWIG_fail;
19255 {
19256 PyThreadState* __tstate = wxPyBeginAllowThreads();
19257 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
19258
19259 wxPyEndAllowThreads(__tstate);
19260 if (PyErr_Occurred()) SWIG_fail;
19261 }
19262 {
19263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19264 }
19265 return resultobj;
19266 fail:
19267 return NULL;
19268 }
19269
19270
19271 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19272 PyObject *resultobj = NULL;
19273 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19274 wxString *arg2 = 0 ;
19275 wxString result;
19276 bool temp2 = false ;
19277 PyObject * obj0 = 0 ;
19278 PyObject * obj1 = 0 ;
19279 char *kwnames[] = {
19280 (char *) "self",(char *) "str", NULL
19281 };
19282
19283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
19284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19285 if (SWIG_arg_fail(1)) SWIG_fail;
19286 {
19287 arg2 = wxString_in_helper(obj1);
19288 if (arg2 == NULL) SWIG_fail;
19289 temp2 = true;
19290 }
19291 {
19292 PyThreadState* __tstate = wxPyBeginAllowThreads();
19293 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
19294
19295 wxPyEndAllowThreads(__tstate);
19296 if (PyErr_Occurred()) SWIG_fail;
19297 }
19298 {
19299 #if wxUSE_UNICODE
19300 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19301 #else
19302 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19303 #endif
19304 }
19305 {
19306 if (temp2)
19307 delete arg2;
19308 }
19309 return resultobj;
19310 fail:
19311 {
19312 if (temp2)
19313 delete arg2;
19314 }
19315 return NULL;
19316 }
19317
19318
19319 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
19320 PyObject *resultobj = NULL;
19321 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19322 wxString result;
19323 PyObject * obj0 = 0 ;
19324 char *kwnames[] = {
19325 (char *) "self", NULL
19326 };
19327
19328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
19329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19330 if (SWIG_arg_fail(1)) SWIG_fail;
19331 {
19332 PyThreadState* __tstate = wxPyBeginAllowThreads();
19333 result = ((wxConfigBase const *)arg1)->GetAppName();
19334
19335 wxPyEndAllowThreads(__tstate);
19336 if (PyErr_Occurred()) SWIG_fail;
19337 }
19338 {
19339 #if wxUSE_UNICODE
19340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19341 #else
19342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19343 #endif
19344 }
19345 return resultobj;
19346 fail:
19347 return NULL;
19348 }
19349
19350
19351 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
19352 PyObject *resultobj = NULL;
19353 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19354 wxString result;
19355 PyObject * obj0 = 0 ;
19356 char *kwnames[] = {
19357 (char *) "self", NULL
19358 };
19359
19360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
19361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19362 if (SWIG_arg_fail(1)) SWIG_fail;
19363 {
19364 PyThreadState* __tstate = wxPyBeginAllowThreads();
19365 result = ((wxConfigBase const *)arg1)->GetVendorName();
19366
19367 wxPyEndAllowThreads(__tstate);
19368 if (PyErr_Occurred()) SWIG_fail;
19369 }
19370 {
19371 #if wxUSE_UNICODE
19372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19373 #else
19374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19375 #endif
19376 }
19377 return resultobj;
19378 fail:
19379 return NULL;
19380 }
19381
19382
19383 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
19384 PyObject *resultobj = NULL;
19385 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19386 wxString *arg2 = 0 ;
19387 bool temp2 = false ;
19388 PyObject * obj0 = 0 ;
19389 PyObject * obj1 = 0 ;
19390 char *kwnames[] = {
19391 (char *) "self",(char *) "appName", NULL
19392 };
19393
19394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
19395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19396 if (SWIG_arg_fail(1)) SWIG_fail;
19397 {
19398 arg2 = wxString_in_helper(obj1);
19399 if (arg2 == NULL) SWIG_fail;
19400 temp2 = true;
19401 }
19402 {
19403 PyThreadState* __tstate = wxPyBeginAllowThreads();
19404 (arg1)->SetAppName((wxString const &)*arg2);
19405
19406 wxPyEndAllowThreads(__tstate);
19407 if (PyErr_Occurred()) SWIG_fail;
19408 }
19409 Py_INCREF(Py_None); resultobj = Py_None;
19410 {
19411 if (temp2)
19412 delete arg2;
19413 }
19414 return resultobj;
19415 fail:
19416 {
19417 if (temp2)
19418 delete arg2;
19419 }
19420 return NULL;
19421 }
19422
19423
19424 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
19425 PyObject *resultobj = NULL;
19426 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19427 wxString *arg2 = 0 ;
19428 bool temp2 = false ;
19429 PyObject * obj0 = 0 ;
19430 PyObject * obj1 = 0 ;
19431 char *kwnames[] = {
19432 (char *) "self",(char *) "vendorName", NULL
19433 };
19434
19435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
19436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19437 if (SWIG_arg_fail(1)) SWIG_fail;
19438 {
19439 arg2 = wxString_in_helper(obj1);
19440 if (arg2 == NULL) SWIG_fail;
19441 temp2 = true;
19442 }
19443 {
19444 PyThreadState* __tstate = wxPyBeginAllowThreads();
19445 (arg1)->SetVendorName((wxString const &)*arg2);
19446
19447 wxPyEndAllowThreads(__tstate);
19448 if (PyErr_Occurred()) SWIG_fail;
19449 }
19450 Py_INCREF(Py_None); resultobj = Py_None;
19451 {
19452 if (temp2)
19453 delete arg2;
19454 }
19455 return resultobj;
19456 fail:
19457 {
19458 if (temp2)
19459 delete arg2;
19460 }
19461 return NULL;
19462 }
19463
19464
19465 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
19466 PyObject *resultobj = NULL;
19467 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19468 long arg2 ;
19469 PyObject * obj0 = 0 ;
19470 PyObject * obj1 = 0 ;
19471 char *kwnames[] = {
19472 (char *) "self",(char *) "style", NULL
19473 };
19474
19475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
19476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19477 if (SWIG_arg_fail(1)) SWIG_fail;
19478 {
19479 arg2 = static_cast<long >(SWIG_As_long(obj1));
19480 if (SWIG_arg_fail(2)) SWIG_fail;
19481 }
19482 {
19483 PyThreadState* __tstate = wxPyBeginAllowThreads();
19484 (arg1)->SetStyle(arg2);
19485
19486 wxPyEndAllowThreads(__tstate);
19487 if (PyErr_Occurred()) SWIG_fail;
19488 }
19489 Py_INCREF(Py_None); resultobj = Py_None;
19490 return resultobj;
19491 fail:
19492 return NULL;
19493 }
19494
19495
19496 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
19497 PyObject *resultobj = NULL;
19498 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19499 long result;
19500 PyObject * obj0 = 0 ;
19501 char *kwnames[] = {
19502 (char *) "self", NULL
19503 };
19504
19505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
19506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19507 if (SWIG_arg_fail(1)) SWIG_fail;
19508 {
19509 PyThreadState* __tstate = wxPyBeginAllowThreads();
19510 result = (long)((wxConfigBase const *)arg1)->GetStyle();
19511
19512 wxPyEndAllowThreads(__tstate);
19513 if (PyErr_Occurred()) SWIG_fail;
19514 }
19515 {
19516 resultobj = SWIG_From_long(static_cast<long >(result));
19517 }
19518 return resultobj;
19519 fail:
19520 return NULL;
19521 }
19522
19523
19524 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
19525 PyObject *obj;
19526 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19527 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
19528 Py_INCREF(obj);
19529 return Py_BuildValue((char *)"");
19530 }
19531 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
19532 PyObject *resultobj = NULL;
19533 wxString const &arg1_defvalue = wxPyEmptyString ;
19534 wxString *arg1 = (wxString *) &arg1_defvalue ;
19535 wxString const &arg2_defvalue = wxPyEmptyString ;
19536 wxString *arg2 = (wxString *) &arg2_defvalue ;
19537 wxString const &arg3_defvalue = wxPyEmptyString ;
19538 wxString *arg3 = (wxString *) &arg3_defvalue ;
19539 wxString const &arg4_defvalue = wxPyEmptyString ;
19540 wxString *arg4 = (wxString *) &arg4_defvalue ;
19541 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
19542 wxConfig *result;
19543 bool temp1 = false ;
19544 bool temp2 = false ;
19545 bool temp3 = false ;
19546 bool temp4 = false ;
19547 PyObject * obj0 = 0 ;
19548 PyObject * obj1 = 0 ;
19549 PyObject * obj2 = 0 ;
19550 PyObject * obj3 = 0 ;
19551 PyObject * obj4 = 0 ;
19552 char *kwnames[] = {
19553 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
19554 };
19555
19556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19557 if (obj0) {
19558 {
19559 arg1 = wxString_in_helper(obj0);
19560 if (arg1 == NULL) SWIG_fail;
19561 temp1 = true;
19562 }
19563 }
19564 if (obj1) {
19565 {
19566 arg2 = wxString_in_helper(obj1);
19567 if (arg2 == NULL) SWIG_fail;
19568 temp2 = true;
19569 }
19570 }
19571 if (obj2) {
19572 {
19573 arg3 = wxString_in_helper(obj2);
19574 if (arg3 == NULL) SWIG_fail;
19575 temp3 = true;
19576 }
19577 }
19578 if (obj3) {
19579 {
19580 arg4 = wxString_in_helper(obj3);
19581 if (arg4 == NULL) SWIG_fail;
19582 temp4 = true;
19583 }
19584 }
19585 if (obj4) {
19586 {
19587 arg5 = static_cast<long >(SWIG_As_long(obj4));
19588 if (SWIG_arg_fail(5)) SWIG_fail;
19589 }
19590 }
19591 {
19592 PyThreadState* __tstate = wxPyBeginAllowThreads();
19593 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
19594
19595 wxPyEndAllowThreads(__tstate);
19596 if (PyErr_Occurred()) SWIG_fail;
19597 }
19598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
19599 {
19600 if (temp1)
19601 delete arg1;
19602 }
19603 {
19604 if (temp2)
19605 delete arg2;
19606 }
19607 {
19608 if (temp3)
19609 delete arg3;
19610 }
19611 {
19612 if (temp4)
19613 delete arg4;
19614 }
19615 return resultobj;
19616 fail:
19617 {
19618 if (temp1)
19619 delete arg1;
19620 }
19621 {
19622 if (temp2)
19623 delete arg2;
19624 }
19625 {
19626 if (temp3)
19627 delete arg3;
19628 }
19629 {
19630 if (temp4)
19631 delete arg4;
19632 }
19633 return NULL;
19634 }
19635
19636
19637 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
19638 PyObject *resultobj = NULL;
19639 wxConfig *arg1 = (wxConfig *) 0 ;
19640 PyObject * obj0 = 0 ;
19641 char *kwnames[] = {
19642 (char *) "self", NULL
19643 };
19644
19645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
19646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
19647 if (SWIG_arg_fail(1)) SWIG_fail;
19648 {
19649 PyThreadState* __tstate = wxPyBeginAllowThreads();
19650 delete arg1;
19651
19652 wxPyEndAllowThreads(__tstate);
19653 if (PyErr_Occurred()) SWIG_fail;
19654 }
19655 Py_INCREF(Py_None); resultobj = Py_None;
19656 return resultobj;
19657 fail:
19658 return NULL;
19659 }
19660
19661
19662 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
19663 PyObject *obj;
19664 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19665 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
19666 Py_INCREF(obj);
19667 return Py_BuildValue((char *)"");
19668 }
19669 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
19670 PyObject *resultobj = NULL;
19671 wxString const &arg1_defvalue = wxPyEmptyString ;
19672 wxString *arg1 = (wxString *) &arg1_defvalue ;
19673 wxString const &arg2_defvalue = wxPyEmptyString ;
19674 wxString *arg2 = (wxString *) &arg2_defvalue ;
19675 wxString const &arg3_defvalue = wxPyEmptyString ;
19676 wxString *arg3 = (wxString *) &arg3_defvalue ;
19677 wxString const &arg4_defvalue = wxPyEmptyString ;
19678 wxString *arg4 = (wxString *) &arg4_defvalue ;
19679 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
19680 wxFileConfig *result;
19681 bool temp1 = false ;
19682 bool temp2 = false ;
19683 bool temp3 = false ;
19684 bool temp4 = false ;
19685 PyObject * obj0 = 0 ;
19686 PyObject * obj1 = 0 ;
19687 PyObject * obj2 = 0 ;
19688 PyObject * obj3 = 0 ;
19689 PyObject * obj4 = 0 ;
19690 char *kwnames[] = {
19691 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
19692 };
19693
19694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19695 if (obj0) {
19696 {
19697 arg1 = wxString_in_helper(obj0);
19698 if (arg1 == NULL) SWIG_fail;
19699 temp1 = true;
19700 }
19701 }
19702 if (obj1) {
19703 {
19704 arg2 = wxString_in_helper(obj1);
19705 if (arg2 == NULL) SWIG_fail;
19706 temp2 = true;
19707 }
19708 }
19709 if (obj2) {
19710 {
19711 arg3 = wxString_in_helper(obj2);
19712 if (arg3 == NULL) SWIG_fail;
19713 temp3 = true;
19714 }
19715 }
19716 if (obj3) {
19717 {
19718 arg4 = wxString_in_helper(obj3);
19719 if (arg4 == NULL) SWIG_fail;
19720 temp4 = true;
19721 }
19722 }
19723 if (obj4) {
19724 {
19725 arg5 = static_cast<long >(SWIG_As_long(obj4));
19726 if (SWIG_arg_fail(5)) SWIG_fail;
19727 }
19728 }
19729 {
19730 PyThreadState* __tstate = wxPyBeginAllowThreads();
19731 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
19732
19733 wxPyEndAllowThreads(__tstate);
19734 if (PyErr_Occurred()) SWIG_fail;
19735 }
19736 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
19737 {
19738 if (temp1)
19739 delete arg1;
19740 }
19741 {
19742 if (temp2)
19743 delete arg2;
19744 }
19745 {
19746 if (temp3)
19747 delete arg3;
19748 }
19749 {
19750 if (temp4)
19751 delete arg4;
19752 }
19753 return resultobj;
19754 fail:
19755 {
19756 if (temp1)
19757 delete arg1;
19758 }
19759 {
19760 if (temp2)
19761 delete arg2;
19762 }
19763 {
19764 if (temp3)
19765 delete arg3;
19766 }
19767 {
19768 if (temp4)
19769 delete arg4;
19770 }
19771 return NULL;
19772 }
19773
19774
19775 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
19776 PyObject *resultobj = NULL;
19777 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
19778 PyObject * obj0 = 0 ;
19779 char *kwnames[] = {
19780 (char *) "self", NULL
19781 };
19782
19783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
19784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
19785 if (SWIG_arg_fail(1)) SWIG_fail;
19786 {
19787 PyThreadState* __tstate = wxPyBeginAllowThreads();
19788 delete arg1;
19789
19790 wxPyEndAllowThreads(__tstate);
19791 if (PyErr_Occurred()) SWIG_fail;
19792 }
19793 Py_INCREF(Py_None); resultobj = Py_None;
19794 return resultobj;
19795 fail:
19796 return NULL;
19797 }
19798
19799
19800 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
19801 PyObject *obj;
19802 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19803 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
19804 Py_INCREF(obj);
19805 return Py_BuildValue((char *)"");
19806 }
19807 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
19808 PyObject *resultobj = NULL;
19809 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19810 wxString *arg2 = 0 ;
19811 wxConfigPathChanger *result;
19812 bool temp2 = false ;
19813 PyObject * obj0 = 0 ;
19814 PyObject * obj1 = 0 ;
19815 char *kwnames[] = {
19816 (char *) "config",(char *) "entry", NULL
19817 };
19818
19819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
19820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19821 if (SWIG_arg_fail(1)) SWIG_fail;
19822 {
19823 arg2 = wxString_in_helper(obj1);
19824 if (arg2 == NULL) SWIG_fail;
19825 temp2 = true;
19826 }
19827 {
19828 PyThreadState* __tstate = wxPyBeginAllowThreads();
19829 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
19830
19831 wxPyEndAllowThreads(__tstate);
19832 if (PyErr_Occurred()) SWIG_fail;
19833 }
19834 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
19835 {
19836 if (temp2)
19837 delete arg2;
19838 }
19839 return resultobj;
19840 fail:
19841 {
19842 if (temp2)
19843 delete arg2;
19844 }
19845 return NULL;
19846 }
19847
19848
19849 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
19850 PyObject *resultobj = NULL;
19851 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
19852 PyObject * obj0 = 0 ;
19853 char *kwnames[] = {
19854 (char *) "self", NULL
19855 };
19856
19857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
19858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
19859 if (SWIG_arg_fail(1)) SWIG_fail;
19860 {
19861 PyThreadState* __tstate = wxPyBeginAllowThreads();
19862 delete arg1;
19863
19864 wxPyEndAllowThreads(__tstate);
19865 if (PyErr_Occurred()) SWIG_fail;
19866 }
19867 Py_INCREF(Py_None); resultobj = Py_None;
19868 return resultobj;
19869 fail:
19870 return NULL;
19871 }
19872
19873
19874 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
19875 PyObject *resultobj = NULL;
19876 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
19877 wxString *result;
19878 PyObject * obj0 = 0 ;
19879 char *kwnames[] = {
19880 (char *) "self", NULL
19881 };
19882
19883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
19884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
19885 if (SWIG_arg_fail(1)) SWIG_fail;
19886 {
19887 PyThreadState* __tstate = wxPyBeginAllowThreads();
19888 {
19889 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
19890 result = (wxString *) &_result_ref;
19891 }
19892
19893 wxPyEndAllowThreads(__tstate);
19894 if (PyErr_Occurred()) SWIG_fail;
19895 }
19896 {
19897 #if wxUSE_UNICODE
19898 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19899 #else
19900 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19901 #endif
19902 }
19903 return resultobj;
19904 fail:
19905 return NULL;
19906 }
19907
19908
19909 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
19910 PyObject *obj;
19911 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19912 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
19913 Py_INCREF(obj);
19914 return Py_BuildValue((char *)"");
19915 }
19916 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19917 PyObject *resultobj = NULL;
19918 wxString *arg1 = 0 ;
19919 wxString result;
19920 bool temp1 = false ;
19921 PyObject * obj0 = 0 ;
19922 char *kwnames[] = {
19923 (char *) "sz", NULL
19924 };
19925
19926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
19927 {
19928 arg1 = wxString_in_helper(obj0);
19929 if (arg1 == NULL) SWIG_fail;
19930 temp1 = true;
19931 }
19932 {
19933 PyThreadState* __tstate = wxPyBeginAllowThreads();
19934 result = wxExpandEnvVars((wxString const &)*arg1);
19935
19936 wxPyEndAllowThreads(__tstate);
19937 if (PyErr_Occurred()) SWIG_fail;
19938 }
19939 {
19940 #if wxUSE_UNICODE
19941 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19942 #else
19943 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19944 #endif
19945 }
19946 {
19947 if (temp1)
19948 delete arg1;
19949 }
19950 return resultobj;
19951 fail:
19952 {
19953 if (temp1)
19954 delete arg1;
19955 }
19956 return NULL;
19957 }
19958
19959
19960 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
19961 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
19962 return 1;
19963 }
19964
19965
19966 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19967 PyObject *pyobj = NULL;
19968
19969 {
19970 #if wxUSE_UNICODE
19971 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19972 #else
19973 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19974 #endif
19975 }
19976 return pyobj;
19977 }
19978
19979
19980 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19981 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19982 return 1;
19983 }
19984
19985
19986 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19987 PyObject *pyobj = NULL;
19988
19989 {
19990 #if wxUSE_UNICODE
19991 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19992 #else
19993 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19994 #endif
19995 }
19996 return pyobj;
19997 }
19998
19999
20000 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
20001 PyObject *resultobj = NULL;
20002 wxDateTime::Country arg1 ;
20003 PyObject * obj0 = 0 ;
20004 char *kwnames[] = {
20005 (char *) "country", NULL
20006 };
20007
20008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
20009 {
20010 arg1 = static_cast<wxDateTime::Country >(SWIG_As_int(obj0));
20011 if (SWIG_arg_fail(1)) SWIG_fail;
20012 }
20013 {
20014 PyThreadState* __tstate = wxPyBeginAllowThreads();
20015 wxDateTime::SetCountry(arg1);
20016
20017 wxPyEndAllowThreads(__tstate);
20018 if (PyErr_Occurred()) SWIG_fail;
20019 }
20020 Py_INCREF(Py_None); resultobj = Py_None;
20021 return resultobj;
20022 fail:
20023 return NULL;
20024 }
20025
20026
20027 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
20028 PyObject *resultobj = NULL;
20029 wxDateTime::Country result;
20030 char *kwnames[] = {
20031 NULL
20032 };
20033
20034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
20035 {
20036 PyThreadState* __tstate = wxPyBeginAllowThreads();
20037 result = (wxDateTime::Country)wxDateTime::GetCountry();
20038
20039 wxPyEndAllowThreads(__tstate);
20040 if (PyErr_Occurred()) SWIG_fail;
20041 }
20042 resultobj = SWIG_From_int((result));
20043 return resultobj;
20044 fail:
20045 return NULL;
20046 }
20047
20048
20049 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
20050 PyObject *resultobj = NULL;
20051 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
20052 bool result;
20053 PyObject * obj0 = 0 ;
20054 char *kwnames[] = {
20055 (char *) "country", NULL
20056 };
20057
20058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
20059 if (obj0) {
20060 {
20061 arg1 = static_cast<wxDateTime::Country >(SWIG_As_int(obj0));
20062 if (SWIG_arg_fail(1)) SWIG_fail;
20063 }
20064 }
20065 {
20066 PyThreadState* __tstate = wxPyBeginAllowThreads();
20067 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
20068
20069 wxPyEndAllowThreads(__tstate);
20070 if (PyErr_Occurred()) SWIG_fail;
20071 }
20072 {
20073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20074 }
20075 return resultobj;
20076 fail:
20077 return NULL;
20078 }
20079
20080
20081 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
20082 PyObject *resultobj = NULL;
20083 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20084 int result;
20085 PyObject * obj0 = 0 ;
20086 char *kwnames[] = {
20087 (char *) "cal", NULL
20088 };
20089
20090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
20091 if (obj0) {
20092 {
20093 arg1 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj0));
20094 if (SWIG_arg_fail(1)) SWIG_fail;
20095 }
20096 }
20097 {
20098 PyThreadState* __tstate = wxPyBeginAllowThreads();
20099 result = (int)wxDateTime::GetCurrentYear(arg1);
20100
20101 wxPyEndAllowThreads(__tstate);
20102 if (PyErr_Occurred()) SWIG_fail;
20103 }
20104 {
20105 resultobj = SWIG_From_int(static_cast<int >(result));
20106 }
20107 return resultobj;
20108 fail:
20109 return NULL;
20110 }
20111
20112
20113 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
20114 PyObject *resultobj = NULL;
20115 int arg1 ;
20116 int result;
20117 PyObject * obj0 = 0 ;
20118 char *kwnames[] = {
20119 (char *) "year", NULL
20120 };
20121
20122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
20123 {
20124 arg1 = static_cast<int >(SWIG_As_int(obj0));
20125 if (SWIG_arg_fail(1)) SWIG_fail;
20126 }
20127 {
20128 PyThreadState* __tstate = wxPyBeginAllowThreads();
20129 result = (int)wxDateTime::ConvertYearToBC(arg1);
20130
20131 wxPyEndAllowThreads(__tstate);
20132 if (PyErr_Occurred()) SWIG_fail;
20133 }
20134 {
20135 resultobj = SWIG_From_int(static_cast<int >(result));
20136 }
20137 return resultobj;
20138 fail:
20139 return NULL;
20140 }
20141
20142
20143 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20144 PyObject *resultobj = NULL;
20145 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20146 wxDateTime::Month result;
20147 PyObject * obj0 = 0 ;
20148 char *kwnames[] = {
20149 (char *) "cal", NULL
20150 };
20151
20152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
20153 if (obj0) {
20154 {
20155 arg1 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj0));
20156 if (SWIG_arg_fail(1)) SWIG_fail;
20157 }
20158 }
20159 {
20160 PyThreadState* __tstate = wxPyBeginAllowThreads();
20161 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
20162
20163 wxPyEndAllowThreads(__tstate);
20164 if (PyErr_Occurred()) SWIG_fail;
20165 }
20166 resultobj = SWIG_From_int((result));
20167 return resultobj;
20168 fail:
20169 return NULL;
20170 }
20171
20172
20173 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
20174 PyObject *resultobj = NULL;
20175 int arg1 = (int) wxDateTime::Inv_Year ;
20176 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20177 bool result;
20178 PyObject * obj0 = 0 ;
20179 PyObject * obj1 = 0 ;
20180 char *kwnames[] = {
20181 (char *) "year",(char *) "cal", NULL
20182 };
20183
20184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
20185 if (obj0) {
20186 {
20187 arg1 = static_cast<int >(SWIG_As_int(obj0));
20188 if (SWIG_arg_fail(1)) SWIG_fail;
20189 }
20190 }
20191 if (obj1) {
20192 {
20193 arg2 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj1));
20194 if (SWIG_arg_fail(2)) SWIG_fail;
20195 }
20196 }
20197 {
20198 PyThreadState* __tstate = wxPyBeginAllowThreads();
20199 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
20200
20201 wxPyEndAllowThreads(__tstate);
20202 if (PyErr_Occurred()) SWIG_fail;
20203 }
20204 {
20205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20206 }
20207 return resultobj;
20208 fail:
20209 return NULL;
20210 }
20211
20212
20213 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
20214 PyObject *resultobj = NULL;
20215 int arg1 = (int) wxDateTime::Inv_Year ;
20216 int result;
20217 PyObject * obj0 = 0 ;
20218 char *kwnames[] = {
20219 (char *) "year", NULL
20220 };
20221
20222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
20223 if (obj0) {
20224 {
20225 arg1 = static_cast<int >(SWIG_As_int(obj0));
20226 if (SWIG_arg_fail(1)) SWIG_fail;
20227 }
20228 }
20229 {
20230 PyThreadState* __tstate = wxPyBeginAllowThreads();
20231 result = (int)wxDateTime::GetCentury(arg1);
20232
20233 wxPyEndAllowThreads(__tstate);
20234 if (PyErr_Occurred()) SWIG_fail;
20235 }
20236 {
20237 resultobj = SWIG_From_int(static_cast<int >(result));
20238 }
20239 return resultobj;
20240 fail:
20241 return NULL;
20242 }
20243
20244
20245 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
20246 PyObject *resultobj = NULL;
20247 int arg1 ;
20248 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20249 int result;
20250 PyObject * obj0 = 0 ;
20251 PyObject * obj1 = 0 ;
20252 char *kwnames[] = {
20253 (char *) "year",(char *) "cal", NULL
20254 };
20255
20256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
20257 {
20258 arg1 = static_cast<int >(SWIG_As_int(obj0));
20259 if (SWIG_arg_fail(1)) SWIG_fail;
20260 }
20261 if (obj1) {
20262 {
20263 arg2 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj1));
20264 if (SWIG_arg_fail(2)) SWIG_fail;
20265 }
20266 }
20267 {
20268 PyThreadState* __tstate = wxPyBeginAllowThreads();
20269 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
20270
20271 wxPyEndAllowThreads(__tstate);
20272 if (PyErr_Occurred()) SWIG_fail;
20273 }
20274 {
20275 resultobj = SWIG_From_int(static_cast<int >(result));
20276 }
20277 return resultobj;
20278 fail:
20279 return NULL;
20280 }
20281
20282
20283 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20284 PyObject *resultobj = NULL;
20285 wxDateTime::Month arg1 ;
20286 int arg2 = (int) wxDateTime::Inv_Year ;
20287 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20288 int result;
20289 PyObject * obj0 = 0 ;
20290 PyObject * obj1 = 0 ;
20291 PyObject * obj2 = 0 ;
20292 char *kwnames[] = {
20293 (char *) "month",(char *) "year",(char *) "cal", NULL
20294 };
20295
20296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
20297 {
20298 arg1 = static_cast<wxDateTime::Month >(SWIG_As_int(obj0));
20299 if (SWIG_arg_fail(1)) SWIG_fail;
20300 }
20301 if (obj1) {
20302 {
20303 arg2 = static_cast<int >(SWIG_As_int(obj1));
20304 if (SWIG_arg_fail(2)) SWIG_fail;
20305 }
20306 }
20307 if (obj2) {
20308 {
20309 arg3 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj2));
20310 if (SWIG_arg_fail(3)) SWIG_fail;
20311 }
20312 }
20313 {
20314 PyThreadState* __tstate = wxPyBeginAllowThreads();
20315 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
20316
20317 wxPyEndAllowThreads(__tstate);
20318 if (PyErr_Occurred()) SWIG_fail;
20319 }
20320 {
20321 resultobj = SWIG_From_int(static_cast<int >(result));
20322 }
20323 return resultobj;
20324 fail:
20325 return NULL;
20326 }
20327
20328
20329 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
20330 PyObject *resultobj = NULL;
20331 wxDateTime::Month arg1 ;
20332 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
20333 wxString result;
20334 PyObject * obj0 = 0 ;
20335 PyObject * obj1 = 0 ;
20336 char *kwnames[] = {
20337 (char *) "month",(char *) "flags", NULL
20338 };
20339
20340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
20341 {
20342 arg1 = static_cast<wxDateTime::Month >(SWIG_As_int(obj0));
20343 if (SWIG_arg_fail(1)) SWIG_fail;
20344 }
20345 if (obj1) {
20346 {
20347 arg2 = static_cast<wxDateTime::NameFlags >(SWIG_As_int(obj1));
20348 if (SWIG_arg_fail(2)) SWIG_fail;
20349 }
20350 }
20351 {
20352 PyThreadState* __tstate = wxPyBeginAllowThreads();
20353 result = wxDateTime::GetMonthName(arg1,arg2);
20354
20355 wxPyEndAllowThreads(__tstate);
20356 if (PyErr_Occurred()) SWIG_fail;
20357 }
20358 {
20359 #if wxUSE_UNICODE
20360 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20361 #else
20362 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20363 #endif
20364 }
20365 return resultobj;
20366 fail:
20367 return NULL;
20368 }
20369
20370
20371 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
20372 PyObject *resultobj = NULL;
20373 wxDateTime::WeekDay arg1 ;
20374 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
20375 wxString result;
20376 PyObject * obj0 = 0 ;
20377 PyObject * obj1 = 0 ;
20378 char *kwnames[] = {
20379 (char *) "weekday",(char *) "flags", NULL
20380 };
20381
20382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
20383 {
20384 arg1 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj0));
20385 if (SWIG_arg_fail(1)) SWIG_fail;
20386 }
20387 if (obj1) {
20388 {
20389 arg2 = static_cast<wxDateTime::NameFlags >(SWIG_As_int(obj1));
20390 if (SWIG_arg_fail(2)) SWIG_fail;
20391 }
20392 }
20393 {
20394 PyThreadState* __tstate = wxPyBeginAllowThreads();
20395 result = wxDateTime::GetWeekDayName(arg1,arg2);
20396
20397 wxPyEndAllowThreads(__tstate);
20398 if (PyErr_Occurred()) SWIG_fail;
20399 }
20400 {
20401 #if wxUSE_UNICODE
20402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20403 #else
20404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20405 #endif
20406 }
20407 return resultobj;
20408 fail:
20409 return NULL;
20410 }
20411
20412
20413 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
20414 PyObject *resultobj = NULL;
20415 PyObject *result;
20416 char *kwnames[] = {
20417 NULL
20418 };
20419
20420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
20421 {
20422 PyThreadState* __tstate = wxPyBeginAllowThreads();
20423 result = (PyObject *)wxDateTime_GetAmPmStrings();
20424
20425 wxPyEndAllowThreads(__tstate);
20426 if (PyErr_Occurred()) SWIG_fail;
20427 }
20428 resultobj = result;
20429 return resultobj;
20430 fail:
20431 return NULL;
20432 }
20433
20434
20435 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
20436 PyObject *resultobj = NULL;
20437 int arg1 = (int) wxDateTime::Inv_Year ;
20438 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20439 bool result;
20440 PyObject * obj0 = 0 ;
20441 PyObject * obj1 = 0 ;
20442 char *kwnames[] = {
20443 (char *) "year",(char *) "country", NULL
20444 };
20445
20446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
20447 if (obj0) {
20448 {
20449 arg1 = static_cast<int >(SWIG_As_int(obj0));
20450 if (SWIG_arg_fail(1)) SWIG_fail;
20451 }
20452 }
20453 if (obj1) {
20454 {
20455 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
20456 if (SWIG_arg_fail(2)) SWIG_fail;
20457 }
20458 }
20459 {
20460 PyThreadState* __tstate = wxPyBeginAllowThreads();
20461 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
20462
20463 wxPyEndAllowThreads(__tstate);
20464 if (PyErr_Occurred()) SWIG_fail;
20465 }
20466 {
20467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20468 }
20469 return resultobj;
20470 fail:
20471 return NULL;
20472 }
20473
20474
20475 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
20476 PyObject *resultobj = NULL;
20477 int arg1 = (int) wxDateTime::Inv_Year ;
20478 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20479 wxDateTime result;
20480 PyObject * obj0 = 0 ;
20481 PyObject * obj1 = 0 ;
20482 char *kwnames[] = {
20483 (char *) "year",(char *) "country", NULL
20484 };
20485
20486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
20487 if (obj0) {
20488 {
20489 arg1 = static_cast<int >(SWIG_As_int(obj0));
20490 if (SWIG_arg_fail(1)) SWIG_fail;
20491 }
20492 }
20493 if (obj1) {
20494 {
20495 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
20496 if (SWIG_arg_fail(2)) SWIG_fail;
20497 }
20498 }
20499 {
20500 PyThreadState* __tstate = wxPyBeginAllowThreads();
20501 result = wxDateTime::GetBeginDST(arg1,arg2);
20502
20503 wxPyEndAllowThreads(__tstate);
20504 if (PyErr_Occurred()) SWIG_fail;
20505 }
20506 {
20507 wxDateTime * resultptr;
20508 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20509 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20510 }
20511 return resultobj;
20512 fail:
20513 return NULL;
20514 }
20515
20516
20517 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
20518 PyObject *resultobj = NULL;
20519 int arg1 = (int) wxDateTime::Inv_Year ;
20520 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20521 wxDateTime result;
20522 PyObject * obj0 = 0 ;
20523 PyObject * obj1 = 0 ;
20524 char *kwnames[] = {
20525 (char *) "year",(char *) "country", NULL
20526 };
20527
20528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
20529 if (obj0) {
20530 {
20531 arg1 = static_cast<int >(SWIG_As_int(obj0));
20532 if (SWIG_arg_fail(1)) SWIG_fail;
20533 }
20534 }
20535 if (obj1) {
20536 {
20537 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
20538 if (SWIG_arg_fail(2)) SWIG_fail;
20539 }
20540 }
20541 {
20542 PyThreadState* __tstate = wxPyBeginAllowThreads();
20543 result = wxDateTime::GetEndDST(arg1,arg2);
20544
20545 wxPyEndAllowThreads(__tstate);
20546 if (PyErr_Occurred()) SWIG_fail;
20547 }
20548 {
20549 wxDateTime * resultptr;
20550 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20551 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20552 }
20553 return resultobj;
20554 fail:
20555 return NULL;
20556 }
20557
20558
20559 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
20560 PyObject *resultobj = NULL;
20561 wxDateTime result;
20562 char *kwnames[] = {
20563 NULL
20564 };
20565
20566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
20567 {
20568 PyThreadState* __tstate = wxPyBeginAllowThreads();
20569 result = wxDateTime::Now();
20570
20571 wxPyEndAllowThreads(__tstate);
20572 if (PyErr_Occurred()) SWIG_fail;
20573 }
20574 {
20575 wxDateTime * resultptr;
20576 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20577 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20578 }
20579 return resultobj;
20580 fail:
20581 return NULL;
20582 }
20583
20584
20585 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
20586 PyObject *resultobj = NULL;
20587 wxDateTime result;
20588 char *kwnames[] = {
20589 NULL
20590 };
20591
20592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
20593 {
20594 PyThreadState* __tstate = wxPyBeginAllowThreads();
20595 result = wxDateTime::UNow();
20596
20597 wxPyEndAllowThreads(__tstate);
20598 if (PyErr_Occurred()) SWIG_fail;
20599 }
20600 {
20601 wxDateTime * resultptr;
20602 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20603 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20604 }
20605 return resultobj;
20606 fail:
20607 return NULL;
20608 }
20609
20610
20611 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
20612 PyObject *resultobj = NULL;
20613 wxDateTime result;
20614 char *kwnames[] = {
20615 NULL
20616 };
20617
20618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
20619 {
20620 PyThreadState* __tstate = wxPyBeginAllowThreads();
20621 result = wxDateTime::Today();
20622
20623 wxPyEndAllowThreads(__tstate);
20624 if (PyErr_Occurred()) SWIG_fail;
20625 }
20626 {
20627 wxDateTime * resultptr;
20628 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20629 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20630 }
20631 return resultobj;
20632 fail:
20633 return NULL;
20634 }
20635
20636
20637 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20638 PyObject *resultobj = NULL;
20639 wxDateTime *result;
20640 char *kwnames[] = {
20641 NULL
20642 };
20643
20644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
20645 {
20646 PyThreadState* __tstate = wxPyBeginAllowThreads();
20647 result = (wxDateTime *)new wxDateTime();
20648
20649 wxPyEndAllowThreads(__tstate);
20650 if (PyErr_Occurred()) SWIG_fail;
20651 }
20652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20653 return resultobj;
20654 fail:
20655 return NULL;
20656 }
20657
20658
20659 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
20660 PyObject *resultobj = NULL;
20661 time_t arg1 ;
20662 wxDateTime *result;
20663 PyObject * obj0 = 0 ;
20664 char *kwnames[] = {
20665 (char *) "timet", NULL
20666 };
20667
20668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
20669 {
20670 arg1 = static_cast<time_t >(SWIG_As_unsigned_SS_int(obj0));
20671 if (SWIG_arg_fail(1)) SWIG_fail;
20672 }
20673 {
20674 PyThreadState* __tstate = wxPyBeginAllowThreads();
20675 result = (wxDateTime *)new wxDateTime(arg1);
20676
20677 wxPyEndAllowThreads(__tstate);
20678 if (PyErr_Occurred()) SWIG_fail;
20679 }
20680 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20681 return resultobj;
20682 fail:
20683 return NULL;
20684 }
20685
20686
20687 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20688 PyObject *resultobj = NULL;
20689 double arg1 ;
20690 wxDateTime *result;
20691 PyObject * obj0 = 0 ;
20692 char *kwnames[] = {
20693 (char *) "jdn", NULL
20694 };
20695
20696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
20697 {
20698 arg1 = static_cast<double >(SWIG_As_double(obj0));
20699 if (SWIG_arg_fail(1)) SWIG_fail;
20700 }
20701 {
20702 PyThreadState* __tstate = wxPyBeginAllowThreads();
20703 result = (wxDateTime *)new wxDateTime(arg1);
20704
20705 wxPyEndAllowThreads(__tstate);
20706 if (PyErr_Occurred()) SWIG_fail;
20707 }
20708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20709 return resultobj;
20710 fail:
20711 return NULL;
20712 }
20713
20714
20715 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20716 PyObject *resultobj = NULL;
20717 int arg1 ;
20718 int arg2 = (int) 0 ;
20719 int arg3 = (int) 0 ;
20720 int arg4 = (int) 0 ;
20721 wxDateTime *result;
20722 PyObject * obj0 = 0 ;
20723 PyObject * obj1 = 0 ;
20724 PyObject * obj2 = 0 ;
20725 PyObject * obj3 = 0 ;
20726 char *kwnames[] = {
20727 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20728 };
20729
20730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20731 {
20732 arg1 = static_cast<int >(SWIG_As_int(obj0));
20733 if (SWIG_arg_fail(1)) SWIG_fail;
20734 }
20735 if (obj1) {
20736 {
20737 arg2 = static_cast<int >(SWIG_As_int(obj1));
20738 if (SWIG_arg_fail(2)) SWIG_fail;
20739 }
20740 }
20741 if (obj2) {
20742 {
20743 arg3 = static_cast<int >(SWIG_As_int(obj2));
20744 if (SWIG_arg_fail(3)) SWIG_fail;
20745 }
20746 }
20747 if (obj3) {
20748 {
20749 arg4 = static_cast<int >(SWIG_As_int(obj3));
20750 if (SWIG_arg_fail(4)) SWIG_fail;
20751 }
20752 }
20753 {
20754 PyThreadState* __tstate = wxPyBeginAllowThreads();
20755 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
20756
20757 wxPyEndAllowThreads(__tstate);
20758 if (PyErr_Occurred()) SWIG_fail;
20759 }
20760 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20761 return resultobj;
20762 fail:
20763 return NULL;
20764 }
20765
20766
20767 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
20768 PyObject *resultobj = NULL;
20769 int arg1 ;
20770 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20771 int arg3 = (int) wxDateTime::Inv_Year ;
20772 int arg4 = (int) 0 ;
20773 int arg5 = (int) 0 ;
20774 int arg6 = (int) 0 ;
20775 int arg7 = (int) 0 ;
20776 wxDateTime *result;
20777 PyObject * obj0 = 0 ;
20778 PyObject * obj1 = 0 ;
20779 PyObject * obj2 = 0 ;
20780 PyObject * obj3 = 0 ;
20781 PyObject * obj4 = 0 ;
20782 PyObject * obj5 = 0 ;
20783 PyObject * obj6 = 0 ;
20784 char *kwnames[] = {
20785 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20786 };
20787
20788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
20789 {
20790 arg1 = static_cast<int >(SWIG_As_int(obj0));
20791 if (SWIG_arg_fail(1)) SWIG_fail;
20792 }
20793 if (obj1) {
20794 {
20795 arg2 = static_cast<wxDateTime::Month >(SWIG_As_int(obj1));
20796 if (SWIG_arg_fail(2)) SWIG_fail;
20797 }
20798 }
20799 if (obj2) {
20800 {
20801 arg3 = static_cast<int >(SWIG_As_int(obj2));
20802 if (SWIG_arg_fail(3)) SWIG_fail;
20803 }
20804 }
20805 if (obj3) {
20806 {
20807 arg4 = static_cast<int >(SWIG_As_int(obj3));
20808 if (SWIG_arg_fail(4)) SWIG_fail;
20809 }
20810 }
20811 if (obj4) {
20812 {
20813 arg5 = static_cast<int >(SWIG_As_int(obj4));
20814 if (SWIG_arg_fail(5)) SWIG_fail;
20815 }
20816 }
20817 if (obj5) {
20818 {
20819 arg6 = static_cast<int >(SWIG_As_int(obj5));
20820 if (SWIG_arg_fail(6)) SWIG_fail;
20821 }
20822 }
20823 if (obj6) {
20824 {
20825 arg7 = static_cast<int >(SWIG_As_int(obj6));
20826 if (SWIG_arg_fail(7)) SWIG_fail;
20827 }
20828 }
20829 {
20830 PyThreadState* __tstate = wxPyBeginAllowThreads();
20831 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
20832
20833 wxPyEndAllowThreads(__tstate);
20834 if (PyErr_Occurred()) SWIG_fail;
20835 }
20836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20837 return resultobj;
20838 fail:
20839 return NULL;
20840 }
20841
20842
20843 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20844 PyObject *resultobj = NULL;
20845 wxDateTime *arg1 = (wxDateTime *) 0 ;
20846 PyObject * obj0 = 0 ;
20847 char *kwnames[] = {
20848 (char *) "self", NULL
20849 };
20850
20851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
20852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20853 if (SWIG_arg_fail(1)) SWIG_fail;
20854 {
20855 PyThreadState* __tstate = wxPyBeginAllowThreads();
20856 delete arg1;
20857
20858 wxPyEndAllowThreads(__tstate);
20859 if (PyErr_Occurred()) SWIG_fail;
20860 }
20861 Py_INCREF(Py_None); resultobj = Py_None;
20862 return resultobj;
20863 fail:
20864 return NULL;
20865 }
20866
20867
20868 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
20869 PyObject *resultobj = NULL;
20870 wxDateTime *arg1 = (wxDateTime *) 0 ;
20871 wxDateTime *result;
20872 PyObject * obj0 = 0 ;
20873 char *kwnames[] = {
20874 (char *) "self", NULL
20875 };
20876
20877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
20878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20879 if (SWIG_arg_fail(1)) SWIG_fail;
20880 {
20881 PyThreadState* __tstate = wxPyBeginAllowThreads();
20882 {
20883 wxDateTime &_result_ref = (arg1)->SetToCurrent();
20884 result = (wxDateTime *) &_result_ref;
20885 }
20886
20887 wxPyEndAllowThreads(__tstate);
20888 if (PyErr_Occurred()) SWIG_fail;
20889 }
20890 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20891 return resultobj;
20892 fail:
20893 return NULL;
20894 }
20895
20896
20897 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
20898 PyObject *resultobj = NULL;
20899 wxDateTime *arg1 = (wxDateTime *) 0 ;
20900 time_t arg2 ;
20901 wxDateTime *result;
20902 PyObject * obj0 = 0 ;
20903 PyObject * obj1 = 0 ;
20904 char *kwnames[] = {
20905 (char *) "self",(char *) "timet", NULL
20906 };
20907
20908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
20909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20910 if (SWIG_arg_fail(1)) SWIG_fail;
20911 {
20912 arg2 = static_cast<time_t >(SWIG_As_unsigned_SS_int(obj1));
20913 if (SWIG_arg_fail(2)) SWIG_fail;
20914 }
20915 {
20916 PyThreadState* __tstate = wxPyBeginAllowThreads();
20917 {
20918 wxDateTime &_result_ref = (arg1)->Set(arg2);
20919 result = (wxDateTime *) &_result_ref;
20920 }
20921
20922 wxPyEndAllowThreads(__tstate);
20923 if (PyErr_Occurred()) SWIG_fail;
20924 }
20925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20926 return resultobj;
20927 fail:
20928 return NULL;
20929 }
20930
20931
20932 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20933 PyObject *resultobj = NULL;
20934 wxDateTime *arg1 = (wxDateTime *) 0 ;
20935 double arg2 ;
20936 wxDateTime *result;
20937 PyObject * obj0 = 0 ;
20938 PyObject * obj1 = 0 ;
20939 char *kwnames[] = {
20940 (char *) "self",(char *) "jdn", NULL
20941 };
20942
20943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
20944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20945 if (SWIG_arg_fail(1)) SWIG_fail;
20946 {
20947 arg2 = static_cast<double >(SWIG_As_double(obj1));
20948 if (SWIG_arg_fail(2)) SWIG_fail;
20949 }
20950 {
20951 PyThreadState* __tstate = wxPyBeginAllowThreads();
20952 {
20953 wxDateTime &_result_ref = (arg1)->Set(arg2);
20954 result = (wxDateTime *) &_result_ref;
20955 }
20956
20957 wxPyEndAllowThreads(__tstate);
20958 if (PyErr_Occurred()) SWIG_fail;
20959 }
20960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20961 return resultobj;
20962 fail:
20963 return NULL;
20964 }
20965
20966
20967 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20968 PyObject *resultobj = NULL;
20969 wxDateTime *arg1 = (wxDateTime *) 0 ;
20970 int arg2 ;
20971 int arg3 = (int) 0 ;
20972 int arg4 = (int) 0 ;
20973 int arg5 = (int) 0 ;
20974 wxDateTime *result;
20975 PyObject * obj0 = 0 ;
20976 PyObject * obj1 = 0 ;
20977 PyObject * obj2 = 0 ;
20978 PyObject * obj3 = 0 ;
20979 PyObject * obj4 = 0 ;
20980 char *kwnames[] = {
20981 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20982 };
20983
20984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20986 if (SWIG_arg_fail(1)) SWIG_fail;
20987 {
20988 arg2 = static_cast<int >(SWIG_As_int(obj1));
20989 if (SWIG_arg_fail(2)) SWIG_fail;
20990 }
20991 if (obj2) {
20992 {
20993 arg3 = static_cast<int >(SWIG_As_int(obj2));
20994 if (SWIG_arg_fail(3)) SWIG_fail;
20995 }
20996 }
20997 if (obj3) {
20998 {
20999 arg4 = static_cast<int >(SWIG_As_int(obj3));
21000 if (SWIG_arg_fail(4)) SWIG_fail;
21001 }
21002 }
21003 if (obj4) {
21004 {
21005 arg5 = static_cast<int >(SWIG_As_int(obj4));
21006 if (SWIG_arg_fail(5)) SWIG_fail;
21007 }
21008 }
21009 {
21010 PyThreadState* __tstate = wxPyBeginAllowThreads();
21011 {
21012 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
21013 result = (wxDateTime *) &_result_ref;
21014 }
21015
21016 wxPyEndAllowThreads(__tstate);
21017 if (PyErr_Occurred()) SWIG_fail;
21018 }
21019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21020 return resultobj;
21021 fail:
21022 return NULL;
21023 }
21024
21025
21026 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
21027 PyObject *resultobj = NULL;
21028 wxDateTime *arg1 = (wxDateTime *) 0 ;
21029 int arg2 ;
21030 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21031 int arg4 = (int) wxDateTime::Inv_Year ;
21032 int arg5 = (int) 0 ;
21033 int arg6 = (int) 0 ;
21034 int arg7 = (int) 0 ;
21035 int arg8 = (int) 0 ;
21036 wxDateTime *result;
21037 PyObject * obj0 = 0 ;
21038 PyObject * obj1 = 0 ;
21039 PyObject * obj2 = 0 ;
21040 PyObject * obj3 = 0 ;
21041 PyObject * obj4 = 0 ;
21042 PyObject * obj5 = 0 ;
21043 PyObject * obj6 = 0 ;
21044 PyObject * obj7 = 0 ;
21045 char *kwnames[] = {
21046 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
21047 };
21048
21049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
21050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21051 if (SWIG_arg_fail(1)) SWIG_fail;
21052 {
21053 arg2 = static_cast<int >(SWIG_As_int(obj1));
21054 if (SWIG_arg_fail(2)) SWIG_fail;
21055 }
21056 if (obj2) {
21057 {
21058 arg3 = static_cast<wxDateTime::Month >(SWIG_As_int(obj2));
21059 if (SWIG_arg_fail(3)) SWIG_fail;
21060 }
21061 }
21062 if (obj3) {
21063 {
21064 arg4 = static_cast<int >(SWIG_As_int(obj3));
21065 if (SWIG_arg_fail(4)) SWIG_fail;
21066 }
21067 }
21068 if (obj4) {
21069 {
21070 arg5 = static_cast<int >(SWIG_As_int(obj4));
21071 if (SWIG_arg_fail(5)) SWIG_fail;
21072 }
21073 }
21074 if (obj5) {
21075 {
21076 arg6 = static_cast<int >(SWIG_As_int(obj5));
21077 if (SWIG_arg_fail(6)) SWIG_fail;
21078 }
21079 }
21080 if (obj6) {
21081 {
21082 arg7 = static_cast<int >(SWIG_As_int(obj6));
21083 if (SWIG_arg_fail(7)) SWIG_fail;
21084 }
21085 }
21086 if (obj7) {
21087 {
21088 arg8 = static_cast<int >(SWIG_As_int(obj7));
21089 if (SWIG_arg_fail(8)) SWIG_fail;
21090 }
21091 }
21092 {
21093 PyThreadState* __tstate = wxPyBeginAllowThreads();
21094 {
21095 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21096 result = (wxDateTime *) &_result_ref;
21097 }
21098
21099 wxPyEndAllowThreads(__tstate);
21100 if (PyErr_Occurred()) SWIG_fail;
21101 }
21102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21103 return resultobj;
21104 fail:
21105 return NULL;
21106 }
21107
21108
21109 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
21110 PyObject *resultobj = NULL;
21111 wxDateTime *arg1 = (wxDateTime *) 0 ;
21112 wxDateTime *result;
21113 PyObject * obj0 = 0 ;
21114 char *kwnames[] = {
21115 (char *) "self", NULL
21116 };
21117
21118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
21119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21120 if (SWIG_arg_fail(1)) SWIG_fail;
21121 {
21122 PyThreadState* __tstate = wxPyBeginAllowThreads();
21123 {
21124 wxDateTime &_result_ref = (arg1)->ResetTime();
21125 result = (wxDateTime *) &_result_ref;
21126 }
21127
21128 wxPyEndAllowThreads(__tstate);
21129 if (PyErr_Occurred()) SWIG_fail;
21130 }
21131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21132 return resultobj;
21133 fail:
21134 return NULL;
21135 }
21136
21137
21138 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21139 PyObject *resultobj = NULL;
21140 wxDateTime *arg1 = (wxDateTime *) 0 ;
21141 int arg2 ;
21142 wxDateTime *result;
21143 PyObject * obj0 = 0 ;
21144 PyObject * obj1 = 0 ;
21145 char *kwnames[] = {
21146 (char *) "self",(char *) "year", NULL
21147 };
21148
21149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
21150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21151 if (SWIG_arg_fail(1)) SWIG_fail;
21152 {
21153 arg2 = static_cast<int >(SWIG_As_int(obj1));
21154 if (SWIG_arg_fail(2)) SWIG_fail;
21155 }
21156 {
21157 PyThreadState* __tstate = wxPyBeginAllowThreads();
21158 {
21159 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
21160 result = (wxDateTime *) &_result_ref;
21161 }
21162
21163 wxPyEndAllowThreads(__tstate);
21164 if (PyErr_Occurred()) SWIG_fail;
21165 }
21166 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21167 return resultobj;
21168 fail:
21169 return NULL;
21170 }
21171
21172
21173 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21174 PyObject *resultobj = NULL;
21175 wxDateTime *arg1 = (wxDateTime *) 0 ;
21176 wxDateTime::Month arg2 ;
21177 wxDateTime *result;
21178 PyObject * obj0 = 0 ;
21179 PyObject * obj1 = 0 ;
21180 char *kwnames[] = {
21181 (char *) "self",(char *) "month", NULL
21182 };
21183
21184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
21185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21186 if (SWIG_arg_fail(1)) SWIG_fail;
21187 {
21188 arg2 = static_cast<wxDateTime::Month >(SWIG_As_int(obj1));
21189 if (SWIG_arg_fail(2)) SWIG_fail;
21190 }
21191 {
21192 PyThreadState* __tstate = wxPyBeginAllowThreads();
21193 {
21194 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
21195 result = (wxDateTime *) &_result_ref;
21196 }
21197
21198 wxPyEndAllowThreads(__tstate);
21199 if (PyErr_Occurred()) SWIG_fail;
21200 }
21201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21202 return resultobj;
21203 fail:
21204 return NULL;
21205 }
21206
21207
21208 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21209 PyObject *resultobj = NULL;
21210 wxDateTime *arg1 = (wxDateTime *) 0 ;
21211 int arg2 ;
21212 wxDateTime *result;
21213 PyObject * obj0 = 0 ;
21214 PyObject * obj1 = 0 ;
21215 char *kwnames[] = {
21216 (char *) "self",(char *) "day", NULL
21217 };
21218
21219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
21220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21221 if (SWIG_arg_fail(1)) SWIG_fail;
21222 {
21223 arg2 = static_cast<int >(SWIG_As_int(obj1));
21224 if (SWIG_arg_fail(2)) SWIG_fail;
21225 }
21226 {
21227 PyThreadState* __tstate = wxPyBeginAllowThreads();
21228 {
21229 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
21230 result = (wxDateTime *) &_result_ref;
21231 }
21232
21233 wxPyEndAllowThreads(__tstate);
21234 if (PyErr_Occurred()) SWIG_fail;
21235 }
21236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21237 return resultobj;
21238 fail:
21239 return NULL;
21240 }
21241
21242
21243 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21244 PyObject *resultobj = NULL;
21245 wxDateTime *arg1 = (wxDateTime *) 0 ;
21246 int arg2 ;
21247 wxDateTime *result;
21248 PyObject * obj0 = 0 ;
21249 PyObject * obj1 = 0 ;
21250 char *kwnames[] = {
21251 (char *) "self",(char *) "hour", NULL
21252 };
21253
21254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
21255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21256 if (SWIG_arg_fail(1)) SWIG_fail;
21257 {
21258 arg2 = static_cast<int >(SWIG_As_int(obj1));
21259 if (SWIG_arg_fail(2)) SWIG_fail;
21260 }
21261 {
21262 PyThreadState* __tstate = wxPyBeginAllowThreads();
21263 {
21264 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
21265 result = (wxDateTime *) &_result_ref;
21266 }
21267
21268 wxPyEndAllowThreads(__tstate);
21269 if (PyErr_Occurred()) SWIG_fail;
21270 }
21271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21272 return resultobj;
21273 fail:
21274 return NULL;
21275 }
21276
21277
21278 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21279 PyObject *resultobj = NULL;
21280 wxDateTime *arg1 = (wxDateTime *) 0 ;
21281 int arg2 ;
21282 wxDateTime *result;
21283 PyObject * obj0 = 0 ;
21284 PyObject * obj1 = 0 ;
21285 char *kwnames[] = {
21286 (char *) "self",(char *) "minute", NULL
21287 };
21288
21289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
21290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21291 if (SWIG_arg_fail(1)) SWIG_fail;
21292 {
21293 arg2 = static_cast<int >(SWIG_As_int(obj1));
21294 if (SWIG_arg_fail(2)) SWIG_fail;
21295 }
21296 {
21297 PyThreadState* __tstate = wxPyBeginAllowThreads();
21298 {
21299 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
21300 result = (wxDateTime *) &_result_ref;
21301 }
21302
21303 wxPyEndAllowThreads(__tstate);
21304 if (PyErr_Occurred()) SWIG_fail;
21305 }
21306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21307 return resultobj;
21308 fail:
21309 return NULL;
21310 }
21311
21312
21313 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21314 PyObject *resultobj = NULL;
21315 wxDateTime *arg1 = (wxDateTime *) 0 ;
21316 int arg2 ;
21317 wxDateTime *result;
21318 PyObject * obj0 = 0 ;
21319 PyObject * obj1 = 0 ;
21320 char *kwnames[] = {
21321 (char *) "self",(char *) "second", NULL
21322 };
21323
21324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
21325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21326 if (SWIG_arg_fail(1)) SWIG_fail;
21327 {
21328 arg2 = static_cast<int >(SWIG_As_int(obj1));
21329 if (SWIG_arg_fail(2)) SWIG_fail;
21330 }
21331 {
21332 PyThreadState* __tstate = wxPyBeginAllowThreads();
21333 {
21334 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
21335 result = (wxDateTime *) &_result_ref;
21336 }
21337
21338 wxPyEndAllowThreads(__tstate);
21339 if (PyErr_Occurred()) SWIG_fail;
21340 }
21341 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21342 return resultobj;
21343 fail:
21344 return NULL;
21345 }
21346
21347
21348 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21349 PyObject *resultobj = NULL;
21350 wxDateTime *arg1 = (wxDateTime *) 0 ;
21351 int arg2 ;
21352 wxDateTime *result;
21353 PyObject * obj0 = 0 ;
21354 PyObject * obj1 = 0 ;
21355 char *kwnames[] = {
21356 (char *) "self",(char *) "millisecond", NULL
21357 };
21358
21359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21361 if (SWIG_arg_fail(1)) SWIG_fail;
21362 {
21363 arg2 = static_cast<int >(SWIG_As_int(obj1));
21364 if (SWIG_arg_fail(2)) SWIG_fail;
21365 }
21366 {
21367 PyThreadState* __tstate = wxPyBeginAllowThreads();
21368 {
21369 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
21370 result = (wxDateTime *) &_result_ref;
21371 }
21372
21373 wxPyEndAllowThreads(__tstate);
21374 if (PyErr_Occurred()) SWIG_fail;
21375 }
21376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21377 return resultobj;
21378 fail:
21379 return NULL;
21380 }
21381
21382
21383 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21384 PyObject *resultobj = NULL;
21385 wxDateTime *arg1 = (wxDateTime *) 0 ;
21386 wxDateTime::WeekDay arg2 ;
21387 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21388 wxDateTime *result;
21389 PyObject * obj0 = 0 ;
21390 PyObject * obj1 = 0 ;
21391 PyObject * obj2 = 0 ;
21392 char *kwnames[] = {
21393 (char *) "self",(char *) "weekday",(char *) "flags", NULL
21394 };
21395
21396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
21397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21398 if (SWIG_arg_fail(1)) SWIG_fail;
21399 {
21400 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21401 if (SWIG_arg_fail(2)) SWIG_fail;
21402 }
21403 if (obj2) {
21404 {
21405 arg3 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj2));
21406 if (SWIG_arg_fail(3)) SWIG_fail;
21407 }
21408 }
21409 {
21410 PyThreadState* __tstate = wxPyBeginAllowThreads();
21411 {
21412 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
21413 result = (wxDateTime *) &_result_ref;
21414 }
21415
21416 wxPyEndAllowThreads(__tstate);
21417 if (PyErr_Occurred()) SWIG_fail;
21418 }
21419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21420 return resultobj;
21421 fail:
21422 return NULL;
21423 }
21424
21425
21426 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21427 PyObject *resultobj = NULL;
21428 wxDateTime *arg1 = (wxDateTime *) 0 ;
21429 wxDateTime::WeekDay arg2 ;
21430 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21431 wxDateTime result;
21432 PyObject * obj0 = 0 ;
21433 PyObject * obj1 = 0 ;
21434 PyObject * obj2 = 0 ;
21435 char *kwnames[] = {
21436 (char *) "self",(char *) "weekday",(char *) "flags", NULL
21437 };
21438
21439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
21440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21441 if (SWIG_arg_fail(1)) SWIG_fail;
21442 {
21443 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21444 if (SWIG_arg_fail(2)) SWIG_fail;
21445 }
21446 if (obj2) {
21447 {
21448 arg3 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj2));
21449 if (SWIG_arg_fail(3)) SWIG_fail;
21450 }
21451 }
21452 {
21453 PyThreadState* __tstate = wxPyBeginAllowThreads();
21454 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
21455
21456 wxPyEndAllowThreads(__tstate);
21457 if (PyErr_Occurred()) SWIG_fail;
21458 }
21459 {
21460 wxDateTime * resultptr;
21461 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21462 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21463 }
21464 return resultobj;
21465 fail:
21466 return NULL;
21467 }
21468
21469
21470 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21471 PyObject *resultobj = NULL;
21472 wxDateTime *arg1 = (wxDateTime *) 0 ;
21473 wxDateTime::WeekDay arg2 ;
21474 wxDateTime *result;
21475 PyObject * obj0 = 0 ;
21476 PyObject * obj1 = 0 ;
21477 char *kwnames[] = {
21478 (char *) "self",(char *) "weekday", NULL
21479 };
21480
21481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
21482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21483 if (SWIG_arg_fail(1)) SWIG_fail;
21484 {
21485 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21486 if (SWIG_arg_fail(2)) SWIG_fail;
21487 }
21488 {
21489 PyThreadState* __tstate = wxPyBeginAllowThreads();
21490 {
21491 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
21492 result = (wxDateTime *) &_result_ref;
21493 }
21494
21495 wxPyEndAllowThreads(__tstate);
21496 if (PyErr_Occurred()) SWIG_fail;
21497 }
21498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21499 return resultobj;
21500 fail:
21501 return NULL;
21502 }
21503
21504
21505 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21506 PyObject *resultobj = NULL;
21507 wxDateTime *arg1 = (wxDateTime *) 0 ;
21508 wxDateTime::WeekDay arg2 ;
21509 wxDateTime result;
21510 PyObject * obj0 = 0 ;
21511 PyObject * obj1 = 0 ;
21512 char *kwnames[] = {
21513 (char *) "self",(char *) "weekday", NULL
21514 };
21515
21516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
21517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21518 if (SWIG_arg_fail(1)) SWIG_fail;
21519 {
21520 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21521 if (SWIG_arg_fail(2)) SWIG_fail;
21522 }
21523 {
21524 PyThreadState* __tstate = wxPyBeginAllowThreads();
21525 result = (arg1)->GetNextWeekDay(arg2);
21526
21527 wxPyEndAllowThreads(__tstate);
21528 if (PyErr_Occurred()) SWIG_fail;
21529 }
21530 {
21531 wxDateTime * resultptr;
21532 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21533 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21534 }
21535 return resultobj;
21536 fail:
21537 return NULL;
21538 }
21539
21540
21541 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21542 PyObject *resultobj = NULL;
21543 wxDateTime *arg1 = (wxDateTime *) 0 ;
21544 wxDateTime::WeekDay arg2 ;
21545 wxDateTime *result;
21546 PyObject * obj0 = 0 ;
21547 PyObject * obj1 = 0 ;
21548 char *kwnames[] = {
21549 (char *) "self",(char *) "weekday", NULL
21550 };
21551
21552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
21553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21554 if (SWIG_arg_fail(1)) SWIG_fail;
21555 {
21556 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21557 if (SWIG_arg_fail(2)) SWIG_fail;
21558 }
21559 {
21560 PyThreadState* __tstate = wxPyBeginAllowThreads();
21561 {
21562 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
21563 result = (wxDateTime *) &_result_ref;
21564 }
21565
21566 wxPyEndAllowThreads(__tstate);
21567 if (PyErr_Occurred()) SWIG_fail;
21568 }
21569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21570 return resultobj;
21571 fail:
21572 return NULL;
21573 }
21574
21575
21576 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21577 PyObject *resultobj = NULL;
21578 wxDateTime *arg1 = (wxDateTime *) 0 ;
21579 wxDateTime::WeekDay arg2 ;
21580 wxDateTime result;
21581 PyObject * obj0 = 0 ;
21582 PyObject * obj1 = 0 ;
21583 char *kwnames[] = {
21584 (char *) "self",(char *) "weekday", NULL
21585 };
21586
21587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
21588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21589 if (SWIG_arg_fail(1)) SWIG_fail;
21590 {
21591 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21592 if (SWIG_arg_fail(2)) SWIG_fail;
21593 }
21594 {
21595 PyThreadState* __tstate = wxPyBeginAllowThreads();
21596 result = (arg1)->GetPrevWeekDay(arg2);
21597
21598 wxPyEndAllowThreads(__tstate);
21599 if (PyErr_Occurred()) SWIG_fail;
21600 }
21601 {
21602 wxDateTime * resultptr;
21603 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21604 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21605 }
21606 return resultobj;
21607 fail:
21608 return NULL;
21609 }
21610
21611
21612 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21613 PyObject *resultobj = NULL;
21614 wxDateTime *arg1 = (wxDateTime *) 0 ;
21615 wxDateTime::WeekDay arg2 ;
21616 int arg3 = (int) 1 ;
21617 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21618 int arg5 = (int) wxDateTime::Inv_Year ;
21619 bool result;
21620 PyObject * obj0 = 0 ;
21621 PyObject * obj1 = 0 ;
21622 PyObject * obj2 = 0 ;
21623 PyObject * obj3 = 0 ;
21624 PyObject * obj4 = 0 ;
21625 char *kwnames[] = {
21626 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
21627 };
21628
21629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21631 if (SWIG_arg_fail(1)) SWIG_fail;
21632 {
21633 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21634 if (SWIG_arg_fail(2)) SWIG_fail;
21635 }
21636 if (obj2) {
21637 {
21638 arg3 = static_cast<int >(SWIG_As_int(obj2));
21639 if (SWIG_arg_fail(3)) SWIG_fail;
21640 }
21641 }
21642 if (obj3) {
21643 {
21644 arg4 = static_cast<wxDateTime::Month >(SWIG_As_int(obj3));
21645 if (SWIG_arg_fail(4)) SWIG_fail;
21646 }
21647 }
21648 if (obj4) {
21649 {
21650 arg5 = static_cast<int >(SWIG_As_int(obj4));
21651 if (SWIG_arg_fail(5)) SWIG_fail;
21652 }
21653 }
21654 {
21655 PyThreadState* __tstate = wxPyBeginAllowThreads();
21656 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
21657
21658 wxPyEndAllowThreads(__tstate);
21659 if (PyErr_Occurred()) SWIG_fail;
21660 }
21661 {
21662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21663 }
21664 return resultobj;
21665 fail:
21666 return NULL;
21667 }
21668
21669
21670 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21671 PyObject *resultobj = NULL;
21672 wxDateTime *arg1 = (wxDateTime *) 0 ;
21673 wxDateTime::WeekDay arg2 ;
21674 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21675 int arg4 = (int) wxDateTime::Inv_Year ;
21676 bool result;
21677 PyObject * obj0 = 0 ;
21678 PyObject * obj1 = 0 ;
21679 PyObject * obj2 = 0 ;
21680 PyObject * obj3 = 0 ;
21681 char *kwnames[] = {
21682 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
21683 };
21684
21685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21687 if (SWIG_arg_fail(1)) SWIG_fail;
21688 {
21689 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21690 if (SWIG_arg_fail(2)) SWIG_fail;
21691 }
21692 if (obj2) {
21693 {
21694 arg3 = static_cast<wxDateTime::Month >(SWIG_As_int(obj2));
21695 if (SWIG_arg_fail(3)) SWIG_fail;
21696 }
21697 }
21698 if (obj3) {
21699 {
21700 arg4 = static_cast<int >(SWIG_As_int(obj3));
21701 if (SWIG_arg_fail(4)) SWIG_fail;
21702 }
21703 }
21704 {
21705 PyThreadState* __tstate = wxPyBeginAllowThreads();
21706 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
21707
21708 wxPyEndAllowThreads(__tstate);
21709 if (PyErr_Occurred()) SWIG_fail;
21710 }
21711 {
21712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21713 }
21714 return resultobj;
21715 fail:
21716 return NULL;
21717 }
21718
21719
21720 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21721 PyObject *resultobj = NULL;
21722 wxDateTime *arg1 = (wxDateTime *) 0 ;
21723 wxDateTime::WeekDay arg2 ;
21724 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21725 int arg4 = (int) wxDateTime::Inv_Year ;
21726 wxDateTime result;
21727 PyObject * obj0 = 0 ;
21728 PyObject * obj1 = 0 ;
21729 PyObject * obj2 = 0 ;
21730 PyObject * obj3 = 0 ;
21731 char *kwnames[] = {
21732 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
21733 };
21734
21735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21737 if (SWIG_arg_fail(1)) SWIG_fail;
21738 {
21739 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21740 if (SWIG_arg_fail(2)) SWIG_fail;
21741 }
21742 if (obj2) {
21743 {
21744 arg3 = static_cast<wxDateTime::Month >(SWIG_As_int(obj2));
21745 if (SWIG_arg_fail(3)) SWIG_fail;
21746 }
21747 }
21748 if (obj3) {
21749 {
21750 arg4 = static_cast<int >(SWIG_As_int(obj3));
21751 if (SWIG_arg_fail(4)) SWIG_fail;
21752 }
21753 }
21754 {
21755 PyThreadState* __tstate = wxPyBeginAllowThreads();
21756 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
21757
21758 wxPyEndAllowThreads(__tstate);
21759 if (PyErr_Occurred()) SWIG_fail;
21760 }
21761 {
21762 wxDateTime * resultptr;
21763 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21764 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21765 }
21766 return resultobj;
21767 fail:
21768 return NULL;
21769 }
21770
21771
21772 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21773 PyObject *resultobj = NULL;
21774 wxDateTime *arg1 = (wxDateTime *) 0 ;
21775 int arg2 ;
21776 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21777 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21778 bool result;
21779 PyObject * obj0 = 0 ;
21780 PyObject * obj1 = 0 ;
21781 PyObject * obj2 = 0 ;
21782 PyObject * obj3 = 0 ;
21783 char *kwnames[] = {
21784 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
21785 };
21786
21787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21789 if (SWIG_arg_fail(1)) SWIG_fail;
21790 {
21791 arg2 = static_cast<int >(SWIG_As_int(obj1));
21792 if (SWIG_arg_fail(2)) SWIG_fail;
21793 }
21794 if (obj2) {
21795 {
21796 arg3 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj2));
21797 if (SWIG_arg_fail(3)) SWIG_fail;
21798 }
21799 }
21800 if (obj3) {
21801 {
21802 arg4 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj3));
21803 if (SWIG_arg_fail(4)) SWIG_fail;
21804 }
21805 }
21806 {
21807 PyThreadState* __tstate = wxPyBeginAllowThreads();
21808 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
21809
21810 wxPyEndAllowThreads(__tstate);
21811 if (PyErr_Occurred()) SWIG_fail;
21812 }
21813 {
21814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21815 }
21816 return resultobj;
21817 fail:
21818 return NULL;
21819 }
21820
21821
21822 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21823 PyObject *resultobj = NULL;
21824 wxDateTime *arg1 = (wxDateTime *) 0 ;
21825 int arg2 ;
21826 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21827 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21828 wxDateTime result;
21829 PyObject * obj0 = 0 ;
21830 PyObject * obj1 = 0 ;
21831 PyObject * obj2 = 0 ;
21832 PyObject * obj3 = 0 ;
21833 char *kwnames[] = {
21834 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
21835 };
21836
21837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21839 if (SWIG_arg_fail(1)) SWIG_fail;
21840 {
21841 arg2 = static_cast<int >(SWIG_As_int(obj1));
21842 if (SWIG_arg_fail(2)) SWIG_fail;
21843 }
21844 if (obj2) {
21845 {
21846 arg3 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj2));
21847 if (SWIG_arg_fail(3)) SWIG_fail;
21848 }
21849 }
21850 if (obj3) {
21851 {
21852 arg4 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj3));
21853 if (SWIG_arg_fail(4)) SWIG_fail;
21854 }
21855 }
21856 {
21857 PyThreadState* __tstate = wxPyBeginAllowThreads();
21858 result = (arg1)->GetWeek(arg2,arg3,arg4);
21859
21860 wxPyEndAllowThreads(__tstate);
21861 if (PyErr_Occurred()) SWIG_fail;
21862 }
21863 {
21864 wxDateTime * resultptr;
21865 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21867 }
21868 return resultobj;
21869 fail:
21870 return NULL;
21871 }
21872
21873
21874 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21875 PyObject *resultobj = NULL;
21876 int arg1 ;
21877 int arg2 ;
21878 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21879 wxDateTime result;
21880 PyObject * obj0 = 0 ;
21881 PyObject * obj1 = 0 ;
21882 PyObject * obj2 = 0 ;
21883 char *kwnames[] = {
21884 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
21885 };
21886
21887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21888 {
21889 arg1 = static_cast<int >(SWIG_As_int(obj0));
21890 if (SWIG_arg_fail(1)) SWIG_fail;
21891 }
21892 {
21893 arg2 = static_cast<int >(SWIG_As_int(obj1));
21894 if (SWIG_arg_fail(2)) SWIG_fail;
21895 }
21896 if (obj2) {
21897 {
21898 arg3 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj2));
21899 if (SWIG_arg_fail(3)) SWIG_fail;
21900 }
21901 }
21902 {
21903 PyThreadState* __tstate = wxPyBeginAllowThreads();
21904 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
21905
21906 wxPyEndAllowThreads(__tstate);
21907 if (PyErr_Occurred()) SWIG_fail;
21908 }
21909 {
21910 wxDateTime * resultptr;
21911 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21912 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21913 }
21914 return resultobj;
21915 fail:
21916 return NULL;
21917 }
21918
21919
21920 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21921 PyObject *resultobj = NULL;
21922 wxDateTime *arg1 = (wxDateTime *) 0 ;
21923 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21924 int arg3 = (int) wxDateTime::Inv_Year ;
21925 wxDateTime *result;
21926 PyObject * obj0 = 0 ;
21927 PyObject * obj1 = 0 ;
21928 PyObject * obj2 = 0 ;
21929 char *kwnames[] = {
21930 (char *) "self",(char *) "month",(char *) "year", NULL
21931 };
21932
21933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21935 if (SWIG_arg_fail(1)) SWIG_fail;
21936 if (obj1) {
21937 {
21938 arg2 = static_cast<wxDateTime::Month >(SWIG_As_int(obj1));
21939 if (SWIG_arg_fail(2)) SWIG_fail;
21940 }
21941 }
21942 if (obj2) {
21943 {
21944 arg3 = static_cast<int >(SWIG_As_int(obj2));
21945 if (SWIG_arg_fail(3)) SWIG_fail;
21946 }
21947 }
21948 {
21949 PyThreadState* __tstate = wxPyBeginAllowThreads();
21950 {
21951 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
21952 result = (wxDateTime *) &_result_ref;
21953 }
21954
21955 wxPyEndAllowThreads(__tstate);
21956 if (PyErr_Occurred()) SWIG_fail;
21957 }
21958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21959 return resultobj;
21960 fail:
21961 return NULL;
21962 }
21963
21964
21965 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21966 PyObject *resultobj = NULL;
21967 wxDateTime *arg1 = (wxDateTime *) 0 ;
21968 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21969 int arg3 = (int) wxDateTime::Inv_Year ;
21970 wxDateTime result;
21971 PyObject * obj0 = 0 ;
21972 PyObject * obj1 = 0 ;
21973 PyObject * obj2 = 0 ;
21974 char *kwnames[] = {
21975 (char *) "self",(char *) "month",(char *) "year", NULL
21976 };
21977
21978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21980 if (SWIG_arg_fail(1)) SWIG_fail;
21981 if (obj1) {
21982 {
21983 arg2 = static_cast<wxDateTime::Month >(SWIG_As_int(obj1));
21984 if (SWIG_arg_fail(2)) SWIG_fail;
21985 }
21986 }
21987 if (obj2) {
21988 {
21989 arg3 = static_cast<int >(SWIG_As_int(obj2));
21990 if (SWIG_arg_fail(3)) SWIG_fail;
21991 }
21992 }
21993 {
21994 PyThreadState* __tstate = wxPyBeginAllowThreads();
21995 result = (arg1)->GetLastMonthDay(arg2,arg3);
21996
21997 wxPyEndAllowThreads(__tstate);
21998 if (PyErr_Occurred()) SWIG_fail;
21999 }
22000 {
22001 wxDateTime * resultptr;
22002 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22003 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22004 }
22005 return resultobj;
22006 fail:
22007 return NULL;
22008 }
22009
22010
22011 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
22012 PyObject *resultobj = NULL;
22013 wxDateTime *arg1 = (wxDateTime *) 0 ;
22014 int arg2 ;
22015 wxDateTime *result;
22016 PyObject * obj0 = 0 ;
22017 PyObject * obj1 = 0 ;
22018 char *kwnames[] = {
22019 (char *) "self",(char *) "yday", NULL
22020 };
22021
22022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
22023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22024 if (SWIG_arg_fail(1)) SWIG_fail;
22025 {
22026 arg2 = static_cast<int >(SWIG_As_int(obj1));
22027 if (SWIG_arg_fail(2)) SWIG_fail;
22028 }
22029 {
22030 PyThreadState* __tstate = wxPyBeginAllowThreads();
22031 {
22032 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
22033 result = (wxDateTime *) &_result_ref;
22034 }
22035
22036 wxPyEndAllowThreads(__tstate);
22037 if (PyErr_Occurred()) SWIG_fail;
22038 }
22039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22040 return resultobj;
22041 fail:
22042 return NULL;
22043 }
22044
22045
22046 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
22047 PyObject *resultobj = NULL;
22048 wxDateTime *arg1 = (wxDateTime *) 0 ;
22049 int arg2 ;
22050 wxDateTime result;
22051 PyObject * obj0 = 0 ;
22052 PyObject * obj1 = 0 ;
22053 char *kwnames[] = {
22054 (char *) "self",(char *) "yday", NULL
22055 };
22056
22057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
22058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22059 if (SWIG_arg_fail(1)) SWIG_fail;
22060 {
22061 arg2 = static_cast<int >(SWIG_As_int(obj1));
22062 if (SWIG_arg_fail(2)) SWIG_fail;
22063 }
22064 {
22065 PyThreadState* __tstate = wxPyBeginAllowThreads();
22066 result = (arg1)->GetYearDay(arg2);
22067
22068 wxPyEndAllowThreads(__tstate);
22069 if (PyErr_Occurred()) SWIG_fail;
22070 }
22071 {
22072 wxDateTime * resultptr;
22073 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22074 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22075 }
22076 return resultobj;
22077 fail:
22078 return NULL;
22079 }
22080
22081
22082 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
22083 PyObject *resultobj = NULL;
22084 wxDateTime *arg1 = (wxDateTime *) 0 ;
22085 double result;
22086 PyObject * obj0 = 0 ;
22087 char *kwnames[] = {
22088 (char *) "self", NULL
22089 };
22090
22091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
22092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22093 if (SWIG_arg_fail(1)) SWIG_fail;
22094 {
22095 PyThreadState* __tstate = wxPyBeginAllowThreads();
22096 result = (double)(arg1)->GetJulianDayNumber();
22097
22098 wxPyEndAllowThreads(__tstate);
22099 if (PyErr_Occurred()) SWIG_fail;
22100 }
22101 {
22102 resultobj = SWIG_From_double(static_cast<double >(result));
22103 }
22104 return resultobj;
22105 fail:
22106 return NULL;
22107 }
22108
22109
22110 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
22111 PyObject *resultobj = NULL;
22112 wxDateTime *arg1 = (wxDateTime *) 0 ;
22113 double result;
22114 PyObject * obj0 = 0 ;
22115 char *kwnames[] = {
22116 (char *) "self", NULL
22117 };
22118
22119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
22120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22121 if (SWIG_arg_fail(1)) SWIG_fail;
22122 {
22123 PyThreadState* __tstate = wxPyBeginAllowThreads();
22124 result = (double)(arg1)->GetJDN();
22125
22126 wxPyEndAllowThreads(__tstate);
22127 if (PyErr_Occurred()) SWIG_fail;
22128 }
22129 {
22130 resultobj = SWIG_From_double(static_cast<double >(result));
22131 }
22132 return resultobj;
22133 fail:
22134 return NULL;
22135 }
22136
22137
22138 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
22139 PyObject *resultobj = NULL;
22140 wxDateTime *arg1 = (wxDateTime *) 0 ;
22141 double result;
22142 PyObject * obj0 = 0 ;
22143 char *kwnames[] = {
22144 (char *) "self", NULL
22145 };
22146
22147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
22148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22149 if (SWIG_arg_fail(1)) SWIG_fail;
22150 {
22151 PyThreadState* __tstate = wxPyBeginAllowThreads();
22152 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
22153
22154 wxPyEndAllowThreads(__tstate);
22155 if (PyErr_Occurred()) SWIG_fail;
22156 }
22157 {
22158 resultobj = SWIG_From_double(static_cast<double >(result));
22159 }
22160 return resultobj;
22161 fail:
22162 return NULL;
22163 }
22164
22165
22166 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
22167 PyObject *resultobj = NULL;
22168 wxDateTime *arg1 = (wxDateTime *) 0 ;
22169 double result;
22170 PyObject * obj0 = 0 ;
22171 char *kwnames[] = {
22172 (char *) "self", NULL
22173 };
22174
22175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
22176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22177 if (SWIG_arg_fail(1)) SWIG_fail;
22178 {
22179 PyThreadState* __tstate = wxPyBeginAllowThreads();
22180 result = (double)(arg1)->GetMJD();
22181
22182 wxPyEndAllowThreads(__tstate);
22183 if (PyErr_Occurred()) SWIG_fail;
22184 }
22185 {
22186 resultobj = SWIG_From_double(static_cast<double >(result));
22187 }
22188 return resultobj;
22189 fail:
22190 return NULL;
22191 }
22192
22193
22194 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
22195 PyObject *resultobj = NULL;
22196 wxDateTime *arg1 = (wxDateTime *) 0 ;
22197 double result;
22198 PyObject * obj0 = 0 ;
22199 char *kwnames[] = {
22200 (char *) "self", NULL
22201 };
22202
22203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
22204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22205 if (SWIG_arg_fail(1)) SWIG_fail;
22206 {
22207 PyThreadState* __tstate = wxPyBeginAllowThreads();
22208 result = (double)(arg1)->GetRataDie();
22209
22210 wxPyEndAllowThreads(__tstate);
22211 if (PyErr_Occurred()) SWIG_fail;
22212 }
22213 {
22214 resultobj = SWIG_From_double(static_cast<double >(result));
22215 }
22216 return resultobj;
22217 fail:
22218 return NULL;
22219 }
22220
22221
22222 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
22223 PyObject *resultobj = NULL;
22224 wxDateTime *arg1 = (wxDateTime *) 0 ;
22225 wxDateTime::TimeZone *arg2 = 0 ;
22226 bool arg3 = (bool) false ;
22227 wxDateTime result;
22228 bool temp2 = false ;
22229 PyObject * obj0 = 0 ;
22230 PyObject * obj1 = 0 ;
22231 PyObject * obj2 = 0 ;
22232 char *kwnames[] = {
22233 (char *) "self",(char *) "tz",(char *) "noDST", NULL
22234 };
22235
22236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
22237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22238 if (SWIG_arg_fail(1)) SWIG_fail;
22239 {
22240 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22241 temp2 = true;
22242 }
22243 if (obj2) {
22244 {
22245 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
22246 if (SWIG_arg_fail(3)) SWIG_fail;
22247 }
22248 }
22249 {
22250 PyThreadState* __tstate = wxPyBeginAllowThreads();
22251 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
22252
22253 wxPyEndAllowThreads(__tstate);
22254 if (PyErr_Occurred()) SWIG_fail;
22255 }
22256 {
22257 wxDateTime * resultptr;
22258 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22259 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22260 }
22261 {
22262 if (temp2) delete arg2;
22263 }
22264 return resultobj;
22265 fail:
22266 {
22267 if (temp2) delete arg2;
22268 }
22269 return NULL;
22270 }
22271
22272
22273 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
22274 PyObject *resultobj = NULL;
22275 wxDateTime *arg1 = (wxDateTime *) 0 ;
22276 wxDateTime::TimeZone *arg2 = 0 ;
22277 bool arg3 = (bool) false ;
22278 wxDateTime *result;
22279 bool temp2 = false ;
22280 PyObject * obj0 = 0 ;
22281 PyObject * obj1 = 0 ;
22282 PyObject * obj2 = 0 ;
22283 char *kwnames[] = {
22284 (char *) "self",(char *) "tz",(char *) "noDST", NULL
22285 };
22286
22287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
22288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22289 if (SWIG_arg_fail(1)) SWIG_fail;
22290 {
22291 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22292 temp2 = true;
22293 }
22294 if (obj2) {
22295 {
22296 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
22297 if (SWIG_arg_fail(3)) SWIG_fail;
22298 }
22299 }
22300 {
22301 PyThreadState* __tstate = wxPyBeginAllowThreads();
22302 {
22303 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
22304 result = (wxDateTime *) &_result_ref;
22305 }
22306
22307 wxPyEndAllowThreads(__tstate);
22308 if (PyErr_Occurred()) SWIG_fail;
22309 }
22310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22311 {
22312 if (temp2) delete arg2;
22313 }
22314 return resultobj;
22315 fail:
22316 {
22317 if (temp2) delete arg2;
22318 }
22319 return NULL;
22320 }
22321
22322
22323 static PyObject *_wrap_DateTime_FromTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
22324 PyObject *resultobj = NULL;
22325 wxDateTime *arg1 = (wxDateTime *) 0 ;
22326 wxDateTime::TimeZone *arg2 = 0 ;
22327 bool arg3 = (bool) false ;
22328 wxDateTime result;
22329 bool temp2 = false ;
22330 PyObject * obj0 = 0 ;
22331 PyObject * obj1 = 0 ;
22332 PyObject * obj2 = 0 ;
22333 char *kwnames[] = {
22334 (char *) "self",(char *) "tz",(char *) "noDST", NULL
22335 };
22336
22337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
22338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22339 if (SWIG_arg_fail(1)) SWIG_fail;
22340 {
22341 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22342 temp2 = true;
22343 }
22344 if (obj2) {
22345 {
22346 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
22347 if (SWIG_arg_fail(3)) SWIG_fail;
22348 }
22349 }
22350 {
22351 PyThreadState* __tstate = wxPyBeginAllowThreads();
22352 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
22353
22354 wxPyEndAllowThreads(__tstate);
22355 if (PyErr_Occurred()) SWIG_fail;
22356 }
22357 {
22358 wxDateTime * resultptr;
22359 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22360 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22361 }
22362 {
22363 if (temp2) delete arg2;
22364 }
22365 return resultobj;
22366 fail:
22367 {
22368 if (temp2) delete arg2;
22369 }
22370 return NULL;
22371 }
22372
22373
22374 static PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
22375 PyObject *resultobj = NULL;
22376 wxDateTime *arg1 = (wxDateTime *) 0 ;
22377 wxDateTime::TimeZone *arg2 = 0 ;
22378 bool arg3 = (bool) false ;
22379 wxDateTime *result;
22380 bool temp2 = false ;
22381 PyObject * obj0 = 0 ;
22382 PyObject * obj1 = 0 ;
22383 PyObject * obj2 = 0 ;
22384 char *kwnames[] = {
22385 (char *) "self",(char *) "tz",(char *) "noDST", NULL
22386 };
22387
22388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
22389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22390 if (SWIG_arg_fail(1)) SWIG_fail;
22391 {
22392 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22393 temp2 = true;
22394 }
22395 if (obj2) {
22396 {
22397 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
22398 if (SWIG_arg_fail(3)) SWIG_fail;
22399 }
22400 }
22401 {
22402 PyThreadState* __tstate = wxPyBeginAllowThreads();
22403 {
22404 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
22405 result = (wxDateTime *) &_result_ref;
22406 }
22407
22408 wxPyEndAllowThreads(__tstate);
22409 if (PyErr_Occurred()) SWIG_fail;
22410 }
22411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22412 {
22413 if (temp2) delete arg2;
22414 }
22415 return resultobj;
22416 fail:
22417 {
22418 if (temp2) delete arg2;
22419 }
22420 return NULL;
22421 }
22422
22423
22424 static PyObject *_wrap_DateTime_ToUTC(PyObject *, PyObject *args, PyObject *kwargs) {
22425 PyObject *resultobj = NULL;
22426 wxDateTime *arg1 = (wxDateTime *) 0 ;
22427 bool arg2 = (bool) false ;
22428 wxDateTime result;
22429 PyObject * obj0 = 0 ;
22430 PyObject * obj1 = 0 ;
22431 char *kwnames[] = {
22432 (char *) "self",(char *) "noDST", NULL
22433 };
22434
22435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) goto fail;
22436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22437 if (SWIG_arg_fail(1)) SWIG_fail;
22438 if (obj1) {
22439 {
22440 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22441 if (SWIG_arg_fail(2)) SWIG_fail;
22442 }
22443 }
22444 {
22445 PyThreadState* __tstate = wxPyBeginAllowThreads();
22446 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
22447
22448 wxPyEndAllowThreads(__tstate);
22449 if (PyErr_Occurred()) SWIG_fail;
22450 }
22451 {
22452 wxDateTime * resultptr;
22453 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22454 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22455 }
22456 return resultobj;
22457 fail:
22458 return NULL;
22459 }
22460
22461
22462 static PyObject *_wrap_DateTime_MakeUTC(PyObject *, PyObject *args, PyObject *kwargs) {
22463 PyObject *resultobj = NULL;
22464 wxDateTime *arg1 = (wxDateTime *) 0 ;
22465 bool arg2 = (bool) false ;
22466 wxDateTime *result;
22467 PyObject * obj0 = 0 ;
22468 PyObject * obj1 = 0 ;
22469 char *kwnames[] = {
22470 (char *) "self",(char *) "noDST", NULL
22471 };
22472
22473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) goto fail;
22474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22475 if (SWIG_arg_fail(1)) SWIG_fail;
22476 if (obj1) {
22477 {
22478 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22479 if (SWIG_arg_fail(2)) SWIG_fail;
22480 }
22481 }
22482 {
22483 PyThreadState* __tstate = wxPyBeginAllowThreads();
22484 {
22485 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
22486 result = (wxDateTime *) &_result_ref;
22487 }
22488
22489 wxPyEndAllowThreads(__tstate);
22490 if (PyErr_Occurred()) SWIG_fail;
22491 }
22492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22493 return resultobj;
22494 fail:
22495 return NULL;
22496 }
22497
22498
22499 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
22500 PyObject *resultobj = NULL;
22501 wxDateTime *arg1 = (wxDateTime *) 0 ;
22502 bool arg2 = (bool) false ;
22503 wxDateTime result;
22504 PyObject * obj0 = 0 ;
22505 PyObject * obj1 = 0 ;
22506 char *kwnames[] = {
22507 (char *) "self",(char *) "noDST", NULL
22508 };
22509
22510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
22511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22512 if (SWIG_arg_fail(1)) SWIG_fail;
22513 if (obj1) {
22514 {
22515 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22516 if (SWIG_arg_fail(2)) SWIG_fail;
22517 }
22518 }
22519 {
22520 PyThreadState* __tstate = wxPyBeginAllowThreads();
22521 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
22522
22523 wxPyEndAllowThreads(__tstate);
22524 if (PyErr_Occurred()) SWIG_fail;
22525 }
22526 {
22527 wxDateTime * resultptr;
22528 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22529 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22530 }
22531 return resultobj;
22532 fail:
22533 return NULL;
22534 }
22535
22536
22537 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
22538 PyObject *resultobj = NULL;
22539 wxDateTime *arg1 = (wxDateTime *) 0 ;
22540 bool arg2 = (bool) false ;
22541 wxDateTime *result;
22542 PyObject * obj0 = 0 ;
22543 PyObject * obj1 = 0 ;
22544 char *kwnames[] = {
22545 (char *) "self",(char *) "noDST", NULL
22546 };
22547
22548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
22549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22550 if (SWIG_arg_fail(1)) SWIG_fail;
22551 if (obj1) {
22552 {
22553 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22554 if (SWIG_arg_fail(2)) SWIG_fail;
22555 }
22556 }
22557 {
22558 PyThreadState* __tstate = wxPyBeginAllowThreads();
22559 {
22560 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
22561 result = (wxDateTime *) &_result_ref;
22562 }
22563
22564 wxPyEndAllowThreads(__tstate);
22565 if (PyErr_Occurred()) SWIG_fail;
22566 }
22567 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22568 return resultobj;
22569 fail:
22570 return NULL;
22571 }
22572
22573
22574 static PyObject *_wrap_DateTime_FromUTC(PyObject *, PyObject *args, PyObject *kwargs) {
22575 PyObject *resultobj = NULL;
22576 wxDateTime *arg1 = (wxDateTime *) 0 ;
22577 bool arg2 = (bool) false ;
22578 wxDateTime result;
22579 PyObject * obj0 = 0 ;
22580 PyObject * obj1 = 0 ;
22581 char *kwnames[] = {
22582 (char *) "self",(char *) "noDST", NULL
22583 };
22584
22585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) goto fail;
22586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22587 if (SWIG_arg_fail(1)) SWIG_fail;
22588 if (obj1) {
22589 {
22590 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22591 if (SWIG_arg_fail(2)) SWIG_fail;
22592 }
22593 }
22594 {
22595 PyThreadState* __tstate = wxPyBeginAllowThreads();
22596 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
22597
22598 wxPyEndAllowThreads(__tstate);
22599 if (PyErr_Occurred()) SWIG_fail;
22600 }
22601 {
22602 wxDateTime * resultptr;
22603 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22604 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22605 }
22606 return resultobj;
22607 fail:
22608 return NULL;
22609 }
22610
22611
22612 static PyObject *_wrap_DateTime_MakeFromUTC(PyObject *, PyObject *args, PyObject *kwargs) {
22613 PyObject *resultobj = NULL;
22614 wxDateTime *arg1 = (wxDateTime *) 0 ;
22615 bool arg2 = (bool) false ;
22616 wxDateTime *result;
22617 PyObject * obj0 = 0 ;
22618 PyObject * obj1 = 0 ;
22619 char *kwnames[] = {
22620 (char *) "self",(char *) "noDST", NULL
22621 };
22622
22623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) goto fail;
22624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22625 if (SWIG_arg_fail(1)) SWIG_fail;
22626 if (obj1) {
22627 {
22628 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22629 if (SWIG_arg_fail(2)) SWIG_fail;
22630 }
22631 }
22632 {
22633 PyThreadState* __tstate = wxPyBeginAllowThreads();
22634 {
22635 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
22636 result = (wxDateTime *) &_result_ref;
22637 }
22638
22639 wxPyEndAllowThreads(__tstate);
22640 if (PyErr_Occurred()) SWIG_fail;
22641 }
22642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22643 return resultobj;
22644 fail:
22645 return NULL;
22646 }
22647
22648
22649 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
22650 PyObject *resultobj = NULL;
22651 wxDateTime *arg1 = (wxDateTime *) 0 ;
22652 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22653 int result;
22654 PyObject * obj0 = 0 ;
22655 PyObject * obj1 = 0 ;
22656 char *kwnames[] = {
22657 (char *) "self",(char *) "country", NULL
22658 };
22659
22660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
22661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22662 if (SWIG_arg_fail(1)) SWIG_fail;
22663 if (obj1) {
22664 {
22665 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
22666 if (SWIG_arg_fail(2)) SWIG_fail;
22667 }
22668 }
22669 {
22670 PyThreadState* __tstate = wxPyBeginAllowThreads();
22671 result = (int)(arg1)->IsDST(arg2);
22672
22673 wxPyEndAllowThreads(__tstate);
22674 if (PyErr_Occurred()) SWIG_fail;
22675 }
22676 {
22677 resultobj = SWIG_From_int(static_cast<int >(result));
22678 }
22679 return resultobj;
22680 fail:
22681 return NULL;
22682 }
22683
22684
22685 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
22686 PyObject *resultobj = NULL;
22687 wxDateTime *arg1 = (wxDateTime *) 0 ;
22688 bool result;
22689 PyObject * obj0 = 0 ;
22690 char *kwnames[] = {
22691 (char *) "self", NULL
22692 };
22693
22694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
22695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22696 if (SWIG_arg_fail(1)) SWIG_fail;
22697 {
22698 PyThreadState* __tstate = wxPyBeginAllowThreads();
22699 result = (bool)((wxDateTime const *)arg1)->IsValid();
22700
22701 wxPyEndAllowThreads(__tstate);
22702 if (PyErr_Occurred()) SWIG_fail;
22703 }
22704 {
22705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22706 }
22707 return resultobj;
22708 fail:
22709 return NULL;
22710 }
22711
22712
22713 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
22714 PyObject *resultobj = NULL;
22715 wxDateTime *arg1 = (wxDateTime *) 0 ;
22716 time_t result;
22717 PyObject * obj0 = 0 ;
22718 char *kwnames[] = {
22719 (char *) "self", NULL
22720 };
22721
22722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
22723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22724 if (SWIG_arg_fail(1)) SWIG_fail;
22725 {
22726 PyThreadState* __tstate = wxPyBeginAllowThreads();
22727 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
22728
22729 wxPyEndAllowThreads(__tstate);
22730 if (PyErr_Occurred()) SWIG_fail;
22731 }
22732 {
22733 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
22734 }
22735 return resultobj;
22736 fail:
22737 return NULL;
22738 }
22739
22740
22741 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
22742 PyObject *resultobj = NULL;
22743 wxDateTime *arg1 = (wxDateTime *) 0 ;
22744 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22745 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22746 int result;
22747 bool temp2 = false ;
22748 PyObject * obj0 = 0 ;
22749 PyObject * obj1 = 0 ;
22750 char *kwnames[] = {
22751 (char *) "self",(char *) "tz", NULL
22752 };
22753
22754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
22755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22756 if (SWIG_arg_fail(1)) SWIG_fail;
22757 if (obj1) {
22758 {
22759 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22760 temp2 = true;
22761 }
22762 }
22763 {
22764 PyThreadState* __tstate = wxPyBeginAllowThreads();
22765 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
22766
22767 wxPyEndAllowThreads(__tstate);
22768 if (PyErr_Occurred()) SWIG_fail;
22769 }
22770 {
22771 resultobj = SWIG_From_int(static_cast<int >(result));
22772 }
22773 {
22774 if (temp2) delete arg2;
22775 }
22776 return resultobj;
22777 fail:
22778 {
22779 if (temp2) delete arg2;
22780 }
22781 return NULL;
22782 }
22783
22784
22785 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
22786 PyObject *resultobj = NULL;
22787 wxDateTime *arg1 = (wxDateTime *) 0 ;
22788 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22789 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22790 wxDateTime::Month result;
22791 bool temp2 = false ;
22792 PyObject * obj0 = 0 ;
22793 PyObject * obj1 = 0 ;
22794 char *kwnames[] = {
22795 (char *) "self",(char *) "tz", NULL
22796 };
22797
22798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
22799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22800 if (SWIG_arg_fail(1)) SWIG_fail;
22801 if (obj1) {
22802 {
22803 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22804 temp2 = true;
22805 }
22806 }
22807 {
22808 PyThreadState* __tstate = wxPyBeginAllowThreads();
22809 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
22810
22811 wxPyEndAllowThreads(__tstate);
22812 if (PyErr_Occurred()) SWIG_fail;
22813 }
22814 resultobj = SWIG_From_int((result));
22815 {
22816 if (temp2) delete arg2;
22817 }
22818 return resultobj;
22819 fail:
22820 {
22821 if (temp2) delete arg2;
22822 }
22823 return NULL;
22824 }
22825
22826
22827 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
22828 PyObject *resultobj = NULL;
22829 wxDateTime *arg1 = (wxDateTime *) 0 ;
22830 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22831 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22832 int result;
22833 bool temp2 = false ;
22834 PyObject * obj0 = 0 ;
22835 PyObject * obj1 = 0 ;
22836 char *kwnames[] = {
22837 (char *) "self",(char *) "tz", NULL
22838 };
22839
22840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
22841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22842 if (SWIG_arg_fail(1)) SWIG_fail;
22843 if (obj1) {
22844 {
22845 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22846 temp2 = true;
22847 }
22848 }
22849 {
22850 PyThreadState* __tstate = wxPyBeginAllowThreads();
22851 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
22852
22853 wxPyEndAllowThreads(__tstate);
22854 if (PyErr_Occurred()) SWIG_fail;
22855 }
22856 {
22857 resultobj = SWIG_From_int(static_cast<int >(result));
22858 }
22859 {
22860 if (temp2) delete arg2;
22861 }
22862 return resultobj;
22863 fail:
22864 {
22865 if (temp2) delete arg2;
22866 }
22867 return NULL;
22868 }
22869
22870
22871 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
22872 PyObject *resultobj = NULL;
22873 wxDateTime *arg1 = (wxDateTime *) 0 ;
22874 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22875 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22876 wxDateTime::WeekDay result;
22877 bool temp2 = false ;
22878 PyObject * obj0 = 0 ;
22879 PyObject * obj1 = 0 ;
22880 char *kwnames[] = {
22881 (char *) "self",(char *) "tz", NULL
22882 };
22883
22884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
22885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22886 if (SWIG_arg_fail(1)) SWIG_fail;
22887 if (obj1) {
22888 {
22889 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22890 temp2 = true;
22891 }
22892 }
22893 {
22894 PyThreadState* __tstate = wxPyBeginAllowThreads();
22895 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
22896
22897 wxPyEndAllowThreads(__tstate);
22898 if (PyErr_Occurred()) SWIG_fail;
22899 }
22900 resultobj = SWIG_From_int((result));
22901 {
22902 if (temp2) delete arg2;
22903 }
22904 return resultobj;
22905 fail:
22906 {
22907 if (temp2) delete arg2;
22908 }
22909 return NULL;
22910 }
22911
22912
22913 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
22914 PyObject *resultobj = NULL;
22915 wxDateTime *arg1 = (wxDateTime *) 0 ;
22916 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22917 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22918 int result;
22919 bool temp2 = false ;
22920 PyObject * obj0 = 0 ;
22921 PyObject * obj1 = 0 ;
22922 char *kwnames[] = {
22923 (char *) "self",(char *) "tz", NULL
22924 };
22925
22926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
22927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22928 if (SWIG_arg_fail(1)) SWIG_fail;
22929 if (obj1) {
22930 {
22931 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22932 temp2 = true;
22933 }
22934 }
22935 {
22936 PyThreadState* __tstate = wxPyBeginAllowThreads();
22937 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
22938
22939 wxPyEndAllowThreads(__tstate);
22940 if (PyErr_Occurred()) SWIG_fail;
22941 }
22942 {
22943 resultobj = SWIG_From_int(static_cast<int >(result));
22944 }
22945 {
22946 if (temp2) delete arg2;
22947 }
22948 return resultobj;
22949 fail:
22950 {
22951 if (temp2) delete arg2;
22952 }
22953 return NULL;
22954 }
22955
22956
22957 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
22958 PyObject *resultobj = NULL;
22959 wxDateTime *arg1 = (wxDateTime *) 0 ;
22960 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22961 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22962 int result;
22963 bool temp2 = false ;
22964 PyObject * obj0 = 0 ;
22965 PyObject * obj1 = 0 ;
22966 char *kwnames[] = {
22967 (char *) "self",(char *) "tz", NULL
22968 };
22969
22970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
22971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22972 if (SWIG_arg_fail(1)) SWIG_fail;
22973 if (obj1) {
22974 {
22975 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22976 temp2 = true;
22977 }
22978 }
22979 {
22980 PyThreadState* __tstate = wxPyBeginAllowThreads();
22981 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
22982
22983 wxPyEndAllowThreads(__tstate);
22984 if (PyErr_Occurred()) SWIG_fail;
22985 }
22986 {
22987 resultobj = SWIG_From_int(static_cast<int >(result));
22988 }
22989 {
22990 if (temp2) delete arg2;
22991 }
22992 return resultobj;
22993 fail:
22994 {
22995 if (temp2) delete arg2;
22996 }
22997 return NULL;
22998 }
22999
23000
23001 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
23002 PyObject *resultobj = NULL;
23003 wxDateTime *arg1 = (wxDateTime *) 0 ;
23004 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
23005 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
23006 int result;
23007 bool temp2 = false ;
23008 PyObject * obj0 = 0 ;
23009 PyObject * obj1 = 0 ;
23010 char *kwnames[] = {
23011 (char *) "self",(char *) "tz", NULL
23012 };
23013
23014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
23015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23016 if (SWIG_arg_fail(1)) SWIG_fail;
23017 if (obj1) {
23018 {
23019 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
23020 temp2 = true;
23021 }
23022 }
23023 {
23024 PyThreadState* __tstate = wxPyBeginAllowThreads();
23025 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
23026
23027 wxPyEndAllowThreads(__tstate);
23028 if (PyErr_Occurred()) SWIG_fail;
23029 }
23030 {
23031 resultobj = SWIG_From_int(static_cast<int >(result));
23032 }
23033 {
23034 if (temp2) delete arg2;
23035 }
23036 return resultobj;
23037 fail:
23038 {
23039 if (temp2) delete arg2;
23040 }
23041 return NULL;
23042 }
23043
23044
23045 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
23046 PyObject *resultobj = NULL;
23047 wxDateTime *arg1 = (wxDateTime *) 0 ;
23048 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
23049 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
23050 int result;
23051 bool temp2 = false ;
23052 PyObject * obj0 = 0 ;
23053 PyObject * obj1 = 0 ;
23054 char *kwnames[] = {
23055 (char *) "self",(char *) "tz", NULL
23056 };
23057
23058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
23059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23060 if (SWIG_arg_fail(1)) SWIG_fail;
23061 if (obj1) {
23062 {
23063 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
23064 temp2 = true;
23065 }
23066 }
23067 {
23068 PyThreadState* __tstate = wxPyBeginAllowThreads();
23069 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
23070
23071 wxPyEndAllowThreads(__tstate);
23072 if (PyErr_Occurred()) SWIG_fail;
23073 }
23074 {
23075 resultobj = SWIG_From_int(static_cast<int >(result));
23076 }
23077 {
23078 if (temp2) delete arg2;
23079 }
23080 return resultobj;
23081 fail:
23082 {
23083 if (temp2) delete arg2;
23084 }
23085 return NULL;
23086 }
23087
23088
23089 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
23090 PyObject *resultobj = NULL;
23091 wxDateTime *arg1 = (wxDateTime *) 0 ;
23092 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
23093 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
23094 int result;
23095 bool temp2 = false ;
23096 PyObject * obj0 = 0 ;
23097 PyObject * obj1 = 0 ;
23098 char *kwnames[] = {
23099 (char *) "self",(char *) "tz", NULL
23100 };
23101
23102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
23103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23104 if (SWIG_arg_fail(1)) SWIG_fail;
23105 if (obj1) {
23106 {
23107 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
23108 temp2 = true;
23109 }
23110 }
23111 {
23112 PyThreadState* __tstate = wxPyBeginAllowThreads();
23113 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
23114
23115 wxPyEndAllowThreads(__tstate);
23116 if (PyErr_Occurred()) SWIG_fail;
23117 }
23118 {
23119 resultobj = SWIG_From_int(static_cast<int >(result));
23120 }
23121 {
23122 if (temp2) delete arg2;
23123 }
23124 return resultobj;
23125 fail:
23126 {
23127 if (temp2) delete arg2;
23128 }
23129 return NULL;
23130 }
23131
23132
23133 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
23134 PyObject *resultobj = NULL;
23135 wxDateTime *arg1 = (wxDateTime *) 0 ;
23136 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23137 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23138 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23139 int result;
23140 bool temp3 = false ;
23141 PyObject * obj0 = 0 ;
23142 PyObject * obj1 = 0 ;
23143 PyObject * obj2 = 0 ;
23144 char *kwnames[] = {
23145 (char *) "self",(char *) "flags",(char *) "tz", NULL
23146 };
23147
23148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
23149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23150 if (SWIG_arg_fail(1)) SWIG_fail;
23151 if (obj1) {
23152 {
23153 arg2 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj1));
23154 if (SWIG_arg_fail(2)) SWIG_fail;
23155 }
23156 }
23157 if (obj2) {
23158 {
23159 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23160 temp3 = true;
23161 }
23162 }
23163 {
23164 PyThreadState* __tstate = wxPyBeginAllowThreads();
23165 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
23166
23167 wxPyEndAllowThreads(__tstate);
23168 if (PyErr_Occurred()) SWIG_fail;
23169 }
23170 {
23171 resultobj = SWIG_From_int(static_cast<int >(result));
23172 }
23173 {
23174 if (temp3) delete arg3;
23175 }
23176 return resultobj;
23177 fail:
23178 {
23179 if (temp3) delete arg3;
23180 }
23181 return NULL;
23182 }
23183
23184
23185 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
23186 PyObject *resultobj = NULL;
23187 wxDateTime *arg1 = (wxDateTime *) 0 ;
23188 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23189 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23190 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23191 int result;
23192 bool temp3 = false ;
23193 PyObject * obj0 = 0 ;
23194 PyObject * obj1 = 0 ;
23195 PyObject * obj2 = 0 ;
23196 char *kwnames[] = {
23197 (char *) "self",(char *) "flags",(char *) "tz", NULL
23198 };
23199
23200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
23201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23202 if (SWIG_arg_fail(1)) SWIG_fail;
23203 if (obj1) {
23204 {
23205 arg2 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj1));
23206 if (SWIG_arg_fail(2)) SWIG_fail;
23207 }
23208 }
23209 if (obj2) {
23210 {
23211 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23212 temp3 = true;
23213 }
23214 }
23215 {
23216 PyThreadState* __tstate = wxPyBeginAllowThreads();
23217 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
23218
23219 wxPyEndAllowThreads(__tstate);
23220 if (PyErr_Occurred()) SWIG_fail;
23221 }
23222 {
23223 resultobj = SWIG_From_int(static_cast<int >(result));
23224 }
23225 {
23226 if (temp3) delete arg3;
23227 }
23228 return resultobj;
23229 fail:
23230 {
23231 if (temp3) delete arg3;
23232 }
23233 return NULL;
23234 }
23235
23236
23237 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
23238 PyObject *resultobj = NULL;
23239 wxDateTime *arg1 = (wxDateTime *) 0 ;
23240 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23241 bool result;
23242 PyObject * obj0 = 0 ;
23243 PyObject * obj1 = 0 ;
23244 char *kwnames[] = {
23245 (char *) "self",(char *) "country", NULL
23246 };
23247
23248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
23249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23250 if (SWIG_arg_fail(1)) SWIG_fail;
23251 if (obj1) {
23252 {
23253 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
23254 if (SWIG_arg_fail(2)) SWIG_fail;
23255 }
23256 }
23257 {
23258 PyThreadState* __tstate = wxPyBeginAllowThreads();
23259 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
23260
23261 wxPyEndAllowThreads(__tstate);
23262 if (PyErr_Occurred()) SWIG_fail;
23263 }
23264 {
23265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23266 }
23267 return resultobj;
23268 fail:
23269 return NULL;
23270 }
23271
23272
23273 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
23274 PyObject *resultobj = NULL;
23275 wxDateTime *arg1 = (wxDateTime *) 0 ;
23276 wxDateTime *arg2 = 0 ;
23277 bool result;
23278 PyObject * obj0 = 0 ;
23279 PyObject * obj1 = 0 ;
23280 char *kwnames[] = {
23281 (char *) "self",(char *) "datetime", NULL
23282 };
23283
23284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
23285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23286 if (SWIG_arg_fail(1)) SWIG_fail;
23287 {
23288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23289 if (SWIG_arg_fail(2)) SWIG_fail;
23290 if (arg2 == NULL) {
23291 SWIG_null_ref("wxDateTime");
23292 }
23293 if (SWIG_arg_fail(2)) SWIG_fail;
23294 }
23295 {
23296 PyThreadState* __tstate = wxPyBeginAllowThreads();
23297 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
23298
23299 wxPyEndAllowThreads(__tstate);
23300 if (PyErr_Occurred()) SWIG_fail;
23301 }
23302 {
23303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23304 }
23305 return resultobj;
23306 fail:
23307 return NULL;
23308 }
23309
23310
23311 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
23312 PyObject *resultobj = NULL;
23313 wxDateTime *arg1 = (wxDateTime *) 0 ;
23314 wxDateTime *arg2 = 0 ;
23315 bool result;
23316 PyObject * obj0 = 0 ;
23317 PyObject * obj1 = 0 ;
23318 char *kwnames[] = {
23319 (char *) "self",(char *) "datetime", NULL
23320 };
23321
23322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
23323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23324 if (SWIG_arg_fail(1)) SWIG_fail;
23325 {
23326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23327 if (SWIG_arg_fail(2)) SWIG_fail;
23328 if (arg2 == NULL) {
23329 SWIG_null_ref("wxDateTime");
23330 }
23331 if (SWIG_arg_fail(2)) SWIG_fail;
23332 }
23333 {
23334 PyThreadState* __tstate = wxPyBeginAllowThreads();
23335 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
23336
23337 wxPyEndAllowThreads(__tstate);
23338 if (PyErr_Occurred()) SWIG_fail;
23339 }
23340 {
23341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23342 }
23343 return resultobj;
23344 fail:
23345 return NULL;
23346 }
23347
23348
23349 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
23350 PyObject *resultobj = NULL;
23351 wxDateTime *arg1 = (wxDateTime *) 0 ;
23352 wxDateTime *arg2 = 0 ;
23353 bool result;
23354 PyObject * obj0 = 0 ;
23355 PyObject * obj1 = 0 ;
23356 char *kwnames[] = {
23357 (char *) "self",(char *) "datetime", NULL
23358 };
23359
23360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
23361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23362 if (SWIG_arg_fail(1)) SWIG_fail;
23363 {
23364 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23365 if (SWIG_arg_fail(2)) SWIG_fail;
23366 if (arg2 == NULL) {
23367 SWIG_null_ref("wxDateTime");
23368 }
23369 if (SWIG_arg_fail(2)) SWIG_fail;
23370 }
23371 {
23372 PyThreadState* __tstate = wxPyBeginAllowThreads();
23373 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
23374
23375 wxPyEndAllowThreads(__tstate);
23376 if (PyErr_Occurred()) SWIG_fail;
23377 }
23378 {
23379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23380 }
23381 return resultobj;
23382 fail:
23383 return NULL;
23384 }
23385
23386
23387 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
23388 PyObject *resultobj = NULL;
23389 wxDateTime *arg1 = (wxDateTime *) 0 ;
23390 wxDateTime *arg2 = 0 ;
23391 wxDateTime *arg3 = 0 ;
23392 bool result;
23393 PyObject * obj0 = 0 ;
23394 PyObject * obj1 = 0 ;
23395 PyObject * obj2 = 0 ;
23396 char *kwnames[] = {
23397 (char *) "self",(char *) "t1",(char *) "t2", NULL
23398 };
23399
23400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
23401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23402 if (SWIG_arg_fail(1)) SWIG_fail;
23403 {
23404 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23405 if (SWIG_arg_fail(2)) SWIG_fail;
23406 if (arg2 == NULL) {
23407 SWIG_null_ref("wxDateTime");
23408 }
23409 if (SWIG_arg_fail(2)) SWIG_fail;
23410 }
23411 {
23412 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23413 if (SWIG_arg_fail(3)) SWIG_fail;
23414 if (arg3 == NULL) {
23415 SWIG_null_ref("wxDateTime");
23416 }
23417 if (SWIG_arg_fail(3)) SWIG_fail;
23418 }
23419 {
23420 PyThreadState* __tstate = wxPyBeginAllowThreads();
23421 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
23422
23423 wxPyEndAllowThreads(__tstate);
23424 if (PyErr_Occurred()) SWIG_fail;
23425 }
23426 {
23427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23428 }
23429 return resultobj;
23430 fail:
23431 return NULL;
23432 }
23433
23434
23435 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
23436 PyObject *resultobj = NULL;
23437 wxDateTime *arg1 = (wxDateTime *) 0 ;
23438 wxDateTime *arg2 = 0 ;
23439 wxDateTime *arg3 = 0 ;
23440 bool result;
23441 PyObject * obj0 = 0 ;
23442 PyObject * obj1 = 0 ;
23443 PyObject * obj2 = 0 ;
23444 char *kwnames[] = {
23445 (char *) "self",(char *) "t1",(char *) "t2", NULL
23446 };
23447
23448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
23449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23450 if (SWIG_arg_fail(1)) SWIG_fail;
23451 {
23452 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23453 if (SWIG_arg_fail(2)) SWIG_fail;
23454 if (arg2 == NULL) {
23455 SWIG_null_ref("wxDateTime");
23456 }
23457 if (SWIG_arg_fail(2)) SWIG_fail;
23458 }
23459 {
23460 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23461 if (SWIG_arg_fail(3)) SWIG_fail;
23462 if (arg3 == NULL) {
23463 SWIG_null_ref("wxDateTime");
23464 }
23465 if (SWIG_arg_fail(3)) SWIG_fail;
23466 }
23467 {
23468 PyThreadState* __tstate = wxPyBeginAllowThreads();
23469 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
23470
23471 wxPyEndAllowThreads(__tstate);
23472 if (PyErr_Occurred()) SWIG_fail;
23473 }
23474 {
23475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23476 }
23477 return resultobj;
23478 fail:
23479 return NULL;
23480 }
23481
23482
23483 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
23484 PyObject *resultobj = NULL;
23485 wxDateTime *arg1 = (wxDateTime *) 0 ;
23486 wxDateTime *arg2 = 0 ;
23487 bool result;
23488 PyObject * obj0 = 0 ;
23489 PyObject * obj1 = 0 ;
23490 char *kwnames[] = {
23491 (char *) "self",(char *) "dt", NULL
23492 };
23493
23494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
23495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23496 if (SWIG_arg_fail(1)) SWIG_fail;
23497 {
23498 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23499 if (SWIG_arg_fail(2)) SWIG_fail;
23500 if (arg2 == NULL) {
23501 SWIG_null_ref("wxDateTime");
23502 }
23503 if (SWIG_arg_fail(2)) SWIG_fail;
23504 }
23505 {
23506 PyThreadState* __tstate = wxPyBeginAllowThreads();
23507 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
23508
23509 wxPyEndAllowThreads(__tstate);
23510 if (PyErr_Occurred()) SWIG_fail;
23511 }
23512 {
23513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23514 }
23515 return resultobj;
23516 fail:
23517 return NULL;
23518 }
23519
23520
23521 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
23522 PyObject *resultobj = NULL;
23523 wxDateTime *arg1 = (wxDateTime *) 0 ;
23524 wxDateTime *arg2 = 0 ;
23525 bool result;
23526 PyObject * obj0 = 0 ;
23527 PyObject * obj1 = 0 ;
23528 char *kwnames[] = {
23529 (char *) "self",(char *) "dt", NULL
23530 };
23531
23532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
23533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23534 if (SWIG_arg_fail(1)) SWIG_fail;
23535 {
23536 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23537 if (SWIG_arg_fail(2)) SWIG_fail;
23538 if (arg2 == NULL) {
23539 SWIG_null_ref("wxDateTime");
23540 }
23541 if (SWIG_arg_fail(2)) SWIG_fail;
23542 }
23543 {
23544 PyThreadState* __tstate = wxPyBeginAllowThreads();
23545 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
23546
23547 wxPyEndAllowThreads(__tstate);
23548 if (PyErr_Occurred()) SWIG_fail;
23549 }
23550 {
23551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23552 }
23553 return resultobj;
23554 fail:
23555 return NULL;
23556 }
23557
23558
23559 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
23560 PyObject *resultobj = NULL;
23561 wxDateTime *arg1 = (wxDateTime *) 0 ;
23562 wxDateTime *arg2 = 0 ;
23563 wxTimeSpan *arg3 = 0 ;
23564 bool result;
23565 PyObject * obj0 = 0 ;
23566 PyObject * obj1 = 0 ;
23567 PyObject * obj2 = 0 ;
23568 char *kwnames[] = {
23569 (char *) "self",(char *) "dt",(char *) "ts", NULL
23570 };
23571
23572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
23573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23574 if (SWIG_arg_fail(1)) SWIG_fail;
23575 {
23576 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23577 if (SWIG_arg_fail(2)) SWIG_fail;
23578 if (arg2 == NULL) {
23579 SWIG_null_ref("wxDateTime");
23580 }
23581 if (SWIG_arg_fail(2)) SWIG_fail;
23582 }
23583 {
23584 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23585 if (SWIG_arg_fail(3)) SWIG_fail;
23586 if (arg3 == NULL) {
23587 SWIG_null_ref("wxTimeSpan");
23588 }
23589 if (SWIG_arg_fail(3)) SWIG_fail;
23590 }
23591 {
23592 PyThreadState* __tstate = wxPyBeginAllowThreads();
23593 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
23594
23595 wxPyEndAllowThreads(__tstate);
23596 if (PyErr_Occurred()) SWIG_fail;
23597 }
23598 {
23599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23600 }
23601 return resultobj;
23602 fail:
23603 return NULL;
23604 }
23605
23606
23607 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
23608 PyObject *resultobj = NULL;
23609 wxDateTime *arg1 = (wxDateTime *) 0 ;
23610 wxTimeSpan *arg2 = 0 ;
23611 wxDateTime *result;
23612 PyObject * obj0 = 0 ;
23613 PyObject * obj1 = 0 ;
23614 char *kwnames[] = {
23615 (char *) "self",(char *) "diff", NULL
23616 };
23617
23618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
23619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23620 if (SWIG_arg_fail(1)) SWIG_fail;
23621 {
23622 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23623 if (SWIG_arg_fail(2)) SWIG_fail;
23624 if (arg2 == NULL) {
23625 SWIG_null_ref("wxTimeSpan");
23626 }
23627 if (SWIG_arg_fail(2)) SWIG_fail;
23628 }
23629 {
23630 PyThreadState* __tstate = wxPyBeginAllowThreads();
23631 {
23632 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
23633 result = (wxDateTime *) &_result_ref;
23634 }
23635
23636 wxPyEndAllowThreads(__tstate);
23637 if (PyErr_Occurred()) SWIG_fail;
23638 }
23639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23640 return resultobj;
23641 fail:
23642 return NULL;
23643 }
23644
23645
23646 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
23647 PyObject *resultobj = NULL;
23648 wxDateTime *arg1 = (wxDateTime *) 0 ;
23649 wxDateSpan *arg2 = 0 ;
23650 wxDateTime *result;
23651 PyObject * obj0 = 0 ;
23652 PyObject * obj1 = 0 ;
23653 char *kwnames[] = {
23654 (char *) "self",(char *) "diff", NULL
23655 };
23656
23657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
23658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23659 if (SWIG_arg_fail(1)) SWIG_fail;
23660 {
23661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23662 if (SWIG_arg_fail(2)) SWIG_fail;
23663 if (arg2 == NULL) {
23664 SWIG_null_ref("wxDateSpan");
23665 }
23666 if (SWIG_arg_fail(2)) SWIG_fail;
23667 }
23668 {
23669 PyThreadState* __tstate = wxPyBeginAllowThreads();
23670 {
23671 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
23672 result = (wxDateTime *) &_result_ref;
23673 }
23674
23675 wxPyEndAllowThreads(__tstate);
23676 if (PyErr_Occurred()) SWIG_fail;
23677 }
23678 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23679 return resultobj;
23680 fail:
23681 return NULL;
23682 }
23683
23684
23685 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
23686 PyObject *resultobj = NULL;
23687 wxDateTime *arg1 = (wxDateTime *) 0 ;
23688 wxTimeSpan *arg2 = 0 ;
23689 wxDateTime *result;
23690 PyObject * obj0 = 0 ;
23691 PyObject * obj1 = 0 ;
23692 char *kwnames[] = {
23693 (char *) "self",(char *) "diff", NULL
23694 };
23695
23696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
23697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23698 if (SWIG_arg_fail(1)) SWIG_fail;
23699 {
23700 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23701 if (SWIG_arg_fail(2)) SWIG_fail;
23702 if (arg2 == NULL) {
23703 SWIG_null_ref("wxTimeSpan");
23704 }
23705 if (SWIG_arg_fail(2)) SWIG_fail;
23706 }
23707 {
23708 PyThreadState* __tstate = wxPyBeginAllowThreads();
23709 {
23710 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
23711 result = (wxDateTime *) &_result_ref;
23712 }
23713
23714 wxPyEndAllowThreads(__tstate);
23715 if (PyErr_Occurred()) SWIG_fail;
23716 }
23717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23718 return resultobj;
23719 fail:
23720 return NULL;
23721 }
23722
23723
23724 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
23725 PyObject *resultobj = NULL;
23726 wxDateTime *arg1 = (wxDateTime *) 0 ;
23727 wxDateSpan *arg2 = 0 ;
23728 wxDateTime *result;
23729 PyObject * obj0 = 0 ;
23730 PyObject * obj1 = 0 ;
23731 char *kwnames[] = {
23732 (char *) "self",(char *) "diff", NULL
23733 };
23734
23735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
23736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23737 if (SWIG_arg_fail(1)) SWIG_fail;
23738 {
23739 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23740 if (SWIG_arg_fail(2)) SWIG_fail;
23741 if (arg2 == NULL) {
23742 SWIG_null_ref("wxDateSpan");
23743 }
23744 if (SWIG_arg_fail(2)) SWIG_fail;
23745 }
23746 {
23747 PyThreadState* __tstate = wxPyBeginAllowThreads();
23748 {
23749 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
23750 result = (wxDateTime *) &_result_ref;
23751 }
23752
23753 wxPyEndAllowThreads(__tstate);
23754 if (PyErr_Occurred()) SWIG_fail;
23755 }
23756 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23757 return resultobj;
23758 fail:
23759 return NULL;
23760 }
23761
23762
23763 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
23764 PyObject *resultobj = NULL;
23765 wxDateTime *arg1 = (wxDateTime *) 0 ;
23766 wxDateTime *arg2 = 0 ;
23767 wxTimeSpan result;
23768 PyObject * obj0 = 0 ;
23769 PyObject * obj1 = 0 ;
23770 char *kwnames[] = {
23771 (char *) "self",(char *) "dt", NULL
23772 };
23773
23774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
23775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23776 if (SWIG_arg_fail(1)) SWIG_fail;
23777 {
23778 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23779 if (SWIG_arg_fail(2)) SWIG_fail;
23780 if (arg2 == NULL) {
23781 SWIG_null_ref("wxDateTime");
23782 }
23783 if (SWIG_arg_fail(2)) SWIG_fail;
23784 }
23785 {
23786 PyThreadState* __tstate = wxPyBeginAllowThreads();
23787 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
23788
23789 wxPyEndAllowThreads(__tstate);
23790 if (PyErr_Occurred()) SWIG_fail;
23791 }
23792 {
23793 wxTimeSpan * resultptr;
23794 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
23795 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23796 }
23797 return resultobj;
23798 fail:
23799 return NULL;
23800 }
23801
23802
23803 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
23804 PyObject *resultobj = NULL;
23805 wxDateTime *arg1 = (wxDateTime *) 0 ;
23806 wxTimeSpan *arg2 = 0 ;
23807 wxDateTime *result;
23808 PyObject * obj0 = 0 ;
23809 PyObject * obj1 = 0 ;
23810
23811 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
23812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23813 if (SWIG_arg_fail(1)) SWIG_fail;
23814 {
23815 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23816 if (SWIG_arg_fail(2)) SWIG_fail;
23817 if (arg2 == NULL) {
23818 SWIG_null_ref("wxTimeSpan");
23819 }
23820 if (SWIG_arg_fail(2)) SWIG_fail;
23821 }
23822 {
23823 PyThreadState* __tstate = wxPyBeginAllowThreads();
23824 {
23825 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
23826 result = (wxDateTime *) &_result_ref;
23827 }
23828
23829 wxPyEndAllowThreads(__tstate);
23830 if (PyErr_Occurred()) SWIG_fail;
23831 }
23832 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
23833 return resultobj;
23834 fail:
23835 return NULL;
23836 }
23837
23838
23839 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
23840 PyObject *resultobj = NULL;
23841 wxDateTime *arg1 = (wxDateTime *) 0 ;
23842 wxDateSpan *arg2 = 0 ;
23843 wxDateTime *result;
23844 PyObject * obj0 = 0 ;
23845 PyObject * obj1 = 0 ;
23846
23847 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
23848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23849 if (SWIG_arg_fail(1)) SWIG_fail;
23850 {
23851 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23852 if (SWIG_arg_fail(2)) SWIG_fail;
23853 if (arg2 == NULL) {
23854 SWIG_null_ref("wxDateSpan");
23855 }
23856 if (SWIG_arg_fail(2)) SWIG_fail;
23857 }
23858 {
23859 PyThreadState* __tstate = wxPyBeginAllowThreads();
23860 {
23861 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
23862 result = (wxDateTime *) &_result_ref;
23863 }
23864
23865 wxPyEndAllowThreads(__tstate);
23866 if (PyErr_Occurred()) SWIG_fail;
23867 }
23868 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
23869 return resultobj;
23870 fail:
23871 return NULL;
23872 }
23873
23874
23875 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
23876 int argc;
23877 PyObject *argv[3];
23878 int ii;
23879
23880 argc = PyObject_Length(args);
23881 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23882 argv[ii] = PyTuple_GetItem(args,ii);
23883 }
23884 if (argc == 2) {
23885 int _v;
23886 {
23887 void *ptr;
23888 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23889 _v = 0;
23890 PyErr_Clear();
23891 } else {
23892 _v = 1;
23893 }
23894 }
23895 if (_v) {
23896 {
23897 void *ptr = 0;
23898 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23899 _v = 0;
23900 PyErr_Clear();
23901 } else {
23902 _v = (ptr != 0);
23903 }
23904 }
23905 if (_v) {
23906 return _wrap_DateTime___iadd____SWIG_0(self,args);
23907 }
23908 }
23909 }
23910 if (argc == 2) {
23911 int _v;
23912 {
23913 void *ptr;
23914 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23915 _v = 0;
23916 PyErr_Clear();
23917 } else {
23918 _v = 1;
23919 }
23920 }
23921 if (_v) {
23922 {
23923 void *ptr = 0;
23924 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23925 _v = 0;
23926 PyErr_Clear();
23927 } else {
23928 _v = (ptr != 0);
23929 }
23930 }
23931 if (_v) {
23932 return _wrap_DateTime___iadd____SWIG_1(self,args);
23933 }
23934 }
23935 }
23936
23937 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
23938 return NULL;
23939 }
23940
23941
23942 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
23943 PyObject *resultobj = NULL;
23944 wxDateTime *arg1 = (wxDateTime *) 0 ;
23945 wxTimeSpan *arg2 = 0 ;
23946 wxDateTime *result;
23947 PyObject * obj0 = 0 ;
23948 PyObject * obj1 = 0 ;
23949
23950 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
23951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23952 if (SWIG_arg_fail(1)) SWIG_fail;
23953 {
23954 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23955 if (SWIG_arg_fail(2)) SWIG_fail;
23956 if (arg2 == NULL) {
23957 SWIG_null_ref("wxTimeSpan");
23958 }
23959 if (SWIG_arg_fail(2)) SWIG_fail;
23960 }
23961 {
23962 PyThreadState* __tstate = wxPyBeginAllowThreads();
23963 {
23964 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
23965 result = (wxDateTime *) &_result_ref;
23966 }
23967
23968 wxPyEndAllowThreads(__tstate);
23969 if (PyErr_Occurred()) SWIG_fail;
23970 }
23971 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
23972 return resultobj;
23973 fail:
23974 return NULL;
23975 }
23976
23977
23978 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
23979 PyObject *resultobj = NULL;
23980 wxDateTime *arg1 = (wxDateTime *) 0 ;
23981 wxDateSpan *arg2 = 0 ;
23982 wxDateTime *result;
23983 PyObject * obj0 = 0 ;
23984 PyObject * obj1 = 0 ;
23985
23986 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
23987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23988 if (SWIG_arg_fail(1)) SWIG_fail;
23989 {
23990 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23991 if (SWIG_arg_fail(2)) SWIG_fail;
23992 if (arg2 == NULL) {
23993 SWIG_null_ref("wxDateSpan");
23994 }
23995 if (SWIG_arg_fail(2)) SWIG_fail;
23996 }
23997 {
23998 PyThreadState* __tstate = wxPyBeginAllowThreads();
23999 {
24000 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
24001 result = (wxDateTime *) &_result_ref;
24002 }
24003
24004 wxPyEndAllowThreads(__tstate);
24005 if (PyErr_Occurred()) SWIG_fail;
24006 }
24007 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
24008 return resultobj;
24009 fail:
24010 return NULL;
24011 }
24012
24013
24014 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
24015 int argc;
24016 PyObject *argv[3];
24017 int ii;
24018
24019 argc = PyObject_Length(args);
24020 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
24021 argv[ii] = PyTuple_GetItem(args,ii);
24022 }
24023 if (argc == 2) {
24024 int _v;
24025 {
24026 void *ptr;
24027 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24028 _v = 0;
24029 PyErr_Clear();
24030 } else {
24031 _v = 1;
24032 }
24033 }
24034 if (_v) {
24035 {
24036 void *ptr = 0;
24037 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
24038 _v = 0;
24039 PyErr_Clear();
24040 } else {
24041 _v = (ptr != 0);
24042 }
24043 }
24044 if (_v) {
24045 return _wrap_DateTime___isub____SWIG_0(self,args);
24046 }
24047 }
24048 }
24049 if (argc == 2) {
24050 int _v;
24051 {
24052 void *ptr;
24053 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24054 _v = 0;
24055 PyErr_Clear();
24056 } else {
24057 _v = 1;
24058 }
24059 }
24060 if (_v) {
24061 {
24062 void *ptr = 0;
24063 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
24064 _v = 0;
24065 PyErr_Clear();
24066 } else {
24067 _v = (ptr != 0);
24068 }
24069 }
24070 if (_v) {
24071 return _wrap_DateTime___isub____SWIG_1(self,args);
24072 }
24073 }
24074 }
24075
24076 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
24077 return NULL;
24078 }
24079
24080
24081 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
24082 PyObject *resultobj = NULL;
24083 wxDateTime *arg1 = (wxDateTime *) 0 ;
24084 wxTimeSpan *arg2 = 0 ;
24085 wxDateTime result;
24086 PyObject * obj0 = 0 ;
24087 PyObject * obj1 = 0 ;
24088
24089 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
24090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24091 if (SWIG_arg_fail(1)) SWIG_fail;
24092 {
24093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24094 if (SWIG_arg_fail(2)) SWIG_fail;
24095 if (arg2 == NULL) {
24096 SWIG_null_ref("wxTimeSpan");
24097 }
24098 if (SWIG_arg_fail(2)) SWIG_fail;
24099 }
24100 {
24101 PyThreadState* __tstate = wxPyBeginAllowThreads();
24102 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
24103
24104 wxPyEndAllowThreads(__tstate);
24105 if (PyErr_Occurred()) SWIG_fail;
24106 }
24107 {
24108 wxDateTime * resultptr;
24109 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
24110 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
24111 }
24112 return resultobj;
24113 fail:
24114 return NULL;
24115 }
24116
24117
24118 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
24119 PyObject *resultobj = NULL;
24120 wxDateTime *arg1 = (wxDateTime *) 0 ;
24121 wxDateSpan *arg2 = 0 ;
24122 wxDateTime result;
24123 PyObject * obj0 = 0 ;
24124 PyObject * obj1 = 0 ;
24125
24126 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
24127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24128 if (SWIG_arg_fail(1)) SWIG_fail;
24129 {
24130 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
24131 if (SWIG_arg_fail(2)) SWIG_fail;
24132 if (arg2 == NULL) {
24133 SWIG_null_ref("wxDateSpan");
24134 }
24135 if (SWIG_arg_fail(2)) SWIG_fail;
24136 }
24137 {
24138 PyThreadState* __tstate = wxPyBeginAllowThreads();
24139 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
24140
24141 wxPyEndAllowThreads(__tstate);
24142 if (PyErr_Occurred()) SWIG_fail;
24143 }
24144 {
24145 wxDateTime * resultptr;
24146 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
24147 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
24148 }
24149 return resultobj;
24150 fail:
24151 return NULL;
24152 }
24153
24154
24155 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
24156 int argc;
24157 PyObject *argv[3];
24158 int ii;
24159
24160 argc = PyObject_Length(args);
24161 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
24162 argv[ii] = PyTuple_GetItem(args,ii);
24163 }
24164 if (argc == 2) {
24165 int _v;
24166 {
24167 void *ptr;
24168 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24169 _v = 0;
24170 PyErr_Clear();
24171 } else {
24172 _v = 1;
24173 }
24174 }
24175 if (_v) {
24176 {
24177 void *ptr = 0;
24178 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
24179 _v = 0;
24180 PyErr_Clear();
24181 } else {
24182 _v = (ptr != 0);
24183 }
24184 }
24185 if (_v) {
24186 return _wrap_DateTime___add____SWIG_0(self,args);
24187 }
24188 }
24189 }
24190 if (argc == 2) {
24191 int _v;
24192 {
24193 void *ptr;
24194 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24195 _v = 0;
24196 PyErr_Clear();
24197 } else {
24198 _v = 1;
24199 }
24200 }
24201 if (_v) {
24202 {
24203 void *ptr = 0;
24204 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
24205 _v = 0;
24206 PyErr_Clear();
24207 } else {
24208 _v = (ptr != 0);
24209 }
24210 }
24211 if (_v) {
24212 return _wrap_DateTime___add____SWIG_1(self,args);
24213 }
24214 }
24215 }
24216
24217 Py_INCREF(Py_NotImplemented);
24218 return Py_NotImplemented;
24219 }
24220
24221
24222 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
24223 PyObject *resultobj = NULL;
24224 wxDateTime *arg1 = (wxDateTime *) 0 ;
24225 wxDateTime *arg2 = 0 ;
24226 wxTimeSpan result;
24227 PyObject * obj0 = 0 ;
24228 PyObject * obj1 = 0 ;
24229
24230 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
24231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24232 if (SWIG_arg_fail(1)) SWIG_fail;
24233 {
24234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24235 if (SWIG_arg_fail(2)) SWIG_fail;
24236 if (arg2 == NULL) {
24237 SWIG_null_ref("wxDateTime");
24238 }
24239 if (SWIG_arg_fail(2)) SWIG_fail;
24240 }
24241 {
24242 PyThreadState* __tstate = wxPyBeginAllowThreads();
24243 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
24244
24245 wxPyEndAllowThreads(__tstate);
24246 if (PyErr_Occurred()) SWIG_fail;
24247 }
24248 {
24249 wxTimeSpan * resultptr;
24250 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
24251 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24252 }
24253 return resultobj;
24254 fail:
24255 return NULL;
24256 }
24257
24258
24259 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
24260 PyObject *resultobj = NULL;
24261 wxDateTime *arg1 = (wxDateTime *) 0 ;
24262 wxTimeSpan *arg2 = 0 ;
24263 wxDateTime result;
24264 PyObject * obj0 = 0 ;
24265 PyObject * obj1 = 0 ;
24266
24267 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
24268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24269 if (SWIG_arg_fail(1)) SWIG_fail;
24270 {
24271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24272 if (SWIG_arg_fail(2)) SWIG_fail;
24273 if (arg2 == NULL) {
24274 SWIG_null_ref("wxTimeSpan");
24275 }
24276 if (SWIG_arg_fail(2)) SWIG_fail;
24277 }
24278 {
24279 PyThreadState* __tstate = wxPyBeginAllowThreads();
24280 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
24281
24282 wxPyEndAllowThreads(__tstate);
24283 if (PyErr_Occurred()) SWIG_fail;
24284 }
24285 {
24286 wxDateTime * resultptr;
24287 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
24288 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
24289 }
24290 return resultobj;
24291 fail:
24292 return NULL;
24293 }
24294
24295
24296 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
24297 PyObject *resultobj = NULL;
24298 wxDateTime *arg1 = (wxDateTime *) 0 ;
24299 wxDateSpan *arg2 = 0 ;
24300 wxDateTime result;
24301 PyObject * obj0 = 0 ;
24302 PyObject * obj1 = 0 ;
24303
24304 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
24305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24306 if (SWIG_arg_fail(1)) SWIG_fail;
24307 {
24308 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
24309 if (SWIG_arg_fail(2)) SWIG_fail;
24310 if (arg2 == NULL) {
24311 SWIG_null_ref("wxDateSpan");
24312 }
24313 if (SWIG_arg_fail(2)) SWIG_fail;
24314 }
24315 {
24316 PyThreadState* __tstate = wxPyBeginAllowThreads();
24317 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
24318
24319 wxPyEndAllowThreads(__tstate);
24320 if (PyErr_Occurred()) SWIG_fail;
24321 }
24322 {
24323 wxDateTime * resultptr;
24324 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
24325 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
24326 }
24327 return resultobj;
24328 fail:
24329 return NULL;
24330 }
24331
24332
24333 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
24334 int argc;
24335 PyObject *argv[3];
24336 int ii;
24337
24338 argc = PyObject_Length(args);
24339 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
24340 argv[ii] = PyTuple_GetItem(args,ii);
24341 }
24342 if (argc == 2) {
24343 int _v;
24344 {
24345 void *ptr;
24346 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24347 _v = 0;
24348 PyErr_Clear();
24349 } else {
24350 _v = 1;
24351 }
24352 }
24353 if (_v) {
24354 {
24355 void *ptr = 0;
24356 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24357 _v = 0;
24358 PyErr_Clear();
24359 } else {
24360 _v = (ptr != 0);
24361 }
24362 }
24363 if (_v) {
24364 return _wrap_DateTime___sub____SWIG_0(self,args);
24365 }
24366 }
24367 }
24368 if (argc == 2) {
24369 int _v;
24370 {
24371 void *ptr;
24372 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24373 _v = 0;
24374 PyErr_Clear();
24375 } else {
24376 _v = 1;
24377 }
24378 }
24379 if (_v) {
24380 {
24381 void *ptr = 0;
24382 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
24383 _v = 0;
24384 PyErr_Clear();
24385 } else {
24386 _v = (ptr != 0);
24387 }
24388 }
24389 if (_v) {
24390 return _wrap_DateTime___sub____SWIG_1(self,args);
24391 }
24392 }
24393 }
24394 if (argc == 2) {
24395 int _v;
24396 {
24397 void *ptr;
24398 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24399 _v = 0;
24400 PyErr_Clear();
24401 } else {
24402 _v = 1;
24403 }
24404 }
24405 if (_v) {
24406 {
24407 void *ptr = 0;
24408 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
24409 _v = 0;
24410 PyErr_Clear();
24411 } else {
24412 _v = (ptr != 0);
24413 }
24414 }
24415 if (_v) {
24416 return _wrap_DateTime___sub____SWIG_2(self,args);
24417 }
24418 }
24419 }
24420
24421 Py_INCREF(Py_NotImplemented);
24422 return Py_NotImplemented;
24423 }
24424
24425
24426 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24427 PyObject *resultobj = NULL;
24428 wxDateTime *arg1 = (wxDateTime *) 0 ;
24429 wxDateTime *arg2 = (wxDateTime *) 0 ;
24430 bool result;
24431 PyObject * obj0 = 0 ;
24432 PyObject * obj1 = 0 ;
24433 char *kwnames[] = {
24434 (char *) "self",(char *) "other", NULL
24435 };
24436
24437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
24438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24439 if (SWIG_arg_fail(1)) SWIG_fail;
24440 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24441 if (SWIG_arg_fail(2)) SWIG_fail;
24442 {
24443 PyThreadState* __tstate = wxPyBeginAllowThreads();
24444 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
24445
24446 wxPyEndAllowThreads(__tstate);
24447 if (PyErr_Occurred()) SWIG_fail;
24448 }
24449 {
24450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24451 }
24452 return resultobj;
24453 fail:
24454 return NULL;
24455 }
24456
24457
24458 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24459 PyObject *resultobj = NULL;
24460 wxDateTime *arg1 = (wxDateTime *) 0 ;
24461 wxDateTime *arg2 = (wxDateTime *) 0 ;
24462 bool result;
24463 PyObject * obj0 = 0 ;
24464 PyObject * obj1 = 0 ;
24465 char *kwnames[] = {
24466 (char *) "self",(char *) "other", NULL
24467 };
24468
24469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
24470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24471 if (SWIG_arg_fail(1)) SWIG_fail;
24472 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24473 if (SWIG_arg_fail(2)) SWIG_fail;
24474 {
24475 PyThreadState* __tstate = wxPyBeginAllowThreads();
24476 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
24477
24478 wxPyEndAllowThreads(__tstate);
24479 if (PyErr_Occurred()) SWIG_fail;
24480 }
24481 {
24482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24483 }
24484 return resultobj;
24485 fail:
24486 return NULL;
24487 }
24488
24489
24490 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24491 PyObject *resultobj = NULL;
24492 wxDateTime *arg1 = (wxDateTime *) 0 ;
24493 wxDateTime *arg2 = (wxDateTime *) 0 ;
24494 bool result;
24495 PyObject * obj0 = 0 ;
24496 PyObject * obj1 = 0 ;
24497 char *kwnames[] = {
24498 (char *) "self",(char *) "other", NULL
24499 };
24500
24501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
24502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24503 if (SWIG_arg_fail(1)) SWIG_fail;
24504 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24505 if (SWIG_arg_fail(2)) SWIG_fail;
24506 {
24507 PyThreadState* __tstate = wxPyBeginAllowThreads();
24508 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
24509
24510 wxPyEndAllowThreads(__tstate);
24511 if (PyErr_Occurred()) SWIG_fail;
24512 }
24513 {
24514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24515 }
24516 return resultobj;
24517 fail:
24518 return NULL;
24519 }
24520
24521
24522 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24523 PyObject *resultobj = NULL;
24524 wxDateTime *arg1 = (wxDateTime *) 0 ;
24525 wxDateTime *arg2 = (wxDateTime *) 0 ;
24526 bool result;
24527 PyObject * obj0 = 0 ;
24528 PyObject * obj1 = 0 ;
24529 char *kwnames[] = {
24530 (char *) "self",(char *) "other", NULL
24531 };
24532
24533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
24534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24535 if (SWIG_arg_fail(1)) SWIG_fail;
24536 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24537 if (SWIG_arg_fail(2)) SWIG_fail;
24538 {
24539 PyThreadState* __tstate = wxPyBeginAllowThreads();
24540 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
24541
24542 wxPyEndAllowThreads(__tstate);
24543 if (PyErr_Occurred()) SWIG_fail;
24544 }
24545 {
24546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24547 }
24548 return resultobj;
24549 fail:
24550 return NULL;
24551 }
24552
24553
24554 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24555 PyObject *resultobj = NULL;
24556 wxDateTime *arg1 = (wxDateTime *) 0 ;
24557 wxDateTime *arg2 = (wxDateTime *) 0 ;
24558 bool result;
24559 PyObject * obj0 = 0 ;
24560 PyObject * obj1 = 0 ;
24561 char *kwnames[] = {
24562 (char *) "self",(char *) "other", NULL
24563 };
24564
24565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
24566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24567 if (SWIG_arg_fail(1)) SWIG_fail;
24568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24569 if (SWIG_arg_fail(2)) SWIG_fail;
24570 {
24571 PyThreadState* __tstate = wxPyBeginAllowThreads();
24572 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
24573
24574 wxPyEndAllowThreads(__tstate);
24575 if (PyErr_Occurred()) SWIG_fail;
24576 }
24577 {
24578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24579 }
24580 return resultobj;
24581 fail:
24582 return NULL;
24583 }
24584
24585
24586 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24587 PyObject *resultobj = NULL;
24588 wxDateTime *arg1 = (wxDateTime *) 0 ;
24589 wxDateTime *arg2 = (wxDateTime *) 0 ;
24590 bool result;
24591 PyObject * obj0 = 0 ;
24592 PyObject * obj1 = 0 ;
24593 char *kwnames[] = {
24594 (char *) "self",(char *) "other", NULL
24595 };
24596
24597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
24598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24599 if (SWIG_arg_fail(1)) SWIG_fail;
24600 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24601 if (SWIG_arg_fail(2)) SWIG_fail;
24602 {
24603 PyThreadState* __tstate = wxPyBeginAllowThreads();
24604 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
24605
24606 wxPyEndAllowThreads(__tstate);
24607 if (PyErr_Occurred()) SWIG_fail;
24608 }
24609 {
24610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24611 }
24612 return resultobj;
24613 fail:
24614 return NULL;
24615 }
24616
24617
24618 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
24619 PyObject *resultobj = NULL;
24620 wxDateTime *arg1 = (wxDateTime *) 0 ;
24621 wxString *arg2 = 0 ;
24622 int result;
24623 bool temp2 = false ;
24624 PyObject * obj0 = 0 ;
24625 PyObject * obj1 = 0 ;
24626 char *kwnames[] = {
24627 (char *) "self",(char *) "date", NULL
24628 };
24629
24630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
24631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24632 if (SWIG_arg_fail(1)) SWIG_fail;
24633 {
24634 arg2 = wxString_in_helper(obj1);
24635 if (arg2 == NULL) SWIG_fail;
24636 temp2 = true;
24637 }
24638 {
24639 PyThreadState* __tstate = wxPyBeginAllowThreads();
24640 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
24641
24642 wxPyEndAllowThreads(__tstate);
24643 if (PyErr_Occurred()) SWIG_fail;
24644 }
24645 {
24646 resultobj = SWIG_From_int(static_cast<int >(result));
24647 }
24648 {
24649 if (temp2)
24650 delete arg2;
24651 }
24652 return resultobj;
24653 fail:
24654 {
24655 if (temp2)
24656 delete arg2;
24657 }
24658 return NULL;
24659 }
24660
24661
24662 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
24663 PyObject *resultobj = NULL;
24664 wxDateTime *arg1 = (wxDateTime *) 0 ;
24665 wxString *arg2 = 0 ;
24666 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
24667 wxString *arg3 = (wxString *) &arg3_defvalue ;
24668 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
24669 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
24670 int result;
24671 bool temp2 = false ;
24672 bool temp3 = false ;
24673 PyObject * obj0 = 0 ;
24674 PyObject * obj1 = 0 ;
24675 PyObject * obj2 = 0 ;
24676 PyObject * obj3 = 0 ;
24677 char *kwnames[] = {
24678 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
24679 };
24680
24681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24683 if (SWIG_arg_fail(1)) SWIG_fail;
24684 {
24685 arg2 = wxString_in_helper(obj1);
24686 if (arg2 == NULL) SWIG_fail;
24687 temp2 = true;
24688 }
24689 if (obj2) {
24690 {
24691 arg3 = wxString_in_helper(obj2);
24692 if (arg3 == NULL) SWIG_fail;
24693 temp3 = true;
24694 }
24695 }
24696 if (obj3) {
24697 {
24698 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24699 if (SWIG_arg_fail(4)) SWIG_fail;
24700 if (arg4 == NULL) {
24701 SWIG_null_ref("wxDateTime");
24702 }
24703 if (SWIG_arg_fail(4)) SWIG_fail;
24704 }
24705 }
24706 {
24707 PyThreadState* __tstate = wxPyBeginAllowThreads();
24708 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
24709
24710 wxPyEndAllowThreads(__tstate);
24711 if (PyErr_Occurred()) SWIG_fail;
24712 }
24713 {
24714 resultobj = SWIG_From_int(static_cast<int >(result));
24715 }
24716 {
24717 if (temp2)
24718 delete arg2;
24719 }
24720 {
24721 if (temp3)
24722 delete arg3;
24723 }
24724 return resultobj;
24725 fail:
24726 {
24727 if (temp2)
24728 delete arg2;
24729 }
24730 {
24731 if (temp3)
24732 delete arg3;
24733 }
24734 return NULL;
24735 }
24736
24737
24738 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
24739 PyObject *resultobj = NULL;
24740 wxDateTime *arg1 = (wxDateTime *) 0 ;
24741 wxString *arg2 = 0 ;
24742 int result;
24743 bool temp2 = false ;
24744 PyObject * obj0 = 0 ;
24745 PyObject * obj1 = 0 ;
24746 char *kwnames[] = {
24747 (char *) "self",(char *) "datetime", NULL
24748 };
24749
24750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
24751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24752 if (SWIG_arg_fail(1)) SWIG_fail;
24753 {
24754 arg2 = wxString_in_helper(obj1);
24755 if (arg2 == NULL) SWIG_fail;
24756 temp2 = true;
24757 }
24758 {
24759 PyThreadState* __tstate = wxPyBeginAllowThreads();
24760 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
24761
24762 wxPyEndAllowThreads(__tstate);
24763 if (PyErr_Occurred()) SWIG_fail;
24764 }
24765 {
24766 resultobj = SWIG_From_int(static_cast<int >(result));
24767 }
24768 {
24769 if (temp2)
24770 delete arg2;
24771 }
24772 return resultobj;
24773 fail:
24774 {
24775 if (temp2)
24776 delete arg2;
24777 }
24778 return NULL;
24779 }
24780
24781
24782 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
24783 PyObject *resultobj = NULL;
24784 wxDateTime *arg1 = (wxDateTime *) 0 ;
24785 wxString *arg2 = 0 ;
24786 int result;
24787 bool temp2 = false ;
24788 PyObject * obj0 = 0 ;
24789 PyObject * obj1 = 0 ;
24790 char *kwnames[] = {
24791 (char *) "self",(char *) "date", NULL
24792 };
24793
24794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
24795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24796 if (SWIG_arg_fail(1)) SWIG_fail;
24797 {
24798 arg2 = wxString_in_helper(obj1);
24799 if (arg2 == NULL) SWIG_fail;
24800 temp2 = true;
24801 }
24802 {
24803 PyThreadState* __tstate = wxPyBeginAllowThreads();
24804 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
24805
24806 wxPyEndAllowThreads(__tstate);
24807 if (PyErr_Occurred()) SWIG_fail;
24808 }
24809 {
24810 resultobj = SWIG_From_int(static_cast<int >(result));
24811 }
24812 {
24813 if (temp2)
24814 delete arg2;
24815 }
24816 return resultobj;
24817 fail:
24818 {
24819 if (temp2)
24820 delete arg2;
24821 }
24822 return NULL;
24823 }
24824
24825
24826 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
24827 PyObject *resultobj = NULL;
24828 wxDateTime *arg1 = (wxDateTime *) 0 ;
24829 wxString *arg2 = 0 ;
24830 int result;
24831 bool temp2 = false ;
24832 PyObject * obj0 = 0 ;
24833 PyObject * obj1 = 0 ;
24834 char *kwnames[] = {
24835 (char *) "self",(char *) "time", NULL
24836 };
24837
24838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
24839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24840 if (SWIG_arg_fail(1)) SWIG_fail;
24841 {
24842 arg2 = wxString_in_helper(obj1);
24843 if (arg2 == NULL) SWIG_fail;
24844 temp2 = true;
24845 }
24846 {
24847 PyThreadState* __tstate = wxPyBeginAllowThreads();
24848 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
24849
24850 wxPyEndAllowThreads(__tstate);
24851 if (PyErr_Occurred()) SWIG_fail;
24852 }
24853 {
24854 resultobj = SWIG_From_int(static_cast<int >(result));
24855 }
24856 {
24857 if (temp2)
24858 delete arg2;
24859 }
24860 return resultobj;
24861 fail:
24862 {
24863 if (temp2)
24864 delete arg2;
24865 }
24866 return NULL;
24867 }
24868
24869
24870 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
24871 PyObject *resultobj = NULL;
24872 wxDateTime *arg1 = (wxDateTime *) 0 ;
24873 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
24874 wxString *arg2 = (wxString *) &arg2_defvalue ;
24875 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
24876 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
24877 wxString result;
24878 bool temp2 = false ;
24879 bool temp3 = false ;
24880 PyObject * obj0 = 0 ;
24881 PyObject * obj1 = 0 ;
24882 PyObject * obj2 = 0 ;
24883 char *kwnames[] = {
24884 (char *) "self",(char *) "format",(char *) "tz", NULL
24885 };
24886
24887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
24888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24889 if (SWIG_arg_fail(1)) SWIG_fail;
24890 if (obj1) {
24891 {
24892 arg2 = wxString_in_helper(obj1);
24893 if (arg2 == NULL) SWIG_fail;
24894 temp2 = true;
24895 }
24896 }
24897 if (obj2) {
24898 {
24899 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
24900 temp3 = true;
24901 }
24902 }
24903 {
24904 PyThreadState* __tstate = wxPyBeginAllowThreads();
24905 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
24906
24907 wxPyEndAllowThreads(__tstate);
24908 if (PyErr_Occurred()) SWIG_fail;
24909 }
24910 {
24911 #if wxUSE_UNICODE
24912 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24913 #else
24914 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24915 #endif
24916 }
24917 {
24918 if (temp2)
24919 delete arg2;
24920 }
24921 {
24922 if (temp3) delete arg3;
24923 }
24924 return resultobj;
24925 fail:
24926 {
24927 if (temp2)
24928 delete arg2;
24929 }
24930 {
24931 if (temp3) delete arg3;
24932 }
24933 return NULL;
24934 }
24935
24936
24937 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
24938 PyObject *resultobj = NULL;
24939 wxDateTime *arg1 = (wxDateTime *) 0 ;
24940 wxString result;
24941 PyObject * obj0 = 0 ;
24942 char *kwnames[] = {
24943 (char *) "self", NULL
24944 };
24945
24946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
24947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24948 if (SWIG_arg_fail(1)) SWIG_fail;
24949 {
24950 PyThreadState* __tstate = wxPyBeginAllowThreads();
24951 result = ((wxDateTime const *)arg1)->FormatDate();
24952
24953 wxPyEndAllowThreads(__tstate);
24954 if (PyErr_Occurred()) SWIG_fail;
24955 }
24956 {
24957 #if wxUSE_UNICODE
24958 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24959 #else
24960 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24961 #endif
24962 }
24963 return resultobj;
24964 fail:
24965 return NULL;
24966 }
24967
24968
24969 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
24970 PyObject *resultobj = NULL;
24971 wxDateTime *arg1 = (wxDateTime *) 0 ;
24972 wxString result;
24973 PyObject * obj0 = 0 ;
24974 char *kwnames[] = {
24975 (char *) "self", NULL
24976 };
24977
24978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
24979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24980 if (SWIG_arg_fail(1)) SWIG_fail;
24981 {
24982 PyThreadState* __tstate = wxPyBeginAllowThreads();
24983 result = ((wxDateTime const *)arg1)->FormatTime();
24984
24985 wxPyEndAllowThreads(__tstate);
24986 if (PyErr_Occurred()) SWIG_fail;
24987 }
24988 {
24989 #if wxUSE_UNICODE
24990 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24991 #else
24992 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24993 #endif
24994 }
24995 return resultobj;
24996 fail:
24997 return NULL;
24998 }
24999
25000
25001 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
25002 PyObject *resultobj = NULL;
25003 wxDateTime *arg1 = (wxDateTime *) 0 ;
25004 wxString result;
25005 PyObject * obj0 = 0 ;
25006 char *kwnames[] = {
25007 (char *) "self", NULL
25008 };
25009
25010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
25011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
25012 if (SWIG_arg_fail(1)) SWIG_fail;
25013 {
25014 PyThreadState* __tstate = wxPyBeginAllowThreads();
25015 result = ((wxDateTime const *)arg1)->FormatISODate();
25016
25017 wxPyEndAllowThreads(__tstate);
25018 if (PyErr_Occurred()) SWIG_fail;
25019 }
25020 {
25021 #if wxUSE_UNICODE
25022 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25023 #else
25024 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25025 #endif
25026 }
25027 return resultobj;
25028 fail:
25029 return NULL;
25030 }
25031
25032
25033 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
25034 PyObject *resultobj = NULL;
25035 wxDateTime *arg1 = (wxDateTime *) 0 ;
25036 wxString result;
25037 PyObject * obj0 = 0 ;
25038 char *kwnames[] = {
25039 (char *) "self", NULL
25040 };
25041
25042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
25043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
25044 if (SWIG_arg_fail(1)) SWIG_fail;
25045 {
25046 PyThreadState* __tstate = wxPyBeginAllowThreads();
25047 result = ((wxDateTime const *)arg1)->FormatISOTime();
25048
25049 wxPyEndAllowThreads(__tstate);
25050 if (PyErr_Occurred()) SWIG_fail;
25051 }
25052 {
25053 #if wxUSE_UNICODE
25054 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25055 #else
25056 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25057 #endif
25058 }
25059 return resultobj;
25060 fail:
25061 return NULL;
25062 }
25063
25064
25065 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
25066 PyObject *obj;
25067 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25068 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
25069 Py_INCREF(obj);
25070 return Py_BuildValue((char *)"");
25071 }
25072 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
25073 PyObject *resultobj = NULL;
25074 long arg1 ;
25075 wxTimeSpan result;
25076 PyObject * obj0 = 0 ;
25077 char *kwnames[] = {
25078 (char *) "sec", NULL
25079 };
25080
25081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
25082 {
25083 arg1 = static_cast<long >(SWIG_As_long(obj0));
25084 if (SWIG_arg_fail(1)) SWIG_fail;
25085 }
25086 {
25087 PyThreadState* __tstate = wxPyBeginAllowThreads();
25088 result = wxTimeSpan::Seconds(arg1);
25089
25090 wxPyEndAllowThreads(__tstate);
25091 if (PyErr_Occurred()) SWIG_fail;
25092 }
25093 {
25094 wxTimeSpan * resultptr;
25095 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25096 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25097 }
25098 return resultobj;
25099 fail:
25100 return NULL;
25101 }
25102
25103
25104 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
25105 PyObject *resultobj = NULL;
25106 wxTimeSpan result;
25107 char *kwnames[] = {
25108 NULL
25109 };
25110
25111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
25112 {
25113 PyThreadState* __tstate = wxPyBeginAllowThreads();
25114 result = wxTimeSpan::Second();
25115
25116 wxPyEndAllowThreads(__tstate);
25117 if (PyErr_Occurred()) SWIG_fail;
25118 }
25119 {
25120 wxTimeSpan * resultptr;
25121 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25122 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25123 }
25124 return resultobj;
25125 fail:
25126 return NULL;
25127 }
25128
25129
25130 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
25131 PyObject *resultobj = NULL;
25132 long arg1 ;
25133 wxTimeSpan result;
25134 PyObject * obj0 = 0 ;
25135 char *kwnames[] = {
25136 (char *) "min", NULL
25137 };
25138
25139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
25140 {
25141 arg1 = static_cast<long >(SWIG_As_long(obj0));
25142 if (SWIG_arg_fail(1)) SWIG_fail;
25143 }
25144 {
25145 PyThreadState* __tstate = wxPyBeginAllowThreads();
25146 result = wxTimeSpan::Minutes(arg1);
25147
25148 wxPyEndAllowThreads(__tstate);
25149 if (PyErr_Occurred()) SWIG_fail;
25150 }
25151 {
25152 wxTimeSpan * resultptr;
25153 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25154 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25155 }
25156 return resultobj;
25157 fail:
25158 return NULL;
25159 }
25160
25161
25162 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
25163 PyObject *resultobj = NULL;
25164 wxTimeSpan result;
25165 char *kwnames[] = {
25166 NULL
25167 };
25168
25169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
25170 {
25171 PyThreadState* __tstate = wxPyBeginAllowThreads();
25172 result = wxTimeSpan::Minute();
25173
25174 wxPyEndAllowThreads(__tstate);
25175 if (PyErr_Occurred()) SWIG_fail;
25176 }
25177 {
25178 wxTimeSpan * resultptr;
25179 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25181 }
25182 return resultobj;
25183 fail:
25184 return NULL;
25185 }
25186
25187
25188 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
25189 PyObject *resultobj = NULL;
25190 long arg1 ;
25191 wxTimeSpan result;
25192 PyObject * obj0 = 0 ;
25193 char *kwnames[] = {
25194 (char *) "hours", NULL
25195 };
25196
25197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
25198 {
25199 arg1 = static_cast<long >(SWIG_As_long(obj0));
25200 if (SWIG_arg_fail(1)) SWIG_fail;
25201 }
25202 {
25203 PyThreadState* __tstate = wxPyBeginAllowThreads();
25204 result = wxTimeSpan::Hours(arg1);
25205
25206 wxPyEndAllowThreads(__tstate);
25207 if (PyErr_Occurred()) SWIG_fail;
25208 }
25209 {
25210 wxTimeSpan * resultptr;
25211 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25212 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25213 }
25214 return resultobj;
25215 fail:
25216 return NULL;
25217 }
25218
25219
25220 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
25221 PyObject *resultobj = NULL;
25222 wxTimeSpan result;
25223 char *kwnames[] = {
25224 NULL
25225 };
25226
25227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
25228 {
25229 PyThreadState* __tstate = wxPyBeginAllowThreads();
25230 result = wxTimeSpan::Hour();
25231
25232 wxPyEndAllowThreads(__tstate);
25233 if (PyErr_Occurred()) SWIG_fail;
25234 }
25235 {
25236 wxTimeSpan * resultptr;
25237 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25238 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25239 }
25240 return resultobj;
25241 fail:
25242 return NULL;
25243 }
25244
25245
25246 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25247 PyObject *resultobj = NULL;
25248 long arg1 ;
25249 wxTimeSpan result;
25250 PyObject * obj0 = 0 ;
25251 char *kwnames[] = {
25252 (char *) "days", NULL
25253 };
25254
25255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
25256 {
25257 arg1 = static_cast<long >(SWIG_As_long(obj0));
25258 if (SWIG_arg_fail(1)) SWIG_fail;
25259 }
25260 {
25261 PyThreadState* __tstate = wxPyBeginAllowThreads();
25262 result = wxTimeSpan::Days(arg1);
25263
25264 wxPyEndAllowThreads(__tstate);
25265 if (PyErr_Occurred()) SWIG_fail;
25266 }
25267 {
25268 wxTimeSpan * resultptr;
25269 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25270 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25271 }
25272 return resultobj;
25273 fail:
25274 return NULL;
25275 }
25276
25277
25278 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25279 PyObject *resultobj = NULL;
25280 wxTimeSpan result;
25281 char *kwnames[] = {
25282 NULL
25283 };
25284
25285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
25286 {
25287 PyThreadState* __tstate = wxPyBeginAllowThreads();
25288 result = wxTimeSpan::Day();
25289
25290 wxPyEndAllowThreads(__tstate);
25291 if (PyErr_Occurred()) SWIG_fail;
25292 }
25293 {
25294 wxTimeSpan * resultptr;
25295 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25296 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25297 }
25298 return resultobj;
25299 fail:
25300 return NULL;
25301 }
25302
25303
25304 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25305 PyObject *resultobj = NULL;
25306 long arg1 ;
25307 wxTimeSpan result;
25308 PyObject * obj0 = 0 ;
25309 char *kwnames[] = {
25310 (char *) "days", NULL
25311 };
25312
25313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
25314 {
25315 arg1 = static_cast<long >(SWIG_As_long(obj0));
25316 if (SWIG_arg_fail(1)) SWIG_fail;
25317 }
25318 {
25319 PyThreadState* __tstate = wxPyBeginAllowThreads();
25320 result = wxTimeSpan::Weeks(arg1);
25321
25322 wxPyEndAllowThreads(__tstate);
25323 if (PyErr_Occurred()) SWIG_fail;
25324 }
25325 {
25326 wxTimeSpan * resultptr;
25327 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25328 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25329 }
25330 return resultobj;
25331 fail:
25332 return NULL;
25333 }
25334
25335
25336 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25337 PyObject *resultobj = NULL;
25338 wxTimeSpan result;
25339 char *kwnames[] = {
25340 NULL
25341 };
25342
25343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
25344 {
25345 PyThreadState* __tstate = wxPyBeginAllowThreads();
25346 result = wxTimeSpan::Week();
25347
25348 wxPyEndAllowThreads(__tstate);
25349 if (PyErr_Occurred()) SWIG_fail;
25350 }
25351 {
25352 wxTimeSpan * resultptr;
25353 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25354 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25355 }
25356 return resultobj;
25357 fail:
25358 return NULL;
25359 }
25360
25361
25362 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25363 PyObject *resultobj = NULL;
25364 long arg1 = (long) 0 ;
25365 long arg2 = (long) 0 ;
25366 long arg3 = (long) 0 ;
25367 long arg4 = (long) 0 ;
25368 wxTimeSpan *result;
25369 PyObject * obj0 = 0 ;
25370 PyObject * obj1 = 0 ;
25371 PyObject * obj2 = 0 ;
25372 PyObject * obj3 = 0 ;
25373 char *kwnames[] = {
25374 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
25375 };
25376
25377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25378 if (obj0) {
25379 {
25380 arg1 = static_cast<long >(SWIG_As_long(obj0));
25381 if (SWIG_arg_fail(1)) SWIG_fail;
25382 }
25383 }
25384 if (obj1) {
25385 {
25386 arg2 = static_cast<long >(SWIG_As_long(obj1));
25387 if (SWIG_arg_fail(2)) SWIG_fail;
25388 }
25389 }
25390 if (obj2) {
25391 {
25392 arg3 = static_cast<long >(SWIG_As_long(obj2));
25393 if (SWIG_arg_fail(3)) SWIG_fail;
25394 }
25395 }
25396 if (obj3) {
25397 {
25398 arg4 = static_cast<long >(SWIG_As_long(obj3));
25399 if (SWIG_arg_fail(4)) SWIG_fail;
25400 }
25401 }
25402 {
25403 PyThreadState* __tstate = wxPyBeginAllowThreads();
25404 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
25405
25406 wxPyEndAllowThreads(__tstate);
25407 if (PyErr_Occurred()) SWIG_fail;
25408 }
25409 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
25410 return resultobj;
25411 fail:
25412 return NULL;
25413 }
25414
25415
25416 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25417 PyObject *resultobj = NULL;
25418 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25419 PyObject * obj0 = 0 ;
25420 char *kwnames[] = {
25421 (char *) "self", NULL
25422 };
25423
25424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
25425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25426 if (SWIG_arg_fail(1)) SWIG_fail;
25427 {
25428 PyThreadState* __tstate = wxPyBeginAllowThreads();
25429 delete arg1;
25430
25431 wxPyEndAllowThreads(__tstate);
25432 if (PyErr_Occurred()) SWIG_fail;
25433 }
25434 Py_INCREF(Py_None); resultobj = Py_None;
25435 return resultobj;
25436 fail:
25437 return NULL;
25438 }
25439
25440
25441 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25442 PyObject *resultobj = NULL;
25443 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25444 wxTimeSpan *arg2 = 0 ;
25445 wxTimeSpan *result;
25446 PyObject * obj0 = 0 ;
25447 PyObject * obj1 = 0 ;
25448 char *kwnames[] = {
25449 (char *) "self",(char *) "diff", NULL
25450 };
25451
25452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25454 if (SWIG_arg_fail(1)) SWIG_fail;
25455 {
25456 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25457 if (SWIG_arg_fail(2)) SWIG_fail;
25458 if (arg2 == NULL) {
25459 SWIG_null_ref("wxTimeSpan");
25460 }
25461 if (SWIG_arg_fail(2)) SWIG_fail;
25462 }
25463 {
25464 PyThreadState* __tstate = wxPyBeginAllowThreads();
25465 {
25466 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25467 result = (wxTimeSpan *) &_result_ref;
25468 }
25469
25470 wxPyEndAllowThreads(__tstate);
25471 if (PyErr_Occurred()) SWIG_fail;
25472 }
25473 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25474 return resultobj;
25475 fail:
25476 return NULL;
25477 }
25478
25479
25480 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25481 PyObject *resultobj = NULL;
25482 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25483 wxTimeSpan *arg2 = 0 ;
25484 wxTimeSpan *result;
25485 PyObject * obj0 = 0 ;
25486 PyObject * obj1 = 0 ;
25487 char *kwnames[] = {
25488 (char *) "self",(char *) "diff", NULL
25489 };
25490
25491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25493 if (SWIG_arg_fail(1)) SWIG_fail;
25494 {
25495 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25496 if (SWIG_arg_fail(2)) SWIG_fail;
25497 if (arg2 == NULL) {
25498 SWIG_null_ref("wxTimeSpan");
25499 }
25500 if (SWIG_arg_fail(2)) SWIG_fail;
25501 }
25502 {
25503 PyThreadState* __tstate = wxPyBeginAllowThreads();
25504 {
25505 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
25506 result = (wxTimeSpan *) &_result_ref;
25507 }
25508
25509 wxPyEndAllowThreads(__tstate);
25510 if (PyErr_Occurred()) SWIG_fail;
25511 }
25512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25513 return resultobj;
25514 fail:
25515 return NULL;
25516 }
25517
25518
25519 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25520 PyObject *resultobj = NULL;
25521 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25522 int arg2 ;
25523 wxTimeSpan *result;
25524 PyObject * obj0 = 0 ;
25525 PyObject * obj1 = 0 ;
25526 char *kwnames[] = {
25527 (char *) "self",(char *) "n", NULL
25528 };
25529
25530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25532 if (SWIG_arg_fail(1)) SWIG_fail;
25533 {
25534 arg2 = static_cast<int >(SWIG_As_int(obj1));
25535 if (SWIG_arg_fail(2)) SWIG_fail;
25536 }
25537 {
25538 PyThreadState* __tstate = wxPyBeginAllowThreads();
25539 {
25540 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
25541 result = (wxTimeSpan *) &_result_ref;
25542 }
25543
25544 wxPyEndAllowThreads(__tstate);
25545 if (PyErr_Occurred()) SWIG_fail;
25546 }
25547 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25548 return resultobj;
25549 fail:
25550 return NULL;
25551 }
25552
25553
25554 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25555 PyObject *resultobj = NULL;
25556 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25557 wxTimeSpan *result;
25558 PyObject * obj0 = 0 ;
25559 char *kwnames[] = {
25560 (char *) "self", NULL
25561 };
25562
25563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
25564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25565 if (SWIG_arg_fail(1)) SWIG_fail;
25566 {
25567 PyThreadState* __tstate = wxPyBeginAllowThreads();
25568 {
25569 wxTimeSpan &_result_ref = (arg1)->Neg();
25570 result = (wxTimeSpan *) &_result_ref;
25571 }
25572
25573 wxPyEndAllowThreads(__tstate);
25574 if (PyErr_Occurred()) SWIG_fail;
25575 }
25576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25577 return resultobj;
25578 fail:
25579 return NULL;
25580 }
25581
25582
25583 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
25584 PyObject *resultobj = NULL;
25585 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25586 wxTimeSpan result;
25587 PyObject * obj0 = 0 ;
25588 char *kwnames[] = {
25589 (char *) "self", NULL
25590 };
25591
25592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
25593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25594 if (SWIG_arg_fail(1)) SWIG_fail;
25595 {
25596 PyThreadState* __tstate = wxPyBeginAllowThreads();
25597 result = ((wxTimeSpan const *)arg1)->Abs();
25598
25599 wxPyEndAllowThreads(__tstate);
25600 if (PyErr_Occurred()) SWIG_fail;
25601 }
25602 {
25603 wxTimeSpan * resultptr;
25604 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25605 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25606 }
25607 return resultobj;
25608 fail:
25609 return NULL;
25610 }
25611
25612
25613 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25614 PyObject *resultobj = NULL;
25615 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25616 wxTimeSpan *arg2 = 0 ;
25617 wxTimeSpan *result;
25618 PyObject * obj0 = 0 ;
25619 PyObject * obj1 = 0 ;
25620 char *kwnames[] = {
25621 (char *) "self",(char *) "diff", NULL
25622 };
25623
25624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25626 if (SWIG_arg_fail(1)) SWIG_fail;
25627 {
25628 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25629 if (SWIG_arg_fail(2)) SWIG_fail;
25630 if (arg2 == NULL) {
25631 SWIG_null_ref("wxTimeSpan");
25632 }
25633 if (SWIG_arg_fail(2)) SWIG_fail;
25634 }
25635 {
25636 PyThreadState* __tstate = wxPyBeginAllowThreads();
25637 {
25638 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
25639 result = (wxTimeSpan *) &_result_ref;
25640 }
25641
25642 wxPyEndAllowThreads(__tstate);
25643 if (PyErr_Occurred()) SWIG_fail;
25644 }
25645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
25646 return resultobj;
25647 fail:
25648 return NULL;
25649 }
25650
25651
25652 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25653 PyObject *resultobj = NULL;
25654 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25655 wxTimeSpan *arg2 = 0 ;
25656 wxTimeSpan *result;
25657 PyObject * obj0 = 0 ;
25658 PyObject * obj1 = 0 ;
25659 char *kwnames[] = {
25660 (char *) "self",(char *) "diff", NULL
25661 };
25662
25663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25665 if (SWIG_arg_fail(1)) SWIG_fail;
25666 {
25667 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25668 if (SWIG_arg_fail(2)) SWIG_fail;
25669 if (arg2 == NULL) {
25670 SWIG_null_ref("wxTimeSpan");
25671 }
25672 if (SWIG_arg_fail(2)) SWIG_fail;
25673 }
25674 {
25675 PyThreadState* __tstate = wxPyBeginAllowThreads();
25676 {
25677 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
25678 result = (wxTimeSpan *) &_result_ref;
25679 }
25680
25681 wxPyEndAllowThreads(__tstate);
25682 if (PyErr_Occurred()) SWIG_fail;
25683 }
25684 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
25685 return resultobj;
25686 fail:
25687 return NULL;
25688 }
25689
25690
25691 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
25692 PyObject *resultobj = NULL;
25693 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25694 int arg2 ;
25695 wxTimeSpan *result;
25696 PyObject * obj0 = 0 ;
25697 PyObject * obj1 = 0 ;
25698 char *kwnames[] = {
25699 (char *) "self",(char *) "n", NULL
25700 };
25701
25702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
25703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25704 if (SWIG_arg_fail(1)) SWIG_fail;
25705 {
25706 arg2 = static_cast<int >(SWIG_As_int(obj1));
25707 if (SWIG_arg_fail(2)) SWIG_fail;
25708 }
25709 {
25710 PyThreadState* __tstate = wxPyBeginAllowThreads();
25711 {
25712 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
25713 result = (wxTimeSpan *) &_result_ref;
25714 }
25715
25716 wxPyEndAllowThreads(__tstate);
25717 if (PyErr_Occurred()) SWIG_fail;
25718 }
25719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
25720 return resultobj;
25721 fail:
25722 return NULL;
25723 }
25724
25725
25726 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25727 PyObject *resultobj = NULL;
25728 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25729 wxTimeSpan *result;
25730 PyObject * obj0 = 0 ;
25731 char *kwnames[] = {
25732 (char *) "self", NULL
25733 };
25734
25735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
25736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25737 if (SWIG_arg_fail(1)) SWIG_fail;
25738 {
25739 PyThreadState* __tstate = wxPyBeginAllowThreads();
25740 {
25741 wxTimeSpan &_result_ref = (arg1)->operator -();
25742 result = (wxTimeSpan *) &_result_ref;
25743 }
25744
25745 wxPyEndAllowThreads(__tstate);
25746 if (PyErr_Occurred()) SWIG_fail;
25747 }
25748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25749 return resultobj;
25750 fail:
25751 return NULL;
25752 }
25753
25754
25755 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
25756 PyObject *resultobj = NULL;
25757 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25758 wxTimeSpan *arg2 = 0 ;
25759 wxTimeSpan result;
25760 PyObject * obj0 = 0 ;
25761 PyObject * obj1 = 0 ;
25762 char *kwnames[] = {
25763 (char *) "self",(char *) "other", NULL
25764 };
25765
25766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
25767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25768 if (SWIG_arg_fail(1)) SWIG_fail;
25769 {
25770 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25771 if (SWIG_arg_fail(2)) SWIG_fail;
25772 if (arg2 == NULL) {
25773 SWIG_null_ref("wxTimeSpan");
25774 }
25775 if (SWIG_arg_fail(2)) SWIG_fail;
25776 }
25777 {
25778 PyThreadState* __tstate = wxPyBeginAllowThreads();
25779 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
25780
25781 wxPyEndAllowThreads(__tstate);
25782 if (PyErr_Occurred()) SWIG_fail;
25783 }
25784 {
25785 wxTimeSpan * resultptr;
25786 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25787 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25788 }
25789 return resultobj;
25790 fail:
25791 return NULL;
25792 }
25793
25794
25795 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
25796 PyObject *resultobj = NULL;
25797 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25798 wxTimeSpan *arg2 = 0 ;
25799 wxTimeSpan result;
25800 PyObject * obj0 = 0 ;
25801 PyObject * obj1 = 0 ;
25802 char *kwnames[] = {
25803 (char *) "self",(char *) "other", NULL
25804 };
25805
25806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
25807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25808 if (SWIG_arg_fail(1)) SWIG_fail;
25809 {
25810 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25811 if (SWIG_arg_fail(2)) SWIG_fail;
25812 if (arg2 == NULL) {
25813 SWIG_null_ref("wxTimeSpan");
25814 }
25815 if (SWIG_arg_fail(2)) SWIG_fail;
25816 }
25817 {
25818 PyThreadState* __tstate = wxPyBeginAllowThreads();
25819 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
25820
25821 wxPyEndAllowThreads(__tstate);
25822 if (PyErr_Occurred()) SWIG_fail;
25823 }
25824 {
25825 wxTimeSpan * resultptr;
25826 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25827 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25828 }
25829 return resultobj;
25830 fail:
25831 return NULL;
25832 }
25833
25834
25835 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
25836 PyObject *resultobj = NULL;
25837 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25838 int arg2 ;
25839 wxTimeSpan result;
25840 PyObject * obj0 = 0 ;
25841 PyObject * obj1 = 0 ;
25842 char *kwnames[] = {
25843 (char *) "self",(char *) "n", NULL
25844 };
25845
25846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
25847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25848 if (SWIG_arg_fail(1)) SWIG_fail;
25849 {
25850 arg2 = static_cast<int >(SWIG_As_int(obj1));
25851 if (SWIG_arg_fail(2)) SWIG_fail;
25852 }
25853 {
25854 PyThreadState* __tstate = wxPyBeginAllowThreads();
25855 result = wxTimeSpan___mul__(arg1,arg2);
25856
25857 wxPyEndAllowThreads(__tstate);
25858 if (PyErr_Occurred()) SWIG_fail;
25859 }
25860 {
25861 wxTimeSpan * resultptr;
25862 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25863 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25864 }
25865 return resultobj;
25866 fail:
25867 return NULL;
25868 }
25869
25870
25871 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
25872 PyObject *resultobj = NULL;
25873 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25874 int arg2 ;
25875 wxTimeSpan result;
25876 PyObject * obj0 = 0 ;
25877 PyObject * obj1 = 0 ;
25878 char *kwnames[] = {
25879 (char *) "self",(char *) "n", NULL
25880 };
25881
25882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
25883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25884 if (SWIG_arg_fail(1)) SWIG_fail;
25885 {
25886 arg2 = static_cast<int >(SWIG_As_int(obj1));
25887 if (SWIG_arg_fail(2)) SWIG_fail;
25888 }
25889 {
25890 PyThreadState* __tstate = wxPyBeginAllowThreads();
25891 result = wxTimeSpan___rmul__(arg1,arg2);
25892
25893 wxPyEndAllowThreads(__tstate);
25894 if (PyErr_Occurred()) SWIG_fail;
25895 }
25896 {
25897 wxTimeSpan * resultptr;
25898 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25899 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25900 }
25901 return resultobj;
25902 fail:
25903 return NULL;
25904 }
25905
25906
25907 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
25908 PyObject *resultobj = NULL;
25909 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25910 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25911 bool result;
25912 PyObject * obj0 = 0 ;
25913 PyObject * obj1 = 0 ;
25914 char *kwnames[] = {
25915 (char *) "self",(char *) "other", NULL
25916 };
25917
25918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
25919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25920 if (SWIG_arg_fail(1)) SWIG_fail;
25921 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25922 if (SWIG_arg_fail(2)) SWIG_fail;
25923 {
25924 PyThreadState* __tstate = wxPyBeginAllowThreads();
25925 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
25926
25927 wxPyEndAllowThreads(__tstate);
25928 if (PyErr_Occurred()) SWIG_fail;
25929 }
25930 {
25931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25932 }
25933 return resultobj;
25934 fail:
25935 return NULL;
25936 }
25937
25938
25939 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
25940 PyObject *resultobj = NULL;
25941 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25942 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25943 bool result;
25944 PyObject * obj0 = 0 ;
25945 PyObject * obj1 = 0 ;
25946 char *kwnames[] = {
25947 (char *) "self",(char *) "other", NULL
25948 };
25949
25950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
25951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25952 if (SWIG_arg_fail(1)) SWIG_fail;
25953 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25954 if (SWIG_arg_fail(2)) SWIG_fail;
25955 {
25956 PyThreadState* __tstate = wxPyBeginAllowThreads();
25957 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
25958
25959 wxPyEndAllowThreads(__tstate);
25960 if (PyErr_Occurred()) SWIG_fail;
25961 }
25962 {
25963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25964 }
25965 return resultobj;
25966 fail:
25967 return NULL;
25968 }
25969
25970
25971 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
25972 PyObject *resultobj = NULL;
25973 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25974 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25975 bool result;
25976 PyObject * obj0 = 0 ;
25977 PyObject * obj1 = 0 ;
25978 char *kwnames[] = {
25979 (char *) "self",(char *) "other", NULL
25980 };
25981
25982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
25983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25984 if (SWIG_arg_fail(1)) SWIG_fail;
25985 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25986 if (SWIG_arg_fail(2)) SWIG_fail;
25987 {
25988 PyThreadState* __tstate = wxPyBeginAllowThreads();
25989 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
25990
25991 wxPyEndAllowThreads(__tstate);
25992 if (PyErr_Occurred()) SWIG_fail;
25993 }
25994 {
25995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25996 }
25997 return resultobj;
25998 fail:
25999 return NULL;
26000 }
26001
26002
26003 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
26004 PyObject *resultobj = NULL;
26005 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26006 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
26007 bool result;
26008 PyObject * obj0 = 0 ;
26009 PyObject * obj1 = 0 ;
26010 char *kwnames[] = {
26011 (char *) "self",(char *) "other", NULL
26012 };
26013
26014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
26015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26016 if (SWIG_arg_fail(1)) SWIG_fail;
26017 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26018 if (SWIG_arg_fail(2)) SWIG_fail;
26019 {
26020 PyThreadState* __tstate = wxPyBeginAllowThreads();
26021 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
26022
26023 wxPyEndAllowThreads(__tstate);
26024 if (PyErr_Occurred()) SWIG_fail;
26025 }
26026 {
26027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26028 }
26029 return resultobj;
26030 fail:
26031 return NULL;
26032 }
26033
26034
26035 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26036 PyObject *resultobj = NULL;
26037 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26038 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
26039 bool result;
26040 PyObject * obj0 = 0 ;
26041 PyObject * obj1 = 0 ;
26042 char *kwnames[] = {
26043 (char *) "self",(char *) "other", NULL
26044 };
26045
26046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26048 if (SWIG_arg_fail(1)) SWIG_fail;
26049 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26050 if (SWIG_arg_fail(2)) SWIG_fail;
26051 {
26052 PyThreadState* __tstate = wxPyBeginAllowThreads();
26053 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
26054
26055 wxPyEndAllowThreads(__tstate);
26056 if (PyErr_Occurred()) SWIG_fail;
26057 }
26058 {
26059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26060 }
26061 return resultobj;
26062 fail:
26063 return NULL;
26064 }
26065
26066
26067 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26068 PyObject *resultobj = NULL;
26069 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26070 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
26071 bool result;
26072 PyObject * obj0 = 0 ;
26073 PyObject * obj1 = 0 ;
26074 char *kwnames[] = {
26075 (char *) "self",(char *) "other", NULL
26076 };
26077
26078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26080 if (SWIG_arg_fail(1)) SWIG_fail;
26081 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26082 if (SWIG_arg_fail(2)) SWIG_fail;
26083 {
26084 PyThreadState* __tstate = wxPyBeginAllowThreads();
26085 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
26086
26087 wxPyEndAllowThreads(__tstate);
26088 if (PyErr_Occurred()) SWIG_fail;
26089 }
26090 {
26091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26092 }
26093 return resultobj;
26094 fail:
26095 return NULL;
26096 }
26097
26098
26099 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
26100 PyObject *resultobj = NULL;
26101 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26102 bool result;
26103 PyObject * obj0 = 0 ;
26104 char *kwnames[] = {
26105 (char *) "self", NULL
26106 };
26107
26108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
26109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26110 if (SWIG_arg_fail(1)) SWIG_fail;
26111 {
26112 PyThreadState* __tstate = wxPyBeginAllowThreads();
26113 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
26114
26115 wxPyEndAllowThreads(__tstate);
26116 if (PyErr_Occurred()) SWIG_fail;
26117 }
26118 {
26119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26120 }
26121 return resultobj;
26122 fail:
26123 return NULL;
26124 }
26125
26126
26127 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
26128 PyObject *resultobj = NULL;
26129 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26130 bool result;
26131 PyObject * obj0 = 0 ;
26132 char *kwnames[] = {
26133 (char *) "self", NULL
26134 };
26135
26136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
26137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26138 if (SWIG_arg_fail(1)) SWIG_fail;
26139 {
26140 PyThreadState* __tstate = wxPyBeginAllowThreads();
26141 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
26142
26143 wxPyEndAllowThreads(__tstate);
26144 if (PyErr_Occurred()) SWIG_fail;
26145 }
26146 {
26147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26148 }
26149 return resultobj;
26150 fail:
26151 return NULL;
26152 }
26153
26154
26155 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
26156 PyObject *resultobj = NULL;
26157 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26158 bool result;
26159 PyObject * obj0 = 0 ;
26160 char *kwnames[] = {
26161 (char *) "self", NULL
26162 };
26163
26164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
26165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26166 if (SWIG_arg_fail(1)) SWIG_fail;
26167 {
26168 PyThreadState* __tstate = wxPyBeginAllowThreads();
26169 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
26170
26171 wxPyEndAllowThreads(__tstate);
26172 if (PyErr_Occurred()) SWIG_fail;
26173 }
26174 {
26175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26176 }
26177 return resultobj;
26178 fail:
26179 return NULL;
26180 }
26181
26182
26183 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
26184 PyObject *resultobj = NULL;
26185 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26186 wxTimeSpan *arg2 = 0 ;
26187 bool result;
26188 PyObject * obj0 = 0 ;
26189 PyObject * obj1 = 0 ;
26190 char *kwnames[] = {
26191 (char *) "self",(char *) "ts", NULL
26192 };
26193
26194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
26195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26196 if (SWIG_arg_fail(1)) SWIG_fail;
26197 {
26198 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26199 if (SWIG_arg_fail(2)) SWIG_fail;
26200 if (arg2 == NULL) {
26201 SWIG_null_ref("wxTimeSpan");
26202 }
26203 if (SWIG_arg_fail(2)) SWIG_fail;
26204 }
26205 {
26206 PyThreadState* __tstate = wxPyBeginAllowThreads();
26207 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
26208
26209 wxPyEndAllowThreads(__tstate);
26210 if (PyErr_Occurred()) SWIG_fail;
26211 }
26212 {
26213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26214 }
26215 return resultobj;
26216 fail:
26217 return NULL;
26218 }
26219
26220
26221 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
26222 PyObject *resultobj = NULL;
26223 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26224 wxTimeSpan *arg2 = 0 ;
26225 bool result;
26226 PyObject * obj0 = 0 ;
26227 PyObject * obj1 = 0 ;
26228 char *kwnames[] = {
26229 (char *) "self",(char *) "ts", NULL
26230 };
26231
26232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
26233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26234 if (SWIG_arg_fail(1)) SWIG_fail;
26235 {
26236 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26237 if (SWIG_arg_fail(2)) SWIG_fail;
26238 if (arg2 == NULL) {
26239 SWIG_null_ref("wxTimeSpan");
26240 }
26241 if (SWIG_arg_fail(2)) SWIG_fail;
26242 }
26243 {
26244 PyThreadState* __tstate = wxPyBeginAllowThreads();
26245 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
26246
26247 wxPyEndAllowThreads(__tstate);
26248 if (PyErr_Occurred()) SWIG_fail;
26249 }
26250 {
26251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26252 }
26253 return resultobj;
26254 fail:
26255 return NULL;
26256 }
26257
26258
26259 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
26260 PyObject *resultobj = NULL;
26261 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26262 wxTimeSpan *arg2 = 0 ;
26263 bool result;
26264 PyObject * obj0 = 0 ;
26265 PyObject * obj1 = 0 ;
26266 char *kwnames[] = {
26267 (char *) "self",(char *) "t", NULL
26268 };
26269
26270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
26271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26272 if (SWIG_arg_fail(1)) SWIG_fail;
26273 {
26274 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26275 if (SWIG_arg_fail(2)) SWIG_fail;
26276 if (arg2 == NULL) {
26277 SWIG_null_ref("wxTimeSpan");
26278 }
26279 if (SWIG_arg_fail(2)) SWIG_fail;
26280 }
26281 {
26282 PyThreadState* __tstate = wxPyBeginAllowThreads();
26283 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
26284
26285 wxPyEndAllowThreads(__tstate);
26286 if (PyErr_Occurred()) SWIG_fail;
26287 }
26288 {
26289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26290 }
26291 return resultobj;
26292 fail:
26293 return NULL;
26294 }
26295
26296
26297 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
26298 PyObject *resultobj = NULL;
26299 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26300 int result;
26301 PyObject * obj0 = 0 ;
26302 char *kwnames[] = {
26303 (char *) "self", NULL
26304 };
26305
26306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
26307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26308 if (SWIG_arg_fail(1)) SWIG_fail;
26309 {
26310 PyThreadState* __tstate = wxPyBeginAllowThreads();
26311 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
26312
26313 wxPyEndAllowThreads(__tstate);
26314 if (PyErr_Occurred()) SWIG_fail;
26315 }
26316 {
26317 resultobj = SWIG_From_int(static_cast<int >(result));
26318 }
26319 return resultobj;
26320 fail:
26321 return NULL;
26322 }
26323
26324
26325 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
26326 PyObject *resultobj = NULL;
26327 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26328 int result;
26329 PyObject * obj0 = 0 ;
26330 char *kwnames[] = {
26331 (char *) "self", NULL
26332 };
26333
26334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
26335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26336 if (SWIG_arg_fail(1)) SWIG_fail;
26337 {
26338 PyThreadState* __tstate = wxPyBeginAllowThreads();
26339 result = (int)((wxTimeSpan const *)arg1)->GetDays();
26340
26341 wxPyEndAllowThreads(__tstate);
26342 if (PyErr_Occurred()) SWIG_fail;
26343 }
26344 {
26345 resultobj = SWIG_From_int(static_cast<int >(result));
26346 }
26347 return resultobj;
26348 fail:
26349 return NULL;
26350 }
26351
26352
26353 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
26354 PyObject *resultobj = NULL;
26355 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26356 int result;
26357 PyObject * obj0 = 0 ;
26358 char *kwnames[] = {
26359 (char *) "self", NULL
26360 };
26361
26362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
26363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26364 if (SWIG_arg_fail(1)) SWIG_fail;
26365 {
26366 PyThreadState* __tstate = wxPyBeginAllowThreads();
26367 result = (int)((wxTimeSpan const *)arg1)->GetHours();
26368
26369 wxPyEndAllowThreads(__tstate);
26370 if (PyErr_Occurred()) SWIG_fail;
26371 }
26372 {
26373 resultobj = SWIG_From_int(static_cast<int >(result));
26374 }
26375 return resultobj;
26376 fail:
26377 return NULL;
26378 }
26379
26380
26381 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
26382 PyObject *resultobj = NULL;
26383 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26384 int result;
26385 PyObject * obj0 = 0 ;
26386 char *kwnames[] = {
26387 (char *) "self", NULL
26388 };
26389
26390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
26391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26392 if (SWIG_arg_fail(1)) SWIG_fail;
26393 {
26394 PyThreadState* __tstate = wxPyBeginAllowThreads();
26395 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
26396
26397 wxPyEndAllowThreads(__tstate);
26398 if (PyErr_Occurred()) SWIG_fail;
26399 }
26400 {
26401 resultobj = SWIG_From_int(static_cast<int >(result));
26402 }
26403 return resultobj;
26404 fail:
26405 return NULL;
26406 }
26407
26408
26409 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
26410 PyObject *resultobj = NULL;
26411 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26412 wxLongLong result;
26413 PyObject * obj0 = 0 ;
26414 char *kwnames[] = {
26415 (char *) "self", NULL
26416 };
26417
26418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
26419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26420 if (SWIG_arg_fail(1)) SWIG_fail;
26421 {
26422 PyThreadState* __tstate = wxPyBeginAllowThreads();
26423 result = ((wxTimeSpan const *)arg1)->GetSeconds();
26424
26425 wxPyEndAllowThreads(__tstate);
26426 if (PyErr_Occurred()) SWIG_fail;
26427 }
26428 {
26429 PyObject *hi, *lo, *shifter, *shifted;
26430 hi = PyLong_FromLong( (&result)->GetHi() );
26431 lo = PyLong_FromLong( (&result)->GetLo() );
26432 shifter = PyLong_FromLong(32);
26433 shifted = PyNumber_Lshift(hi, shifter);
26434 resultobj = PyNumber_Or(shifted, lo);
26435 Py_DECREF(hi);
26436 Py_DECREF(lo);
26437 Py_DECREF(shifter);
26438 Py_DECREF(shifted);
26439 }
26440 return resultobj;
26441 fail:
26442 return NULL;
26443 }
26444
26445
26446 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
26447 PyObject *resultobj = NULL;
26448 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26449 wxLongLong result;
26450 PyObject * obj0 = 0 ;
26451 char *kwnames[] = {
26452 (char *) "self", NULL
26453 };
26454
26455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
26456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26457 if (SWIG_arg_fail(1)) SWIG_fail;
26458 {
26459 PyThreadState* __tstate = wxPyBeginAllowThreads();
26460 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
26461
26462 wxPyEndAllowThreads(__tstate);
26463 if (PyErr_Occurred()) SWIG_fail;
26464 }
26465 {
26466 PyObject *hi, *lo, *shifter, *shifted;
26467 hi = PyLong_FromLong( (&result)->GetHi() );
26468 lo = PyLong_FromLong( (&result)->GetLo() );
26469 shifter = PyLong_FromLong(32);
26470 shifted = PyNumber_Lshift(hi, shifter);
26471 resultobj = PyNumber_Or(shifted, lo);
26472 Py_DECREF(hi);
26473 Py_DECREF(lo);
26474 Py_DECREF(shifter);
26475 Py_DECREF(shifted);
26476 }
26477 return resultobj;
26478 fail:
26479 return NULL;
26480 }
26481
26482
26483 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
26484 PyObject *resultobj = NULL;
26485 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26486 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
26487 wxString *arg2 = (wxString *) &arg2_defvalue ;
26488 wxString result;
26489 bool temp2 = false ;
26490 PyObject * obj0 = 0 ;
26491 PyObject * obj1 = 0 ;
26492 char *kwnames[] = {
26493 (char *) "self",(char *) "format", NULL
26494 };
26495
26496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
26497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26498 if (SWIG_arg_fail(1)) SWIG_fail;
26499 if (obj1) {
26500 {
26501 arg2 = wxString_in_helper(obj1);
26502 if (arg2 == NULL) SWIG_fail;
26503 temp2 = true;
26504 }
26505 }
26506 {
26507 PyThreadState* __tstate = wxPyBeginAllowThreads();
26508 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
26509
26510 wxPyEndAllowThreads(__tstate);
26511 if (PyErr_Occurred()) SWIG_fail;
26512 }
26513 {
26514 #if wxUSE_UNICODE
26515 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26516 #else
26517 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26518 #endif
26519 }
26520 {
26521 if (temp2)
26522 delete arg2;
26523 }
26524 return resultobj;
26525 fail:
26526 {
26527 if (temp2)
26528 delete arg2;
26529 }
26530 return NULL;
26531 }
26532
26533
26534 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
26535 PyObject *obj;
26536 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26537 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
26538 Py_INCREF(obj);
26539 return Py_BuildValue((char *)"");
26540 }
26541 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
26542 PyObject *resultobj = NULL;
26543 int arg1 = (int) 0 ;
26544 int arg2 = (int) 0 ;
26545 int arg3 = (int) 0 ;
26546 int arg4 = (int) 0 ;
26547 wxDateSpan *result;
26548 PyObject * obj0 = 0 ;
26549 PyObject * obj1 = 0 ;
26550 PyObject * obj2 = 0 ;
26551 PyObject * obj3 = 0 ;
26552 char *kwnames[] = {
26553 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
26554 };
26555
26556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26557 if (obj0) {
26558 {
26559 arg1 = static_cast<int >(SWIG_As_int(obj0));
26560 if (SWIG_arg_fail(1)) SWIG_fail;
26561 }
26562 }
26563 if (obj1) {
26564 {
26565 arg2 = static_cast<int >(SWIG_As_int(obj1));
26566 if (SWIG_arg_fail(2)) SWIG_fail;
26567 }
26568 }
26569 if (obj2) {
26570 {
26571 arg3 = static_cast<int >(SWIG_As_int(obj2));
26572 if (SWIG_arg_fail(3)) SWIG_fail;
26573 }
26574 }
26575 if (obj3) {
26576 {
26577 arg4 = static_cast<int >(SWIG_As_int(obj3));
26578 if (SWIG_arg_fail(4)) SWIG_fail;
26579 }
26580 }
26581 {
26582 PyThreadState* __tstate = wxPyBeginAllowThreads();
26583 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
26584
26585 wxPyEndAllowThreads(__tstate);
26586 if (PyErr_Occurred()) SWIG_fail;
26587 }
26588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26589 return resultobj;
26590 fail:
26591 return NULL;
26592 }
26593
26594
26595 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
26596 PyObject *resultobj = NULL;
26597 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26598 PyObject * obj0 = 0 ;
26599 char *kwnames[] = {
26600 (char *) "self", NULL
26601 };
26602
26603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
26604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26605 if (SWIG_arg_fail(1)) SWIG_fail;
26606 {
26607 PyThreadState* __tstate = wxPyBeginAllowThreads();
26608 delete arg1;
26609
26610 wxPyEndAllowThreads(__tstate);
26611 if (PyErr_Occurred()) SWIG_fail;
26612 }
26613 Py_INCREF(Py_None); resultobj = Py_None;
26614 return resultobj;
26615 fail:
26616 return NULL;
26617 }
26618
26619
26620 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
26621 PyObject *resultobj = NULL;
26622 int arg1 ;
26623 wxDateSpan result;
26624 PyObject * obj0 = 0 ;
26625 char *kwnames[] = {
26626 (char *) "days", NULL
26627 };
26628
26629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
26630 {
26631 arg1 = static_cast<int >(SWIG_As_int(obj0));
26632 if (SWIG_arg_fail(1)) SWIG_fail;
26633 }
26634 {
26635 PyThreadState* __tstate = wxPyBeginAllowThreads();
26636 result = wxDateSpan::Days(arg1);
26637
26638 wxPyEndAllowThreads(__tstate);
26639 if (PyErr_Occurred()) SWIG_fail;
26640 }
26641 {
26642 wxDateSpan * resultptr;
26643 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26644 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26645 }
26646 return resultobj;
26647 fail:
26648 return NULL;
26649 }
26650
26651
26652 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
26653 PyObject *resultobj = NULL;
26654 wxDateSpan result;
26655 char *kwnames[] = {
26656 NULL
26657 };
26658
26659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
26660 {
26661 PyThreadState* __tstate = wxPyBeginAllowThreads();
26662 result = wxDateSpan::Day();
26663
26664 wxPyEndAllowThreads(__tstate);
26665 if (PyErr_Occurred()) SWIG_fail;
26666 }
26667 {
26668 wxDateSpan * resultptr;
26669 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26670 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26671 }
26672 return resultobj;
26673 fail:
26674 return NULL;
26675 }
26676
26677
26678 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
26679 PyObject *resultobj = NULL;
26680 int arg1 ;
26681 wxDateSpan result;
26682 PyObject * obj0 = 0 ;
26683 char *kwnames[] = {
26684 (char *) "weeks", NULL
26685 };
26686
26687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
26688 {
26689 arg1 = static_cast<int >(SWIG_As_int(obj0));
26690 if (SWIG_arg_fail(1)) SWIG_fail;
26691 }
26692 {
26693 PyThreadState* __tstate = wxPyBeginAllowThreads();
26694 result = wxDateSpan::Weeks(arg1);
26695
26696 wxPyEndAllowThreads(__tstate);
26697 if (PyErr_Occurred()) SWIG_fail;
26698 }
26699 {
26700 wxDateSpan * resultptr;
26701 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26702 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26703 }
26704 return resultobj;
26705 fail:
26706 return NULL;
26707 }
26708
26709
26710 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
26711 PyObject *resultobj = NULL;
26712 wxDateSpan result;
26713 char *kwnames[] = {
26714 NULL
26715 };
26716
26717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
26718 {
26719 PyThreadState* __tstate = wxPyBeginAllowThreads();
26720 result = wxDateSpan::Week();
26721
26722 wxPyEndAllowThreads(__tstate);
26723 if (PyErr_Occurred()) SWIG_fail;
26724 }
26725 {
26726 wxDateSpan * resultptr;
26727 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26728 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26729 }
26730 return resultobj;
26731 fail:
26732 return NULL;
26733 }
26734
26735
26736 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
26737 PyObject *resultobj = NULL;
26738 int arg1 ;
26739 wxDateSpan result;
26740 PyObject * obj0 = 0 ;
26741 char *kwnames[] = {
26742 (char *) "mon", NULL
26743 };
26744
26745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
26746 {
26747 arg1 = static_cast<int >(SWIG_As_int(obj0));
26748 if (SWIG_arg_fail(1)) SWIG_fail;
26749 }
26750 {
26751 PyThreadState* __tstate = wxPyBeginAllowThreads();
26752 result = wxDateSpan::Months(arg1);
26753
26754 wxPyEndAllowThreads(__tstate);
26755 if (PyErr_Occurred()) SWIG_fail;
26756 }
26757 {
26758 wxDateSpan * resultptr;
26759 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26760 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26761 }
26762 return resultobj;
26763 fail:
26764 return NULL;
26765 }
26766
26767
26768 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
26769 PyObject *resultobj = NULL;
26770 wxDateSpan result;
26771 char *kwnames[] = {
26772 NULL
26773 };
26774
26775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
26776 {
26777 PyThreadState* __tstate = wxPyBeginAllowThreads();
26778 result = wxDateSpan::Month();
26779
26780 wxPyEndAllowThreads(__tstate);
26781 if (PyErr_Occurred()) SWIG_fail;
26782 }
26783 {
26784 wxDateSpan * resultptr;
26785 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26786 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26787 }
26788 return resultobj;
26789 fail:
26790 return NULL;
26791 }
26792
26793
26794 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
26795 PyObject *resultobj = NULL;
26796 int arg1 ;
26797 wxDateSpan result;
26798 PyObject * obj0 = 0 ;
26799 char *kwnames[] = {
26800 (char *) "years", NULL
26801 };
26802
26803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
26804 {
26805 arg1 = static_cast<int >(SWIG_As_int(obj0));
26806 if (SWIG_arg_fail(1)) SWIG_fail;
26807 }
26808 {
26809 PyThreadState* __tstate = wxPyBeginAllowThreads();
26810 result = wxDateSpan::Years(arg1);
26811
26812 wxPyEndAllowThreads(__tstate);
26813 if (PyErr_Occurred()) SWIG_fail;
26814 }
26815 {
26816 wxDateSpan * resultptr;
26817 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26818 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26819 }
26820 return resultobj;
26821 fail:
26822 return NULL;
26823 }
26824
26825
26826 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
26827 PyObject *resultobj = NULL;
26828 wxDateSpan result;
26829 char *kwnames[] = {
26830 NULL
26831 };
26832
26833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
26834 {
26835 PyThreadState* __tstate = wxPyBeginAllowThreads();
26836 result = wxDateSpan::Year();
26837
26838 wxPyEndAllowThreads(__tstate);
26839 if (PyErr_Occurred()) SWIG_fail;
26840 }
26841 {
26842 wxDateSpan * resultptr;
26843 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26844 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26845 }
26846 return resultobj;
26847 fail:
26848 return NULL;
26849 }
26850
26851
26852 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
26853 PyObject *resultobj = NULL;
26854 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26855 int arg2 ;
26856 wxDateSpan *result;
26857 PyObject * obj0 = 0 ;
26858 PyObject * obj1 = 0 ;
26859 char *kwnames[] = {
26860 (char *) "self",(char *) "n", NULL
26861 };
26862
26863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
26864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26865 if (SWIG_arg_fail(1)) SWIG_fail;
26866 {
26867 arg2 = static_cast<int >(SWIG_As_int(obj1));
26868 if (SWIG_arg_fail(2)) SWIG_fail;
26869 }
26870 {
26871 PyThreadState* __tstate = wxPyBeginAllowThreads();
26872 {
26873 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
26874 result = (wxDateSpan *) &_result_ref;
26875 }
26876
26877 wxPyEndAllowThreads(__tstate);
26878 if (PyErr_Occurred()) SWIG_fail;
26879 }
26880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26881 return resultobj;
26882 fail:
26883 return NULL;
26884 }
26885
26886
26887 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
26888 PyObject *resultobj = NULL;
26889 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26890 int arg2 ;
26891 wxDateSpan *result;
26892 PyObject * obj0 = 0 ;
26893 PyObject * obj1 = 0 ;
26894 char *kwnames[] = {
26895 (char *) "self",(char *) "n", NULL
26896 };
26897
26898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
26899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26900 if (SWIG_arg_fail(1)) SWIG_fail;
26901 {
26902 arg2 = static_cast<int >(SWIG_As_int(obj1));
26903 if (SWIG_arg_fail(2)) SWIG_fail;
26904 }
26905 {
26906 PyThreadState* __tstate = wxPyBeginAllowThreads();
26907 {
26908 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
26909 result = (wxDateSpan *) &_result_ref;
26910 }
26911
26912 wxPyEndAllowThreads(__tstate);
26913 if (PyErr_Occurred()) SWIG_fail;
26914 }
26915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26916 return resultobj;
26917 fail:
26918 return NULL;
26919 }
26920
26921
26922 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
26923 PyObject *resultobj = NULL;
26924 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26925 int arg2 ;
26926 wxDateSpan *result;
26927 PyObject * obj0 = 0 ;
26928 PyObject * obj1 = 0 ;
26929 char *kwnames[] = {
26930 (char *) "self",(char *) "n", NULL
26931 };
26932
26933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
26934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26935 if (SWIG_arg_fail(1)) SWIG_fail;
26936 {
26937 arg2 = static_cast<int >(SWIG_As_int(obj1));
26938 if (SWIG_arg_fail(2)) SWIG_fail;
26939 }
26940 {
26941 PyThreadState* __tstate = wxPyBeginAllowThreads();
26942 {
26943 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
26944 result = (wxDateSpan *) &_result_ref;
26945 }
26946
26947 wxPyEndAllowThreads(__tstate);
26948 if (PyErr_Occurred()) SWIG_fail;
26949 }
26950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26951 return resultobj;
26952 fail:
26953 return NULL;
26954 }
26955
26956
26957 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
26958 PyObject *resultobj = NULL;
26959 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26960 int arg2 ;
26961 wxDateSpan *result;
26962 PyObject * obj0 = 0 ;
26963 PyObject * obj1 = 0 ;
26964 char *kwnames[] = {
26965 (char *) "self",(char *) "n", NULL
26966 };
26967
26968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
26969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26970 if (SWIG_arg_fail(1)) SWIG_fail;
26971 {
26972 arg2 = static_cast<int >(SWIG_As_int(obj1));
26973 if (SWIG_arg_fail(2)) SWIG_fail;
26974 }
26975 {
26976 PyThreadState* __tstate = wxPyBeginAllowThreads();
26977 {
26978 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
26979 result = (wxDateSpan *) &_result_ref;
26980 }
26981
26982 wxPyEndAllowThreads(__tstate);
26983 if (PyErr_Occurred()) SWIG_fail;
26984 }
26985 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26986 return resultobj;
26987 fail:
26988 return NULL;
26989 }
26990
26991
26992 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
26993 PyObject *resultobj = NULL;
26994 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26995 int result;
26996 PyObject * obj0 = 0 ;
26997 char *kwnames[] = {
26998 (char *) "self", NULL
26999 };
27000
27001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
27002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27003 if (SWIG_arg_fail(1)) SWIG_fail;
27004 {
27005 PyThreadState* __tstate = wxPyBeginAllowThreads();
27006 result = (int)((wxDateSpan const *)arg1)->GetYears();
27007
27008 wxPyEndAllowThreads(__tstate);
27009 if (PyErr_Occurred()) SWIG_fail;
27010 }
27011 {
27012 resultobj = SWIG_From_int(static_cast<int >(result));
27013 }
27014 return resultobj;
27015 fail:
27016 return NULL;
27017 }
27018
27019
27020 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
27021 PyObject *resultobj = NULL;
27022 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27023 int result;
27024 PyObject * obj0 = 0 ;
27025 char *kwnames[] = {
27026 (char *) "self", NULL
27027 };
27028
27029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
27030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27031 if (SWIG_arg_fail(1)) SWIG_fail;
27032 {
27033 PyThreadState* __tstate = wxPyBeginAllowThreads();
27034 result = (int)((wxDateSpan const *)arg1)->GetMonths();
27035
27036 wxPyEndAllowThreads(__tstate);
27037 if (PyErr_Occurred()) SWIG_fail;
27038 }
27039 {
27040 resultobj = SWIG_From_int(static_cast<int >(result));
27041 }
27042 return resultobj;
27043 fail:
27044 return NULL;
27045 }
27046
27047
27048 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
27049 PyObject *resultobj = NULL;
27050 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27051 int result;
27052 PyObject * obj0 = 0 ;
27053 char *kwnames[] = {
27054 (char *) "self", NULL
27055 };
27056
27057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
27058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27059 if (SWIG_arg_fail(1)) SWIG_fail;
27060 {
27061 PyThreadState* __tstate = wxPyBeginAllowThreads();
27062 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
27063
27064 wxPyEndAllowThreads(__tstate);
27065 if (PyErr_Occurred()) SWIG_fail;
27066 }
27067 {
27068 resultobj = SWIG_From_int(static_cast<int >(result));
27069 }
27070 return resultobj;
27071 fail:
27072 return NULL;
27073 }
27074
27075
27076 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
27077 PyObject *resultobj = NULL;
27078 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27079 int result;
27080 PyObject * obj0 = 0 ;
27081 char *kwnames[] = {
27082 (char *) "self", NULL
27083 };
27084
27085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
27086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27087 if (SWIG_arg_fail(1)) SWIG_fail;
27088 {
27089 PyThreadState* __tstate = wxPyBeginAllowThreads();
27090 result = (int)((wxDateSpan const *)arg1)->GetDays();
27091
27092 wxPyEndAllowThreads(__tstate);
27093 if (PyErr_Occurred()) SWIG_fail;
27094 }
27095 {
27096 resultobj = SWIG_From_int(static_cast<int >(result));
27097 }
27098 return resultobj;
27099 fail:
27100 return NULL;
27101 }
27102
27103
27104 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
27105 PyObject *resultobj = NULL;
27106 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27107 int result;
27108 PyObject * obj0 = 0 ;
27109 char *kwnames[] = {
27110 (char *) "self", NULL
27111 };
27112
27113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
27114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27115 if (SWIG_arg_fail(1)) SWIG_fail;
27116 {
27117 PyThreadState* __tstate = wxPyBeginAllowThreads();
27118 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
27119
27120 wxPyEndAllowThreads(__tstate);
27121 if (PyErr_Occurred()) SWIG_fail;
27122 }
27123 {
27124 resultobj = SWIG_From_int(static_cast<int >(result));
27125 }
27126 return resultobj;
27127 fail:
27128 return NULL;
27129 }
27130
27131
27132 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27133 PyObject *resultobj = NULL;
27134 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27135 wxDateSpan *arg2 = 0 ;
27136 wxDateSpan *result;
27137 PyObject * obj0 = 0 ;
27138 PyObject * obj1 = 0 ;
27139 char *kwnames[] = {
27140 (char *) "self",(char *) "other", NULL
27141 };
27142
27143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
27144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27145 if (SWIG_arg_fail(1)) SWIG_fail;
27146 {
27147 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27148 if (SWIG_arg_fail(2)) SWIG_fail;
27149 if (arg2 == NULL) {
27150 SWIG_null_ref("wxDateSpan");
27151 }
27152 if (SWIG_arg_fail(2)) SWIG_fail;
27153 }
27154 {
27155 PyThreadState* __tstate = wxPyBeginAllowThreads();
27156 {
27157 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27158 result = (wxDateSpan *) &_result_ref;
27159 }
27160
27161 wxPyEndAllowThreads(__tstate);
27162 if (PyErr_Occurred()) SWIG_fail;
27163 }
27164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27165 return resultobj;
27166 fail:
27167 return NULL;
27168 }
27169
27170
27171 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
27172 PyObject *resultobj = NULL;
27173 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27174 wxDateSpan *arg2 = 0 ;
27175 wxDateSpan *result;
27176 PyObject * obj0 = 0 ;
27177 PyObject * obj1 = 0 ;
27178 char *kwnames[] = {
27179 (char *) "self",(char *) "other", NULL
27180 };
27181
27182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
27183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27184 if (SWIG_arg_fail(1)) SWIG_fail;
27185 {
27186 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27187 if (SWIG_arg_fail(2)) SWIG_fail;
27188 if (arg2 == NULL) {
27189 SWIG_null_ref("wxDateSpan");
27190 }
27191 if (SWIG_arg_fail(2)) SWIG_fail;
27192 }
27193 {
27194 PyThreadState* __tstate = wxPyBeginAllowThreads();
27195 {
27196 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27197 result = (wxDateSpan *) &_result_ref;
27198 }
27199
27200 wxPyEndAllowThreads(__tstate);
27201 if (PyErr_Occurred()) SWIG_fail;
27202 }
27203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27204 return resultobj;
27205 fail:
27206 return NULL;
27207 }
27208
27209
27210 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
27211 PyObject *resultobj = NULL;
27212 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27213 wxDateSpan *result;
27214 PyObject * obj0 = 0 ;
27215 char *kwnames[] = {
27216 (char *) "self", NULL
27217 };
27218
27219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
27220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27221 if (SWIG_arg_fail(1)) SWIG_fail;
27222 {
27223 PyThreadState* __tstate = wxPyBeginAllowThreads();
27224 {
27225 wxDateSpan &_result_ref = (arg1)->Neg();
27226 result = (wxDateSpan *) &_result_ref;
27227 }
27228
27229 wxPyEndAllowThreads(__tstate);
27230 if (PyErr_Occurred()) SWIG_fail;
27231 }
27232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27233 return resultobj;
27234 fail:
27235 return NULL;
27236 }
27237
27238
27239 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
27240 PyObject *resultobj = NULL;
27241 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27242 int arg2 ;
27243 wxDateSpan *result;
27244 PyObject * obj0 = 0 ;
27245 PyObject * obj1 = 0 ;
27246 char *kwnames[] = {
27247 (char *) "self",(char *) "factor", NULL
27248 };
27249
27250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
27251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27252 if (SWIG_arg_fail(1)) SWIG_fail;
27253 {
27254 arg2 = static_cast<int >(SWIG_As_int(obj1));
27255 if (SWIG_arg_fail(2)) SWIG_fail;
27256 }
27257 {
27258 PyThreadState* __tstate = wxPyBeginAllowThreads();
27259 {
27260 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
27261 result = (wxDateSpan *) &_result_ref;
27262 }
27263
27264 wxPyEndAllowThreads(__tstate);
27265 if (PyErr_Occurred()) SWIG_fail;
27266 }
27267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27268 return resultobj;
27269 fail:
27270 return NULL;
27271 }
27272
27273
27274 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
27275 PyObject *resultobj = NULL;
27276 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27277 wxDateSpan *arg2 = 0 ;
27278 wxDateSpan *result;
27279 PyObject * obj0 = 0 ;
27280 PyObject * obj1 = 0 ;
27281 char *kwnames[] = {
27282 (char *) "self",(char *) "other", NULL
27283 };
27284
27285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
27286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27287 if (SWIG_arg_fail(1)) SWIG_fail;
27288 {
27289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27290 if (SWIG_arg_fail(2)) SWIG_fail;
27291 if (arg2 == NULL) {
27292 SWIG_null_ref("wxDateSpan");
27293 }
27294 if (SWIG_arg_fail(2)) SWIG_fail;
27295 }
27296 {
27297 PyThreadState* __tstate = wxPyBeginAllowThreads();
27298 {
27299 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27300 result = (wxDateSpan *) &_result_ref;
27301 }
27302
27303 wxPyEndAllowThreads(__tstate);
27304 if (PyErr_Occurred()) SWIG_fail;
27305 }
27306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
27307 return resultobj;
27308 fail:
27309 return NULL;
27310 }
27311
27312
27313 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
27314 PyObject *resultobj = NULL;
27315 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27316 wxDateSpan *arg2 = 0 ;
27317 wxDateSpan *result;
27318 PyObject * obj0 = 0 ;
27319 PyObject * obj1 = 0 ;
27320 char *kwnames[] = {
27321 (char *) "self",(char *) "other", NULL
27322 };
27323
27324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
27325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27326 if (SWIG_arg_fail(1)) SWIG_fail;
27327 {
27328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27329 if (SWIG_arg_fail(2)) SWIG_fail;
27330 if (arg2 == NULL) {
27331 SWIG_null_ref("wxDateSpan");
27332 }
27333 if (SWIG_arg_fail(2)) SWIG_fail;
27334 }
27335 {
27336 PyThreadState* __tstate = wxPyBeginAllowThreads();
27337 {
27338 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27339 result = (wxDateSpan *) &_result_ref;
27340 }
27341
27342 wxPyEndAllowThreads(__tstate);
27343 if (PyErr_Occurred()) SWIG_fail;
27344 }
27345 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
27346 return resultobj;
27347 fail:
27348 return NULL;
27349 }
27350
27351
27352 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
27353 PyObject *resultobj = NULL;
27354 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27355 wxDateSpan *result;
27356 PyObject * obj0 = 0 ;
27357 char *kwnames[] = {
27358 (char *) "self", NULL
27359 };
27360
27361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
27362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27363 if (SWIG_arg_fail(1)) SWIG_fail;
27364 {
27365 PyThreadState* __tstate = wxPyBeginAllowThreads();
27366 {
27367 wxDateSpan &_result_ref = (arg1)->operator -();
27368 result = (wxDateSpan *) &_result_ref;
27369 }
27370
27371 wxPyEndAllowThreads(__tstate);
27372 if (PyErr_Occurred()) SWIG_fail;
27373 }
27374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27375 return resultobj;
27376 fail:
27377 return NULL;
27378 }
27379
27380
27381 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
27382 PyObject *resultobj = NULL;
27383 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27384 int arg2 ;
27385 wxDateSpan *result;
27386 PyObject * obj0 = 0 ;
27387 PyObject * obj1 = 0 ;
27388 char *kwnames[] = {
27389 (char *) "self",(char *) "factor", NULL
27390 };
27391
27392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
27393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27394 if (SWIG_arg_fail(1)) SWIG_fail;
27395 {
27396 arg2 = static_cast<int >(SWIG_As_int(obj1));
27397 if (SWIG_arg_fail(2)) SWIG_fail;
27398 }
27399 {
27400 PyThreadState* __tstate = wxPyBeginAllowThreads();
27401 {
27402 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
27403 result = (wxDateSpan *) &_result_ref;
27404 }
27405
27406 wxPyEndAllowThreads(__tstate);
27407 if (PyErr_Occurred()) SWIG_fail;
27408 }
27409 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
27410 return resultobj;
27411 fail:
27412 return NULL;
27413 }
27414
27415
27416 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
27417 PyObject *resultobj = NULL;
27418 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27419 wxDateSpan *arg2 = 0 ;
27420 wxDateSpan result;
27421 PyObject * obj0 = 0 ;
27422 PyObject * obj1 = 0 ;
27423 char *kwnames[] = {
27424 (char *) "self",(char *) "other", NULL
27425 };
27426
27427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
27428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27429 if (SWIG_arg_fail(1)) SWIG_fail;
27430 {
27431 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27432 if (SWIG_arg_fail(2)) SWIG_fail;
27433 if (arg2 == NULL) {
27434 SWIG_null_ref("wxDateSpan");
27435 }
27436 if (SWIG_arg_fail(2)) SWIG_fail;
27437 }
27438 {
27439 PyThreadState* __tstate = wxPyBeginAllowThreads();
27440 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
27441
27442 wxPyEndAllowThreads(__tstate);
27443 if (PyErr_Occurred()) SWIG_fail;
27444 }
27445 {
27446 wxDateSpan * resultptr;
27447 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
27448 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
27449 }
27450 return resultobj;
27451 fail:
27452 return NULL;
27453 }
27454
27455
27456 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
27457 PyObject *resultobj = NULL;
27458 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27459 wxDateSpan *arg2 = 0 ;
27460 wxDateSpan result;
27461 PyObject * obj0 = 0 ;
27462 PyObject * obj1 = 0 ;
27463 char *kwnames[] = {
27464 (char *) "self",(char *) "other", NULL
27465 };
27466
27467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
27468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27469 if (SWIG_arg_fail(1)) SWIG_fail;
27470 {
27471 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27472 if (SWIG_arg_fail(2)) SWIG_fail;
27473 if (arg2 == NULL) {
27474 SWIG_null_ref("wxDateSpan");
27475 }
27476 if (SWIG_arg_fail(2)) SWIG_fail;
27477 }
27478 {
27479 PyThreadState* __tstate = wxPyBeginAllowThreads();
27480 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
27481
27482 wxPyEndAllowThreads(__tstate);
27483 if (PyErr_Occurred()) SWIG_fail;
27484 }
27485 {
27486 wxDateSpan * resultptr;
27487 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
27488 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
27489 }
27490 return resultobj;
27491 fail:
27492 return NULL;
27493 }
27494
27495
27496 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
27497 PyObject *resultobj = NULL;
27498 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27499 int arg2 ;
27500 wxDateSpan result;
27501 PyObject * obj0 = 0 ;
27502 PyObject * obj1 = 0 ;
27503 char *kwnames[] = {
27504 (char *) "self",(char *) "n", NULL
27505 };
27506
27507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
27508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27509 if (SWIG_arg_fail(1)) SWIG_fail;
27510 {
27511 arg2 = static_cast<int >(SWIG_As_int(obj1));
27512 if (SWIG_arg_fail(2)) SWIG_fail;
27513 }
27514 {
27515 PyThreadState* __tstate = wxPyBeginAllowThreads();
27516 result = wxDateSpan___mul__(arg1,arg2);
27517
27518 wxPyEndAllowThreads(__tstate);
27519 if (PyErr_Occurred()) SWIG_fail;
27520 }
27521 {
27522 wxDateSpan * resultptr;
27523 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
27524 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
27525 }
27526 return resultobj;
27527 fail:
27528 return NULL;
27529 }
27530
27531
27532 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
27533 PyObject *resultobj = NULL;
27534 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27535 int arg2 ;
27536 wxDateSpan result;
27537 PyObject * obj0 = 0 ;
27538 PyObject * obj1 = 0 ;
27539 char *kwnames[] = {
27540 (char *) "self",(char *) "n", NULL
27541 };
27542
27543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
27544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27545 if (SWIG_arg_fail(1)) SWIG_fail;
27546 {
27547 arg2 = static_cast<int >(SWIG_As_int(obj1));
27548 if (SWIG_arg_fail(2)) SWIG_fail;
27549 }
27550 {
27551 PyThreadState* __tstate = wxPyBeginAllowThreads();
27552 result = wxDateSpan___rmul__(arg1,arg2);
27553
27554 wxPyEndAllowThreads(__tstate);
27555 if (PyErr_Occurred()) SWIG_fail;
27556 }
27557 {
27558 wxDateSpan * resultptr;
27559 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
27560 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
27561 }
27562 return resultobj;
27563 fail:
27564 return NULL;
27565 }
27566
27567
27568 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
27569 PyObject *resultobj = NULL;
27570 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27571 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
27572 bool result;
27573 PyObject * obj0 = 0 ;
27574 PyObject * obj1 = 0 ;
27575 char *kwnames[] = {
27576 (char *) "self",(char *) "other", NULL
27577 };
27578
27579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
27580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27581 if (SWIG_arg_fail(1)) SWIG_fail;
27582 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27583 if (SWIG_arg_fail(2)) SWIG_fail;
27584 {
27585 PyThreadState* __tstate = wxPyBeginAllowThreads();
27586 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
27587
27588 wxPyEndAllowThreads(__tstate);
27589 if (PyErr_Occurred()) SWIG_fail;
27590 }
27591 {
27592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27593 }
27594 return resultobj;
27595 fail:
27596 return NULL;
27597 }
27598
27599
27600 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
27601 PyObject *resultobj = NULL;
27602 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27603 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
27604 bool result;
27605 PyObject * obj0 = 0 ;
27606 PyObject * obj1 = 0 ;
27607 char *kwnames[] = {
27608 (char *) "self",(char *) "other", NULL
27609 };
27610
27611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
27612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27613 if (SWIG_arg_fail(1)) SWIG_fail;
27614 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27615 if (SWIG_arg_fail(2)) SWIG_fail;
27616 {
27617 PyThreadState* __tstate = wxPyBeginAllowThreads();
27618 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
27619
27620 wxPyEndAllowThreads(__tstate);
27621 if (PyErr_Occurred()) SWIG_fail;
27622 }
27623 {
27624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27625 }
27626 return resultobj;
27627 fail:
27628 return NULL;
27629 }
27630
27631
27632 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
27633 PyObject *obj;
27634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27635 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
27636 Py_INCREF(obj);
27637 return Py_BuildValue((char *)"");
27638 }
27639 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
27640 PyObject *resultobj = NULL;
27641 long result;
27642 char *kwnames[] = {
27643 NULL
27644 };
27645
27646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
27647 {
27648 PyThreadState* __tstate = wxPyBeginAllowThreads();
27649 result = (long)wxGetLocalTime();
27650
27651 wxPyEndAllowThreads(__tstate);
27652 if (PyErr_Occurred()) SWIG_fail;
27653 }
27654 {
27655 resultobj = SWIG_From_long(static_cast<long >(result));
27656 }
27657 return resultobj;
27658 fail:
27659 return NULL;
27660 }
27661
27662
27663 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
27664 PyObject *resultobj = NULL;
27665 long result;
27666 char *kwnames[] = {
27667 NULL
27668 };
27669
27670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
27671 {
27672 PyThreadState* __tstate = wxPyBeginAllowThreads();
27673 result = (long)wxGetUTCTime();
27674
27675 wxPyEndAllowThreads(__tstate);
27676 if (PyErr_Occurred()) SWIG_fail;
27677 }
27678 {
27679 resultobj = SWIG_From_long(static_cast<long >(result));
27680 }
27681 return resultobj;
27682 fail:
27683 return NULL;
27684 }
27685
27686
27687 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
27688 PyObject *resultobj = NULL;
27689 long result;
27690 char *kwnames[] = {
27691 NULL
27692 };
27693
27694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
27695 {
27696 PyThreadState* __tstate = wxPyBeginAllowThreads();
27697 result = (long)wxGetCurrentTime();
27698
27699 wxPyEndAllowThreads(__tstate);
27700 if (PyErr_Occurred()) SWIG_fail;
27701 }
27702 {
27703 resultobj = SWIG_From_long(static_cast<long >(result));
27704 }
27705 return resultobj;
27706 fail:
27707 return NULL;
27708 }
27709
27710
27711 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
27712 PyObject *resultobj = NULL;
27713 wxLongLong result;
27714 char *kwnames[] = {
27715 NULL
27716 };
27717
27718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
27719 {
27720 PyThreadState* __tstate = wxPyBeginAllowThreads();
27721 result = wxGetLocalTimeMillis();
27722
27723 wxPyEndAllowThreads(__tstate);
27724 if (PyErr_Occurred()) SWIG_fail;
27725 }
27726 {
27727 PyObject *hi, *lo, *shifter, *shifted;
27728 hi = PyLong_FromLong( (&result)->GetHi() );
27729 lo = PyLong_FromLong( (&result)->GetLo() );
27730 shifter = PyLong_FromLong(32);
27731 shifted = PyNumber_Lshift(hi, shifter);
27732 resultobj = PyNumber_Or(shifted, lo);
27733 Py_DECREF(hi);
27734 Py_DECREF(lo);
27735 Py_DECREF(shifter);
27736 Py_DECREF(shifted);
27737 }
27738 return resultobj;
27739 fail:
27740 return NULL;
27741 }
27742
27743
27744 static int _wrap_DefaultDateTime_set(PyObject *) {
27745 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
27746 return 1;
27747 }
27748
27749
27750 static PyObject *_wrap_DefaultDateTime_get(void) {
27751 PyObject *pyobj = NULL;
27752
27753 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
27754 return pyobj;
27755 }
27756
27757
27758 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27759 PyObject *resultobj = NULL;
27760 wxDataFormatId arg1 ;
27761 wxDataFormat *result;
27762 PyObject * obj0 = 0 ;
27763 char *kwnames[] = {
27764 (char *) "type", NULL
27765 };
27766
27767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
27768 {
27769 arg1 = static_cast<wxDataFormatId >(SWIG_As_int(obj0));
27770 if (SWIG_arg_fail(1)) SWIG_fail;
27771 }
27772 {
27773 PyThreadState* __tstate = wxPyBeginAllowThreads();
27774 result = (wxDataFormat *)new wxDataFormat(arg1);
27775
27776 wxPyEndAllowThreads(__tstate);
27777 if (PyErr_Occurred()) SWIG_fail;
27778 }
27779 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
27780 return resultobj;
27781 fail:
27782 return NULL;
27783 }
27784
27785
27786 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27787 PyObject *resultobj = NULL;
27788 wxString *arg1 = 0 ;
27789 wxDataFormat *result;
27790 bool temp1 = false ;
27791 PyObject * obj0 = 0 ;
27792 char *kwnames[] = {
27793 (char *) "format", NULL
27794 };
27795
27796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
27797 {
27798 arg1 = wxString_in_helper(obj0);
27799 if (arg1 == NULL) SWIG_fail;
27800 temp1 = true;
27801 }
27802 {
27803 PyThreadState* __tstate = wxPyBeginAllowThreads();
27804 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
27805
27806 wxPyEndAllowThreads(__tstate);
27807 if (PyErr_Occurred()) SWIG_fail;
27808 }
27809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
27810 {
27811 if (temp1)
27812 delete arg1;
27813 }
27814 return resultobj;
27815 fail:
27816 {
27817 if (temp1)
27818 delete arg1;
27819 }
27820 return NULL;
27821 }
27822
27823
27824 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27825 PyObject *resultobj = NULL;
27826 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27827 PyObject * obj0 = 0 ;
27828 char *kwnames[] = {
27829 (char *) "self", NULL
27830 };
27831
27832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
27833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27834 if (SWIG_arg_fail(1)) SWIG_fail;
27835 {
27836 PyThreadState* __tstate = wxPyBeginAllowThreads();
27837 delete arg1;
27838
27839 wxPyEndAllowThreads(__tstate);
27840 if (PyErr_Occurred()) SWIG_fail;
27841 }
27842 Py_INCREF(Py_None); resultobj = Py_None;
27843 return resultobj;
27844 fail:
27845 return NULL;
27846 }
27847
27848
27849 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
27850 PyObject *resultobj = NULL;
27851 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27852 wxDataFormatId arg2 ;
27853 bool result;
27854 PyObject * obj0 = 0 ;
27855 PyObject * obj1 = 0 ;
27856
27857 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
27858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27859 if (SWIG_arg_fail(1)) SWIG_fail;
27860 {
27861 arg2 = static_cast<wxDataFormatId >(SWIG_As_int(obj1));
27862 if (SWIG_arg_fail(2)) SWIG_fail;
27863 }
27864 {
27865 PyThreadState* __tstate = wxPyBeginAllowThreads();
27866 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
27867
27868 wxPyEndAllowThreads(__tstate);
27869 if (PyErr_Occurred()) SWIG_fail;
27870 }
27871 {
27872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27873 }
27874 return resultobj;
27875 fail:
27876 return NULL;
27877 }
27878
27879
27880 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
27881 PyObject *resultobj = NULL;
27882 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27883 wxDataFormatId arg2 ;
27884 bool result;
27885 PyObject * obj0 = 0 ;
27886 PyObject * obj1 = 0 ;
27887
27888 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
27889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27890 if (SWIG_arg_fail(1)) SWIG_fail;
27891 {
27892 arg2 = static_cast<wxDataFormatId >(SWIG_As_int(obj1));
27893 if (SWIG_arg_fail(2)) SWIG_fail;
27894 }
27895 {
27896 PyThreadState* __tstate = wxPyBeginAllowThreads();
27897 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
27898
27899 wxPyEndAllowThreads(__tstate);
27900 if (PyErr_Occurred()) SWIG_fail;
27901 }
27902 {
27903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27904 }
27905 return resultobj;
27906 fail:
27907 return NULL;
27908 }
27909
27910
27911 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
27912 PyObject *resultobj = NULL;
27913 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27914 wxDataFormat *arg2 = 0 ;
27915 bool result;
27916 PyObject * obj0 = 0 ;
27917 PyObject * obj1 = 0 ;
27918
27919 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
27920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27921 if (SWIG_arg_fail(1)) SWIG_fail;
27922 {
27923 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27924 if (SWIG_arg_fail(2)) SWIG_fail;
27925 if (arg2 == NULL) {
27926 SWIG_null_ref("wxDataFormat");
27927 }
27928 if (SWIG_arg_fail(2)) SWIG_fail;
27929 }
27930 {
27931 PyThreadState* __tstate = wxPyBeginAllowThreads();
27932 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
27933
27934 wxPyEndAllowThreads(__tstate);
27935 if (PyErr_Occurred()) SWIG_fail;
27936 }
27937 {
27938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27939 }
27940 return resultobj;
27941 fail:
27942 return NULL;
27943 }
27944
27945
27946 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
27947 int argc;
27948 PyObject *argv[3];
27949 int ii;
27950
27951 argc = PyObject_Length(args);
27952 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
27953 argv[ii] = PyTuple_GetItem(args,ii);
27954 }
27955 if (argc == 2) {
27956 int _v;
27957 {
27958 void *ptr;
27959 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27960 _v = 0;
27961 PyErr_Clear();
27962 } else {
27963 _v = 1;
27964 }
27965 }
27966 if (_v) {
27967 {
27968 void *ptr = 0;
27969 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27970 _v = 0;
27971 PyErr_Clear();
27972 } else {
27973 _v = (ptr != 0);
27974 }
27975 }
27976 if (_v) {
27977 return _wrap_DataFormat___eq____SWIG_1(self,args);
27978 }
27979 }
27980 }
27981 if (argc == 2) {
27982 int _v;
27983 {
27984 void *ptr;
27985 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27986 _v = 0;
27987 PyErr_Clear();
27988 } else {
27989 _v = 1;
27990 }
27991 }
27992 if (_v) {
27993 _v = SWIG_Check_int(argv[1]);
27994 if (_v) {
27995 return _wrap_DataFormat___eq____SWIG_0(self,args);
27996 }
27997 }
27998 }
27999
28000 Py_INCREF(Py_NotImplemented);
28001 return Py_NotImplemented;
28002 }
28003
28004
28005 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
28006 PyObject *resultobj = NULL;
28007 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28008 wxDataFormat *arg2 = 0 ;
28009 bool result;
28010 PyObject * obj0 = 0 ;
28011 PyObject * obj1 = 0 ;
28012
28013 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
28014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28015 if (SWIG_arg_fail(1)) SWIG_fail;
28016 {
28017 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28018 if (SWIG_arg_fail(2)) SWIG_fail;
28019 if (arg2 == NULL) {
28020 SWIG_null_ref("wxDataFormat");
28021 }
28022 if (SWIG_arg_fail(2)) SWIG_fail;
28023 }
28024 {
28025 PyThreadState* __tstate = wxPyBeginAllowThreads();
28026 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
28027
28028 wxPyEndAllowThreads(__tstate);
28029 if (PyErr_Occurred()) SWIG_fail;
28030 }
28031 {
28032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28033 }
28034 return resultobj;
28035 fail:
28036 return NULL;
28037 }
28038
28039
28040 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
28041 int argc;
28042 PyObject *argv[3];
28043 int ii;
28044
28045 argc = PyObject_Length(args);
28046 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
28047 argv[ii] = PyTuple_GetItem(args,ii);
28048 }
28049 if (argc == 2) {
28050 int _v;
28051 {
28052 void *ptr;
28053 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28054 _v = 0;
28055 PyErr_Clear();
28056 } else {
28057 _v = 1;
28058 }
28059 }
28060 if (_v) {
28061 {
28062 void *ptr = 0;
28063 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28064 _v = 0;
28065 PyErr_Clear();
28066 } else {
28067 _v = (ptr != 0);
28068 }
28069 }
28070 if (_v) {
28071 return _wrap_DataFormat___ne____SWIG_1(self,args);
28072 }
28073 }
28074 }
28075 if (argc == 2) {
28076 int _v;
28077 {
28078 void *ptr;
28079 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28080 _v = 0;
28081 PyErr_Clear();
28082 } else {
28083 _v = 1;
28084 }
28085 }
28086 if (_v) {
28087 _v = SWIG_Check_int(argv[1]);
28088 if (_v) {
28089 return _wrap_DataFormat___ne____SWIG_0(self,args);
28090 }
28091 }
28092 }
28093
28094 Py_INCREF(Py_NotImplemented);
28095 return Py_NotImplemented;
28096 }
28097
28098
28099 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
28100 PyObject *resultobj = NULL;
28101 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28102 wxDataFormatId arg2 ;
28103 PyObject * obj0 = 0 ;
28104 PyObject * obj1 = 0 ;
28105 char *kwnames[] = {
28106 (char *) "self",(char *) "format", NULL
28107 };
28108
28109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
28110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28111 if (SWIG_arg_fail(1)) SWIG_fail;
28112 {
28113 arg2 = static_cast<wxDataFormatId >(SWIG_As_int(obj1));
28114 if (SWIG_arg_fail(2)) SWIG_fail;
28115 }
28116 {
28117 PyThreadState* __tstate = wxPyBeginAllowThreads();
28118 (arg1)->SetType(arg2);
28119
28120 wxPyEndAllowThreads(__tstate);
28121 if (PyErr_Occurred()) SWIG_fail;
28122 }
28123 Py_INCREF(Py_None); resultobj = Py_None;
28124 return resultobj;
28125 fail:
28126 return NULL;
28127 }
28128
28129
28130 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
28131 PyObject *resultobj = NULL;
28132 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28133 wxDataFormatId result;
28134 PyObject * obj0 = 0 ;
28135 char *kwnames[] = {
28136 (char *) "self", NULL
28137 };
28138
28139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
28140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28141 if (SWIG_arg_fail(1)) SWIG_fail;
28142 {
28143 PyThreadState* __tstate = wxPyBeginAllowThreads();
28144 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
28145
28146 wxPyEndAllowThreads(__tstate);
28147 if (PyErr_Occurred()) SWIG_fail;
28148 }
28149 resultobj = SWIG_From_int((result));
28150 return resultobj;
28151 fail:
28152 return NULL;
28153 }
28154
28155
28156 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
28157 PyObject *resultobj = NULL;
28158 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28159 wxString result;
28160 PyObject * obj0 = 0 ;
28161 char *kwnames[] = {
28162 (char *) "self", NULL
28163 };
28164
28165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
28166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28167 if (SWIG_arg_fail(1)) SWIG_fail;
28168 {
28169 PyThreadState* __tstate = wxPyBeginAllowThreads();
28170 result = ((wxDataFormat const *)arg1)->GetId();
28171
28172 wxPyEndAllowThreads(__tstate);
28173 if (PyErr_Occurred()) SWIG_fail;
28174 }
28175 {
28176 #if wxUSE_UNICODE
28177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28178 #else
28179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28180 #endif
28181 }
28182 return resultobj;
28183 fail:
28184 return NULL;
28185 }
28186
28187
28188 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
28189 PyObject *resultobj = NULL;
28190 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28191 wxString *arg2 = 0 ;
28192 bool temp2 = false ;
28193 PyObject * obj0 = 0 ;
28194 PyObject * obj1 = 0 ;
28195 char *kwnames[] = {
28196 (char *) "self",(char *) "format", NULL
28197 };
28198
28199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
28200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28201 if (SWIG_arg_fail(1)) SWIG_fail;
28202 {
28203 arg2 = wxString_in_helper(obj1);
28204 if (arg2 == NULL) SWIG_fail;
28205 temp2 = true;
28206 }
28207 {
28208 PyThreadState* __tstate = wxPyBeginAllowThreads();
28209 (arg1)->SetId((wxString const &)*arg2);
28210
28211 wxPyEndAllowThreads(__tstate);
28212 if (PyErr_Occurred()) SWIG_fail;
28213 }
28214 Py_INCREF(Py_None); resultobj = Py_None;
28215 {
28216 if (temp2)
28217 delete arg2;
28218 }
28219 return resultobj;
28220 fail:
28221 {
28222 if (temp2)
28223 delete arg2;
28224 }
28225 return NULL;
28226 }
28227
28228
28229 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
28230 PyObject *obj;
28231 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28232 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
28233 Py_INCREF(obj);
28234 return Py_BuildValue((char *)"");
28235 }
28236 static int _wrap_FormatInvalid_set(PyObject *) {
28237 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
28238 return 1;
28239 }
28240
28241
28242 static PyObject *_wrap_FormatInvalid_get(void) {
28243 PyObject *pyobj = NULL;
28244
28245 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
28246 return pyobj;
28247 }
28248
28249
28250 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28251 PyObject *resultobj = NULL;
28252 wxDataObject *arg1 = (wxDataObject *) 0 ;
28253 PyObject * obj0 = 0 ;
28254 char *kwnames[] = {
28255 (char *) "self", NULL
28256 };
28257
28258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
28259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28260 if (SWIG_arg_fail(1)) SWIG_fail;
28261 {
28262 PyThreadState* __tstate = wxPyBeginAllowThreads();
28263 delete arg1;
28264
28265 wxPyEndAllowThreads(__tstate);
28266 if (PyErr_Occurred()) SWIG_fail;
28267 }
28268 Py_INCREF(Py_None); resultobj = Py_None;
28269 return resultobj;
28270 fail:
28271 return NULL;
28272 }
28273
28274
28275 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
28276 PyObject *resultobj = NULL;
28277 wxDataObject *arg1 = (wxDataObject *) 0 ;
28278 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
28279 SwigValueWrapper<wxDataFormat > result;
28280 PyObject * obj0 = 0 ;
28281 PyObject * obj1 = 0 ;
28282 char *kwnames[] = {
28283 (char *) "self",(char *) "dir", NULL
28284 };
28285
28286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
28287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28288 if (SWIG_arg_fail(1)) SWIG_fail;
28289 if (obj1) {
28290 {
28291 arg2 = static_cast<wxDataObject::Direction >(SWIG_As_int(obj1));
28292 if (SWIG_arg_fail(2)) SWIG_fail;
28293 }
28294 }
28295 {
28296 PyThreadState* __tstate = wxPyBeginAllowThreads();
28297 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
28298
28299 wxPyEndAllowThreads(__tstate);
28300 if (PyErr_Occurred()) SWIG_fail;
28301 }
28302 {
28303 wxDataFormat * resultptr;
28304 resultptr = new wxDataFormat(static_cast<wxDataFormat & >(result));
28305 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
28306 }
28307 return resultobj;
28308 fail:
28309 return NULL;
28310 }
28311
28312
28313 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
28314 PyObject *resultobj = NULL;
28315 wxDataObject *arg1 = (wxDataObject *) 0 ;
28316 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
28317 size_t result;
28318 PyObject * obj0 = 0 ;
28319 PyObject * obj1 = 0 ;
28320 char *kwnames[] = {
28321 (char *) "self",(char *) "dir", NULL
28322 };
28323
28324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
28325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28326 if (SWIG_arg_fail(1)) SWIG_fail;
28327 if (obj1) {
28328 {
28329 arg2 = static_cast<wxDataObject::Direction >(SWIG_As_int(obj1));
28330 if (SWIG_arg_fail(2)) SWIG_fail;
28331 }
28332 }
28333 {
28334 PyThreadState* __tstate = wxPyBeginAllowThreads();
28335 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
28336
28337 wxPyEndAllowThreads(__tstate);
28338 if (PyErr_Occurred()) SWIG_fail;
28339 }
28340 {
28341 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
28342 }
28343 return resultobj;
28344 fail:
28345 return NULL;
28346 }
28347
28348
28349 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
28350 PyObject *resultobj = NULL;
28351 wxDataObject *arg1 = (wxDataObject *) 0 ;
28352 wxDataFormat *arg2 = 0 ;
28353 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
28354 bool result;
28355 PyObject * obj0 = 0 ;
28356 PyObject * obj1 = 0 ;
28357 PyObject * obj2 = 0 ;
28358 char *kwnames[] = {
28359 (char *) "self",(char *) "format",(char *) "dir", NULL
28360 };
28361
28362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
28363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28364 if (SWIG_arg_fail(1)) SWIG_fail;
28365 {
28366 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28367 if (SWIG_arg_fail(2)) SWIG_fail;
28368 if (arg2 == NULL) {
28369 SWIG_null_ref("wxDataFormat");
28370 }
28371 if (SWIG_arg_fail(2)) SWIG_fail;
28372 }
28373 if (obj2) {
28374 {
28375 arg3 = static_cast<wxDataObject::Direction >(SWIG_As_int(obj2));
28376 if (SWIG_arg_fail(3)) SWIG_fail;
28377 }
28378 }
28379 {
28380 PyThreadState* __tstate = wxPyBeginAllowThreads();
28381 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
28382
28383 wxPyEndAllowThreads(__tstate);
28384 if (PyErr_Occurred()) SWIG_fail;
28385 }
28386 {
28387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28388 }
28389 return resultobj;
28390 fail:
28391 return NULL;
28392 }
28393
28394
28395 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
28396 PyObject *resultobj = NULL;
28397 wxDataObject *arg1 = (wxDataObject *) 0 ;
28398 wxDataFormat *arg2 = 0 ;
28399 size_t result;
28400 PyObject * obj0 = 0 ;
28401 PyObject * obj1 = 0 ;
28402 char *kwnames[] = {
28403 (char *) "self",(char *) "format", NULL
28404 };
28405
28406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
28407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28408 if (SWIG_arg_fail(1)) SWIG_fail;
28409 {
28410 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28411 if (SWIG_arg_fail(2)) SWIG_fail;
28412 if (arg2 == NULL) {
28413 SWIG_null_ref("wxDataFormat");
28414 }
28415 if (SWIG_arg_fail(2)) SWIG_fail;
28416 }
28417 {
28418 PyThreadState* __tstate = wxPyBeginAllowThreads();
28419 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
28420
28421 wxPyEndAllowThreads(__tstate);
28422 if (PyErr_Occurred()) SWIG_fail;
28423 }
28424 {
28425 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
28426 }
28427 return resultobj;
28428 fail:
28429 return NULL;
28430 }
28431
28432
28433 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
28434 PyObject *resultobj = NULL;
28435 wxDataObject *arg1 = (wxDataObject *) 0 ;
28436 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
28437 PyObject *result;
28438 PyObject * obj0 = 0 ;
28439 PyObject * obj1 = 0 ;
28440 char *kwnames[] = {
28441 (char *) "self",(char *) "dir", NULL
28442 };
28443
28444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
28445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28446 if (SWIG_arg_fail(1)) SWIG_fail;
28447 if (obj1) {
28448 {
28449 arg2 = static_cast<wxDataObject::Direction >(SWIG_As_int(obj1));
28450 if (SWIG_arg_fail(2)) SWIG_fail;
28451 }
28452 }
28453 {
28454 PyThreadState* __tstate = wxPyBeginAllowThreads();
28455 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
28456
28457 wxPyEndAllowThreads(__tstate);
28458 if (PyErr_Occurred()) SWIG_fail;
28459 }
28460 resultobj = result;
28461 return resultobj;
28462 fail:
28463 return NULL;
28464 }
28465
28466
28467 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
28468 PyObject *resultobj = NULL;
28469 wxDataObject *arg1 = (wxDataObject *) 0 ;
28470 wxDataFormat *arg2 = 0 ;
28471 PyObject *result;
28472 PyObject * obj0 = 0 ;
28473 PyObject * obj1 = 0 ;
28474 char *kwnames[] = {
28475 (char *) "self",(char *) "format", NULL
28476 };
28477
28478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
28479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28480 if (SWIG_arg_fail(1)) SWIG_fail;
28481 {
28482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28483 if (SWIG_arg_fail(2)) SWIG_fail;
28484 if (arg2 == NULL) {
28485 SWIG_null_ref("wxDataFormat");
28486 }
28487 if (SWIG_arg_fail(2)) SWIG_fail;
28488 }
28489 {
28490 PyThreadState* __tstate = wxPyBeginAllowThreads();
28491 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
28492
28493 wxPyEndAllowThreads(__tstate);
28494 if (PyErr_Occurred()) SWIG_fail;
28495 }
28496 resultobj = result;
28497 return resultobj;
28498 fail:
28499 return NULL;
28500 }
28501
28502
28503 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28504 PyObject *resultobj = NULL;
28505 wxDataObject *arg1 = (wxDataObject *) 0 ;
28506 wxDataFormat *arg2 = 0 ;
28507 PyObject *arg3 = (PyObject *) 0 ;
28508 bool result;
28509 PyObject * obj0 = 0 ;
28510 PyObject * obj1 = 0 ;
28511 PyObject * obj2 = 0 ;
28512 char *kwnames[] = {
28513 (char *) "self",(char *) "format",(char *) "data", NULL
28514 };
28515
28516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
28517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28518 if (SWIG_arg_fail(1)) SWIG_fail;
28519 {
28520 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28521 if (SWIG_arg_fail(2)) SWIG_fail;
28522 if (arg2 == NULL) {
28523 SWIG_null_ref("wxDataFormat");
28524 }
28525 if (SWIG_arg_fail(2)) SWIG_fail;
28526 }
28527 arg3 = obj2;
28528 {
28529 PyThreadState* __tstate = wxPyBeginAllowThreads();
28530 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
28531
28532 wxPyEndAllowThreads(__tstate);
28533 if (PyErr_Occurred()) SWIG_fail;
28534 }
28535 {
28536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28537 }
28538 return resultobj;
28539 fail:
28540 return NULL;
28541 }
28542
28543
28544 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
28545 PyObject *obj;
28546 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28547 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
28548 Py_INCREF(obj);
28549 return Py_BuildValue((char *)"");
28550 }
28551 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
28552 PyObject *resultobj = NULL;
28553 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
28554 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
28555 wxDataObjectSimple *result;
28556 PyObject * obj0 = 0 ;
28557 char *kwnames[] = {
28558 (char *) "format", NULL
28559 };
28560
28561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
28562 if (obj0) {
28563 {
28564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28565 if (SWIG_arg_fail(1)) SWIG_fail;
28566 if (arg1 == NULL) {
28567 SWIG_null_ref("wxDataFormat");
28568 }
28569 if (SWIG_arg_fail(1)) SWIG_fail;
28570 }
28571 }
28572 {
28573 PyThreadState* __tstate = wxPyBeginAllowThreads();
28574 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
28575
28576 wxPyEndAllowThreads(__tstate);
28577 if (PyErr_Occurred()) SWIG_fail;
28578 }
28579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
28580 return resultobj;
28581 fail:
28582 return NULL;
28583 }
28584
28585
28586 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
28587 PyObject *resultobj = NULL;
28588 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28589 wxDataFormat *result;
28590 PyObject * obj0 = 0 ;
28591 char *kwnames[] = {
28592 (char *) "self", NULL
28593 };
28594
28595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
28596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28597 if (SWIG_arg_fail(1)) SWIG_fail;
28598 {
28599 PyThreadState* __tstate = wxPyBeginAllowThreads();
28600 {
28601 wxDataFormat const &_result_ref = (arg1)->GetFormat();
28602 result = (wxDataFormat *) &_result_ref;
28603 }
28604
28605 wxPyEndAllowThreads(__tstate);
28606 if (PyErr_Occurred()) SWIG_fail;
28607 }
28608 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
28609 return resultobj;
28610 fail:
28611 return NULL;
28612 }
28613
28614
28615 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
28616 PyObject *resultobj = NULL;
28617 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28618 wxDataFormat *arg2 = 0 ;
28619 PyObject * obj0 = 0 ;
28620 PyObject * obj1 = 0 ;
28621 char *kwnames[] = {
28622 (char *) "self",(char *) "format", NULL
28623 };
28624
28625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
28626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28627 if (SWIG_arg_fail(1)) SWIG_fail;
28628 {
28629 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28630 if (SWIG_arg_fail(2)) SWIG_fail;
28631 if (arg2 == NULL) {
28632 SWIG_null_ref("wxDataFormat");
28633 }
28634 if (SWIG_arg_fail(2)) SWIG_fail;
28635 }
28636 {
28637 PyThreadState* __tstate = wxPyBeginAllowThreads();
28638 (arg1)->SetFormat((wxDataFormat const &)*arg2);
28639
28640 wxPyEndAllowThreads(__tstate);
28641 if (PyErr_Occurred()) SWIG_fail;
28642 }
28643 Py_INCREF(Py_None); resultobj = Py_None;
28644 return resultobj;
28645 fail:
28646 return NULL;
28647 }
28648
28649
28650 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
28651 PyObject *resultobj = NULL;
28652 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28653 size_t result;
28654 PyObject * obj0 = 0 ;
28655 char *kwnames[] = {
28656 (char *) "self", NULL
28657 };
28658
28659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
28660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28661 if (SWIG_arg_fail(1)) SWIG_fail;
28662 {
28663 PyThreadState* __tstate = wxPyBeginAllowThreads();
28664 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
28665
28666 wxPyEndAllowThreads(__tstate);
28667 if (PyErr_Occurred()) SWIG_fail;
28668 }
28669 {
28670 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
28671 }
28672 return resultobj;
28673 fail:
28674 return NULL;
28675 }
28676
28677
28678 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
28679 PyObject *resultobj = NULL;
28680 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28681 PyObject *result;
28682 PyObject * obj0 = 0 ;
28683 char *kwnames[] = {
28684 (char *) "self", NULL
28685 };
28686
28687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
28688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28689 if (SWIG_arg_fail(1)) SWIG_fail;
28690 {
28691 PyThreadState* __tstate = wxPyBeginAllowThreads();
28692 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
28693
28694 wxPyEndAllowThreads(__tstate);
28695 if (PyErr_Occurred()) SWIG_fail;
28696 }
28697 resultobj = result;
28698 return resultobj;
28699 fail:
28700 return NULL;
28701 }
28702
28703
28704 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28705 PyObject *resultobj = NULL;
28706 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28707 PyObject *arg2 = (PyObject *) 0 ;
28708 bool result;
28709 PyObject * obj0 = 0 ;
28710 PyObject * obj1 = 0 ;
28711 char *kwnames[] = {
28712 (char *) "self",(char *) "data", NULL
28713 };
28714
28715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
28716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28717 if (SWIG_arg_fail(1)) SWIG_fail;
28718 arg2 = obj1;
28719 {
28720 PyThreadState* __tstate = wxPyBeginAllowThreads();
28721 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
28722
28723 wxPyEndAllowThreads(__tstate);
28724 if (PyErr_Occurred()) SWIG_fail;
28725 }
28726 {
28727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28728 }
28729 return resultobj;
28730 fail:
28731 return NULL;
28732 }
28733
28734
28735 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
28736 PyObject *obj;
28737 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28738 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
28739 Py_INCREF(obj);
28740 return Py_BuildValue((char *)"");
28741 }
28742 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
28743 PyObject *resultobj = NULL;
28744 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
28745 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
28746 wxPyDataObjectSimple *result;
28747 PyObject * obj0 = 0 ;
28748 char *kwnames[] = {
28749 (char *) "format", NULL
28750 };
28751
28752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
28753 if (obj0) {
28754 {
28755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28756 if (SWIG_arg_fail(1)) SWIG_fail;
28757 if (arg1 == NULL) {
28758 SWIG_null_ref("wxDataFormat");
28759 }
28760 if (SWIG_arg_fail(1)) SWIG_fail;
28761 }
28762 }
28763 {
28764 PyThreadState* __tstate = wxPyBeginAllowThreads();
28765 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
28766
28767 wxPyEndAllowThreads(__tstate);
28768 if (PyErr_Occurred()) SWIG_fail;
28769 }
28770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
28771 return resultobj;
28772 fail:
28773 return NULL;
28774 }
28775
28776
28777 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28778 PyObject *resultobj = NULL;
28779 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
28780 PyObject *arg2 = (PyObject *) 0 ;
28781 PyObject *arg3 = (PyObject *) 0 ;
28782 PyObject * obj0 = 0 ;
28783 PyObject * obj1 = 0 ;
28784 PyObject * obj2 = 0 ;
28785 char *kwnames[] = {
28786 (char *) "self",(char *) "self",(char *) "_class", NULL
28787 };
28788
28789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28791 if (SWIG_arg_fail(1)) SWIG_fail;
28792 arg2 = obj1;
28793 arg3 = obj2;
28794 {
28795 PyThreadState* __tstate = wxPyBeginAllowThreads();
28796 (arg1)->_setCallbackInfo(arg2,arg3);
28797
28798 wxPyEndAllowThreads(__tstate);
28799 if (PyErr_Occurred()) SWIG_fail;
28800 }
28801 Py_INCREF(Py_None); resultobj = Py_None;
28802 return resultobj;
28803 fail:
28804 return NULL;
28805 }
28806
28807
28808 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
28809 PyObject *obj;
28810 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28811 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
28812 Py_INCREF(obj);
28813 return Py_BuildValue((char *)"");
28814 }
28815 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
28816 PyObject *resultobj = NULL;
28817 wxDataObjectComposite *result;
28818 char *kwnames[] = {
28819 NULL
28820 };
28821
28822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
28823 {
28824 PyThreadState* __tstate = wxPyBeginAllowThreads();
28825 result = (wxDataObjectComposite *)new wxDataObjectComposite();
28826
28827 wxPyEndAllowThreads(__tstate);
28828 if (PyErr_Occurred()) SWIG_fail;
28829 }
28830 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
28831 return resultobj;
28832 fail:
28833 return NULL;
28834 }
28835
28836
28837 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
28838 PyObject *resultobj = NULL;
28839 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
28840 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
28841 bool arg3 = (bool) false ;
28842 PyObject * obj0 = 0 ;
28843 PyObject * obj1 = 0 ;
28844 PyObject * obj2 = 0 ;
28845 char *kwnames[] = {
28846 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
28847 };
28848
28849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
28850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
28851 if (SWIG_arg_fail(1)) SWIG_fail;
28852 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28853 if (SWIG_arg_fail(2)) SWIG_fail;
28854 if (obj2) {
28855 {
28856 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
28857 if (SWIG_arg_fail(3)) SWIG_fail;
28858 }
28859 }
28860 {
28861 PyThreadState* __tstate = wxPyBeginAllowThreads();
28862 (arg1)->Add(arg2,arg3);
28863
28864 wxPyEndAllowThreads(__tstate);
28865 if (PyErr_Occurred()) SWIG_fail;
28866 }
28867 Py_INCREF(Py_None); resultobj = Py_None;
28868 return resultobj;
28869 fail:
28870 return NULL;
28871 }
28872
28873
28874 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
28875 PyObject *obj;
28876 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28877 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
28878 Py_INCREF(obj);
28879 return Py_BuildValue((char *)"");
28880 }
28881 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28882 PyObject *resultobj = NULL;
28883 wxString const &arg1_defvalue = wxPyEmptyString ;
28884 wxString *arg1 = (wxString *) &arg1_defvalue ;
28885 wxTextDataObject *result;
28886 bool temp1 = false ;
28887 PyObject * obj0 = 0 ;
28888 char *kwnames[] = {
28889 (char *) "text", NULL
28890 };
28891
28892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
28893 if (obj0) {
28894 {
28895 arg1 = wxString_in_helper(obj0);
28896 if (arg1 == NULL) SWIG_fail;
28897 temp1 = true;
28898 }
28899 }
28900 {
28901 PyThreadState* __tstate = wxPyBeginAllowThreads();
28902 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
28903
28904 wxPyEndAllowThreads(__tstate);
28905 if (PyErr_Occurred()) SWIG_fail;
28906 }
28907 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
28908 {
28909 if (temp1)
28910 delete arg1;
28911 }
28912 return resultobj;
28913 fail:
28914 {
28915 if (temp1)
28916 delete arg1;
28917 }
28918 return NULL;
28919 }
28920
28921
28922 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
28923 PyObject *resultobj = NULL;
28924 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
28925 size_t result;
28926 PyObject * obj0 = 0 ;
28927 char *kwnames[] = {
28928 (char *) "self", NULL
28929 };
28930
28931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
28932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28933 if (SWIG_arg_fail(1)) SWIG_fail;
28934 {
28935 PyThreadState* __tstate = wxPyBeginAllowThreads();
28936 result = (size_t)(arg1)->GetTextLength();
28937
28938 wxPyEndAllowThreads(__tstate);
28939 if (PyErr_Occurred()) SWIG_fail;
28940 }
28941 {
28942 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
28943 }
28944 return resultobj;
28945 fail:
28946 return NULL;
28947 }
28948
28949
28950 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
28951 PyObject *resultobj = NULL;
28952 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
28953 wxString result;
28954 PyObject * obj0 = 0 ;
28955 char *kwnames[] = {
28956 (char *) "self", NULL
28957 };
28958
28959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
28960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28961 if (SWIG_arg_fail(1)) SWIG_fail;
28962 {
28963 PyThreadState* __tstate = wxPyBeginAllowThreads();
28964 result = (arg1)->GetText();
28965
28966 wxPyEndAllowThreads(__tstate);
28967 if (PyErr_Occurred()) SWIG_fail;
28968 }
28969 {
28970 #if wxUSE_UNICODE
28971 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28972 #else
28973 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28974 #endif
28975 }
28976 return resultobj;
28977 fail:
28978 return NULL;
28979 }
28980
28981
28982 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
28983 PyObject *resultobj = NULL;
28984 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
28985 wxString *arg2 = 0 ;
28986 bool temp2 = false ;
28987 PyObject * obj0 = 0 ;
28988 PyObject * obj1 = 0 ;
28989 char *kwnames[] = {
28990 (char *) "self",(char *) "text", NULL
28991 };
28992
28993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
28994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28995 if (SWIG_arg_fail(1)) SWIG_fail;
28996 {
28997 arg2 = wxString_in_helper(obj1);
28998 if (arg2 == NULL) SWIG_fail;
28999 temp2 = true;
29000 }
29001 {
29002 PyThreadState* __tstate = wxPyBeginAllowThreads();
29003 (arg1)->SetText((wxString const &)*arg2);
29004
29005 wxPyEndAllowThreads(__tstate);
29006 if (PyErr_Occurred()) SWIG_fail;
29007 }
29008 Py_INCREF(Py_None); resultobj = Py_None;
29009 {
29010 if (temp2)
29011 delete arg2;
29012 }
29013 return resultobj;
29014 fail:
29015 {
29016 if (temp2)
29017 delete arg2;
29018 }
29019 return NULL;
29020 }
29021
29022
29023 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
29024 PyObject *obj;
29025 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29026 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
29027 Py_INCREF(obj);
29028 return Py_BuildValue((char *)"");
29029 }
29030 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29031 PyObject *resultobj = NULL;
29032 wxString const &arg1_defvalue = wxPyEmptyString ;
29033 wxString *arg1 = (wxString *) &arg1_defvalue ;
29034 wxPyTextDataObject *result;
29035 bool temp1 = false ;
29036 PyObject * obj0 = 0 ;
29037 char *kwnames[] = {
29038 (char *) "text", NULL
29039 };
29040
29041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
29042 if (obj0) {
29043 {
29044 arg1 = wxString_in_helper(obj0);
29045 if (arg1 == NULL) SWIG_fail;
29046 temp1 = true;
29047 }
29048 }
29049 {
29050 PyThreadState* __tstate = wxPyBeginAllowThreads();
29051 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
29052
29053 wxPyEndAllowThreads(__tstate);
29054 if (PyErr_Occurred()) SWIG_fail;
29055 }
29056 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
29057 {
29058 if (temp1)
29059 delete arg1;
29060 }
29061 return resultobj;
29062 fail:
29063 {
29064 if (temp1)
29065 delete arg1;
29066 }
29067 return NULL;
29068 }
29069
29070
29071 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29072 PyObject *resultobj = NULL;
29073 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
29074 PyObject *arg2 = (PyObject *) 0 ;
29075 PyObject *arg3 = (PyObject *) 0 ;
29076 PyObject * obj0 = 0 ;
29077 PyObject * obj1 = 0 ;
29078 PyObject * obj2 = 0 ;
29079 char *kwnames[] = {
29080 (char *) "self",(char *) "self",(char *) "_class", NULL
29081 };
29082
29083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
29085 if (SWIG_arg_fail(1)) SWIG_fail;
29086 arg2 = obj1;
29087 arg3 = obj2;
29088 {
29089 PyThreadState* __tstate = wxPyBeginAllowThreads();
29090 (arg1)->_setCallbackInfo(arg2,arg3);
29091
29092 wxPyEndAllowThreads(__tstate);
29093 if (PyErr_Occurred()) SWIG_fail;
29094 }
29095 Py_INCREF(Py_None); resultobj = Py_None;
29096 return resultobj;
29097 fail:
29098 return NULL;
29099 }
29100
29101
29102 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
29103 PyObject *obj;
29104 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29105 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
29106 Py_INCREF(obj);
29107 return Py_BuildValue((char *)"");
29108 }
29109 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29110 PyObject *resultobj = NULL;
29111 wxBitmap const &arg1_defvalue = wxNullBitmap ;
29112 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
29113 wxBitmapDataObject *result;
29114 PyObject * obj0 = 0 ;
29115 char *kwnames[] = {
29116 (char *) "bitmap", NULL
29117 };
29118
29119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
29120 if (obj0) {
29121 {
29122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
29123 if (SWIG_arg_fail(1)) SWIG_fail;
29124 if (arg1 == NULL) {
29125 SWIG_null_ref("wxBitmap");
29126 }
29127 if (SWIG_arg_fail(1)) SWIG_fail;
29128 }
29129 }
29130 {
29131 PyThreadState* __tstate = wxPyBeginAllowThreads();
29132 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
29133
29134 wxPyEndAllowThreads(__tstate);
29135 if (PyErr_Occurred()) SWIG_fail;
29136 }
29137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
29138 return resultobj;
29139 fail:
29140 return NULL;
29141 }
29142
29143
29144 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
29145 PyObject *resultobj = NULL;
29146 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
29147 wxBitmap result;
29148 PyObject * obj0 = 0 ;
29149 char *kwnames[] = {
29150 (char *) "self", NULL
29151 };
29152
29153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
29154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
29155 if (SWIG_arg_fail(1)) SWIG_fail;
29156 {
29157 PyThreadState* __tstate = wxPyBeginAllowThreads();
29158 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
29159
29160 wxPyEndAllowThreads(__tstate);
29161 if (PyErr_Occurred()) SWIG_fail;
29162 }
29163 {
29164 wxBitmap * resultptr;
29165 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
29166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
29167 }
29168 return resultobj;
29169 fail:
29170 return NULL;
29171 }
29172
29173
29174 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
29175 PyObject *resultobj = NULL;
29176 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
29177 wxBitmap *arg2 = 0 ;
29178 PyObject * obj0 = 0 ;
29179 PyObject * obj1 = 0 ;
29180 char *kwnames[] = {
29181 (char *) "self",(char *) "bitmap", NULL
29182 };
29183
29184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
29185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
29186 if (SWIG_arg_fail(1)) SWIG_fail;
29187 {
29188 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
29189 if (SWIG_arg_fail(2)) SWIG_fail;
29190 if (arg2 == NULL) {
29191 SWIG_null_ref("wxBitmap");
29192 }
29193 if (SWIG_arg_fail(2)) SWIG_fail;
29194 }
29195 {
29196 PyThreadState* __tstate = wxPyBeginAllowThreads();
29197 (arg1)->SetBitmap((wxBitmap const &)*arg2);
29198
29199 wxPyEndAllowThreads(__tstate);
29200 if (PyErr_Occurred()) SWIG_fail;
29201 }
29202 Py_INCREF(Py_None); resultobj = Py_None;
29203 return resultobj;
29204 fail:
29205 return NULL;
29206 }
29207
29208
29209 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
29210 PyObject *obj;
29211 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29212 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
29213 Py_INCREF(obj);
29214 return Py_BuildValue((char *)"");
29215 }
29216 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29217 PyObject *resultobj = NULL;
29218 wxBitmap const &arg1_defvalue = wxNullBitmap ;
29219 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
29220 wxPyBitmapDataObject *result;
29221 PyObject * obj0 = 0 ;
29222 char *kwnames[] = {
29223 (char *) "bitmap", NULL
29224 };
29225
29226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
29227 if (obj0) {
29228 {
29229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
29230 if (SWIG_arg_fail(1)) SWIG_fail;
29231 if (arg1 == NULL) {
29232 SWIG_null_ref("wxBitmap");
29233 }
29234 if (SWIG_arg_fail(1)) SWIG_fail;
29235 }
29236 }
29237 {
29238 PyThreadState* __tstate = wxPyBeginAllowThreads();
29239 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
29240
29241 wxPyEndAllowThreads(__tstate);
29242 if (PyErr_Occurred()) SWIG_fail;
29243 }
29244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
29245 return resultobj;
29246 fail:
29247 return NULL;
29248 }
29249
29250
29251 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29252 PyObject *resultobj = NULL;
29253 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
29254 PyObject *arg2 = (PyObject *) 0 ;
29255 PyObject *arg3 = (PyObject *) 0 ;
29256 PyObject * obj0 = 0 ;
29257 PyObject * obj1 = 0 ;
29258 PyObject * obj2 = 0 ;
29259 char *kwnames[] = {
29260 (char *) "self",(char *) "self",(char *) "_class", NULL
29261 };
29262
29263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
29265 if (SWIG_arg_fail(1)) SWIG_fail;
29266 arg2 = obj1;
29267 arg3 = obj2;
29268 {
29269 PyThreadState* __tstate = wxPyBeginAllowThreads();
29270 (arg1)->_setCallbackInfo(arg2,arg3);
29271
29272 wxPyEndAllowThreads(__tstate);
29273 if (PyErr_Occurred()) SWIG_fail;
29274 }
29275 Py_INCREF(Py_None); resultobj = Py_None;
29276 return resultobj;
29277 fail:
29278 return NULL;
29279 }
29280
29281
29282 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
29283 PyObject *obj;
29284 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29285 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
29286 Py_INCREF(obj);
29287 return Py_BuildValue((char *)"");
29288 }
29289 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29290 PyObject *resultobj = NULL;
29291 wxFileDataObject *result;
29292 char *kwnames[] = {
29293 NULL
29294 };
29295
29296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
29297 {
29298 PyThreadState* __tstate = wxPyBeginAllowThreads();
29299 result = (wxFileDataObject *)new wxFileDataObject();
29300
29301 wxPyEndAllowThreads(__tstate);
29302 if (PyErr_Occurred()) SWIG_fail;
29303 }
29304 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
29305 return resultobj;
29306 fail:
29307 return NULL;
29308 }
29309
29310
29311 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
29312 PyObject *resultobj = NULL;
29313 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
29314 wxArrayString *result;
29315 PyObject * obj0 = 0 ;
29316 char *kwnames[] = {
29317 (char *) "self", NULL
29318 };
29319
29320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
29321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
29322 if (SWIG_arg_fail(1)) SWIG_fail;
29323 {
29324 PyThreadState* __tstate = wxPyBeginAllowThreads();
29325 {
29326 wxArrayString const &_result_ref = (arg1)->GetFilenames();
29327 result = (wxArrayString *) &_result_ref;
29328 }
29329
29330 wxPyEndAllowThreads(__tstate);
29331 if (PyErr_Occurred()) SWIG_fail;
29332 }
29333 {
29334 resultobj = wxArrayString2PyList_helper(*result);
29335 }
29336 return resultobj;
29337 fail:
29338 return NULL;
29339 }
29340
29341
29342 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
29343 PyObject *resultobj = NULL;
29344 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
29345 wxString *arg2 = 0 ;
29346 bool temp2 = false ;
29347 PyObject * obj0 = 0 ;
29348 PyObject * obj1 = 0 ;
29349 char *kwnames[] = {
29350 (char *) "self",(char *) "filename", NULL
29351 };
29352
29353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
29354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
29355 if (SWIG_arg_fail(1)) SWIG_fail;
29356 {
29357 arg2 = wxString_in_helper(obj1);
29358 if (arg2 == NULL) SWIG_fail;
29359 temp2 = true;
29360 }
29361 {
29362 PyThreadState* __tstate = wxPyBeginAllowThreads();
29363 (arg1)->AddFile((wxString const &)*arg2);
29364
29365 wxPyEndAllowThreads(__tstate);
29366 if (PyErr_Occurred()) SWIG_fail;
29367 }
29368 Py_INCREF(Py_None); resultobj = Py_None;
29369 {
29370 if (temp2)
29371 delete arg2;
29372 }
29373 return resultobj;
29374 fail:
29375 {
29376 if (temp2)
29377 delete arg2;
29378 }
29379 return NULL;
29380 }
29381
29382
29383 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
29384 PyObject *obj;
29385 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29386 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
29387 Py_INCREF(obj);
29388 return Py_BuildValue((char *)"");
29389 }
29390 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
29391 PyObject *resultobj = NULL;
29392 wxDataFormat *arg1 = 0 ;
29393 wxCustomDataObject *result;
29394 PyObject * obj0 = 0 ;
29395
29396 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
29397 {
29398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29399 if (SWIG_arg_fail(1)) SWIG_fail;
29400 if (arg1 == NULL) {
29401 SWIG_null_ref("wxDataFormat");
29402 }
29403 if (SWIG_arg_fail(1)) SWIG_fail;
29404 }
29405 {
29406 PyThreadState* __tstate = wxPyBeginAllowThreads();
29407 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
29408
29409 wxPyEndAllowThreads(__tstate);
29410 if (PyErr_Occurred()) SWIG_fail;
29411 }
29412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
29413 return resultobj;
29414 fail:
29415 return NULL;
29416 }
29417
29418
29419 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
29420 PyObject *resultobj = NULL;
29421 wxString *arg1 = 0 ;
29422 wxCustomDataObject *result;
29423 bool temp1 = false ;
29424 PyObject * obj0 = 0 ;
29425
29426 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
29427 {
29428 arg1 = wxString_in_helper(obj0);
29429 if (arg1 == NULL) SWIG_fail;
29430 temp1 = true;
29431 }
29432 {
29433 PyThreadState* __tstate = wxPyBeginAllowThreads();
29434 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
29435
29436 wxPyEndAllowThreads(__tstate);
29437 if (PyErr_Occurred()) SWIG_fail;
29438 }
29439 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
29440 {
29441 if (temp1)
29442 delete arg1;
29443 }
29444 return resultobj;
29445 fail:
29446 {
29447 if (temp1)
29448 delete arg1;
29449 }
29450 return NULL;
29451 }
29452
29453
29454 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
29455 PyObject *resultobj = NULL;
29456 wxCustomDataObject *result;
29457
29458 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
29459 {
29460 PyThreadState* __tstate = wxPyBeginAllowThreads();
29461 result = (wxCustomDataObject *)new wxCustomDataObject();
29462
29463 wxPyEndAllowThreads(__tstate);
29464 if (PyErr_Occurred()) SWIG_fail;
29465 }
29466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
29467 return resultobj;
29468 fail:
29469 return NULL;
29470 }
29471
29472
29473 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
29474 int argc;
29475 PyObject *argv[2];
29476 int ii;
29477
29478 argc = PyObject_Length(args);
29479 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
29480 argv[ii] = PyTuple_GetItem(args,ii);
29481 }
29482 if (argc == 0) {
29483 return _wrap_new_CustomDataObject__SWIG_2(self,args);
29484 }
29485 if (argc == 1) {
29486 int _v;
29487 {
29488 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
29489 }
29490 if (_v) {
29491 return _wrap_new_CustomDataObject__SWIG_1(self,args);
29492 }
29493 }
29494 if (argc == 1) {
29495 int _v;
29496 {
29497 void *ptr = 0;
29498 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
29499 _v = 0;
29500 PyErr_Clear();
29501 } else {
29502 _v = (ptr != 0);
29503 }
29504 }
29505 if (_v) {
29506 return _wrap_new_CustomDataObject__SWIG_0(self,args);
29507 }
29508 }
29509
29510 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
29511 return NULL;
29512 }
29513
29514
29515 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29516 PyObject *resultobj = NULL;
29517 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
29518 PyObject *arg2 = (PyObject *) 0 ;
29519 bool result;
29520 PyObject * obj0 = 0 ;
29521 PyObject * obj1 = 0 ;
29522 char *kwnames[] = {
29523 (char *) "self",(char *) "data", NULL
29524 };
29525
29526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
29527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
29528 if (SWIG_arg_fail(1)) SWIG_fail;
29529 arg2 = obj1;
29530 {
29531 PyThreadState* __tstate = wxPyBeginAllowThreads();
29532 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
29533
29534 wxPyEndAllowThreads(__tstate);
29535 if (PyErr_Occurred()) SWIG_fail;
29536 }
29537 {
29538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29539 }
29540 return resultobj;
29541 fail:
29542 return NULL;
29543 }
29544
29545
29546 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
29547 PyObject *resultobj = NULL;
29548 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
29549 size_t result;
29550 PyObject * obj0 = 0 ;
29551 char *kwnames[] = {
29552 (char *) "self", NULL
29553 };
29554
29555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
29556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
29557 if (SWIG_arg_fail(1)) SWIG_fail;
29558 {
29559 PyThreadState* __tstate = wxPyBeginAllowThreads();
29560 result = (size_t)(arg1)->GetSize();
29561
29562 wxPyEndAllowThreads(__tstate);
29563 if (PyErr_Occurred()) SWIG_fail;
29564 }
29565 {
29566 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
29567 }
29568 return resultobj;
29569 fail:
29570 return NULL;
29571 }
29572
29573
29574 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29575 PyObject *resultobj = NULL;
29576 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
29577 PyObject *result;
29578 PyObject * obj0 = 0 ;
29579 char *kwnames[] = {
29580 (char *) "self", NULL
29581 };
29582
29583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
29584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
29585 if (SWIG_arg_fail(1)) SWIG_fail;
29586 {
29587 PyThreadState* __tstate = wxPyBeginAllowThreads();
29588 result = (PyObject *)wxCustomDataObject_GetData(arg1);
29589
29590 wxPyEndAllowThreads(__tstate);
29591 if (PyErr_Occurred()) SWIG_fail;
29592 }
29593 resultobj = result;
29594 return resultobj;
29595 fail:
29596 return NULL;
29597 }
29598
29599
29600 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
29601 PyObject *obj;
29602 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29603 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
29604 Py_INCREF(obj);
29605 return Py_BuildValue((char *)"");
29606 }
29607 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29608 PyObject *resultobj = NULL;
29609 wxURLDataObject *result;
29610 char *kwnames[] = {
29611 NULL
29612 };
29613
29614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
29615 {
29616 PyThreadState* __tstate = wxPyBeginAllowThreads();
29617 result = (wxURLDataObject *)new wxURLDataObject();
29618
29619 wxPyEndAllowThreads(__tstate);
29620 if (PyErr_Occurred()) SWIG_fail;
29621 }
29622 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
29623 return resultobj;
29624 fail:
29625 return NULL;
29626 }
29627
29628
29629 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
29630 PyObject *resultobj = NULL;
29631 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
29632 wxString result;
29633 PyObject * obj0 = 0 ;
29634 char *kwnames[] = {
29635 (char *) "self", NULL
29636 };
29637
29638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
29639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
29640 if (SWIG_arg_fail(1)) SWIG_fail;
29641 {
29642 PyThreadState* __tstate = wxPyBeginAllowThreads();
29643 result = (arg1)->GetURL();
29644
29645 wxPyEndAllowThreads(__tstate);
29646 if (PyErr_Occurred()) SWIG_fail;
29647 }
29648 {
29649 #if wxUSE_UNICODE
29650 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29651 #else
29652 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29653 #endif
29654 }
29655 return resultobj;
29656 fail:
29657 return NULL;
29658 }
29659
29660
29661 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
29662 PyObject *resultobj = NULL;
29663 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
29664 wxString *arg2 = 0 ;
29665 bool temp2 = false ;
29666 PyObject * obj0 = 0 ;
29667 PyObject * obj1 = 0 ;
29668 char *kwnames[] = {
29669 (char *) "self",(char *) "url", NULL
29670 };
29671
29672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
29673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
29674 if (SWIG_arg_fail(1)) SWIG_fail;
29675 {
29676 arg2 = wxString_in_helper(obj1);
29677 if (arg2 == NULL) SWIG_fail;
29678 temp2 = true;
29679 }
29680 {
29681 PyThreadState* __tstate = wxPyBeginAllowThreads();
29682 (arg1)->SetURL((wxString const &)*arg2);
29683
29684 wxPyEndAllowThreads(__tstate);
29685 if (PyErr_Occurred()) SWIG_fail;
29686 }
29687 Py_INCREF(Py_None); resultobj = Py_None;
29688 {
29689 if (temp2)
29690 delete arg2;
29691 }
29692 return resultobj;
29693 fail:
29694 {
29695 if (temp2)
29696 delete arg2;
29697 }
29698 return NULL;
29699 }
29700
29701
29702 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
29703 PyObject *obj;
29704 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29705 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
29706 Py_INCREF(obj);
29707 return Py_BuildValue((char *)"");
29708 }
29709 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29710 PyObject *resultobj = NULL;
29711 wxMetafileDataObject *result;
29712 char *kwnames[] = {
29713 NULL
29714 };
29715
29716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
29717 {
29718 PyThreadState* __tstate = wxPyBeginAllowThreads();
29719 result = (wxMetafileDataObject *)new wxMetafileDataObject();
29720
29721 wxPyEndAllowThreads(__tstate);
29722 if (PyErr_Occurred()) SWIG_fail;
29723 }
29724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
29725 return resultobj;
29726 fail:
29727 return NULL;
29728 }
29729
29730
29731 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
29732 PyObject *resultobj = NULL;
29733 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
29734 wxMetafile *arg2 = 0 ;
29735 PyObject * obj0 = 0 ;
29736 PyObject * obj1 = 0 ;
29737 char *kwnames[] = {
29738 (char *) "self",(char *) "metafile", NULL
29739 };
29740
29741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
29742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
29743 if (SWIG_arg_fail(1)) SWIG_fail;
29744 {
29745 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
29746 if (SWIG_arg_fail(2)) SWIG_fail;
29747 if (arg2 == NULL) {
29748 SWIG_null_ref("wxMetafile");
29749 }
29750 if (SWIG_arg_fail(2)) SWIG_fail;
29751 }
29752 {
29753 PyThreadState* __tstate = wxPyBeginAllowThreads();
29754 (arg1)->SetMetafile((wxMetafile const &)*arg2);
29755
29756 wxPyEndAllowThreads(__tstate);
29757 if (PyErr_Occurred()) SWIG_fail;
29758 }
29759 Py_INCREF(Py_None); resultobj = Py_None;
29760 return resultobj;
29761 fail:
29762 return NULL;
29763 }
29764
29765
29766 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
29767 PyObject *resultobj = NULL;
29768 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
29769 wxMetafile result;
29770 PyObject * obj0 = 0 ;
29771 char *kwnames[] = {
29772 (char *) "self", NULL
29773 };
29774
29775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
29776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
29777 if (SWIG_arg_fail(1)) SWIG_fail;
29778 {
29779 PyThreadState* __tstate = wxPyBeginAllowThreads();
29780 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
29781
29782 wxPyEndAllowThreads(__tstate);
29783 if (PyErr_Occurred()) SWIG_fail;
29784 }
29785 {
29786 wxMetafile * resultptr;
29787 resultptr = new wxMetafile(static_cast<wxMetafile & >(result));
29788 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
29789 }
29790 return resultobj;
29791 fail:
29792 return NULL;
29793 }
29794
29795
29796 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
29797 PyObject *obj;
29798 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29799 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
29800 Py_INCREF(obj);
29801 return Py_BuildValue((char *)"");
29802 }
29803 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
29804 PyObject *resultobj = NULL;
29805 wxDragResult arg1 ;
29806 bool result;
29807 PyObject * obj0 = 0 ;
29808 char *kwnames[] = {
29809 (char *) "res", NULL
29810 };
29811
29812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
29813 {
29814 arg1 = static_cast<wxDragResult >(SWIG_As_int(obj0));
29815 if (SWIG_arg_fail(1)) SWIG_fail;
29816 }
29817 {
29818 PyThreadState* __tstate = wxPyBeginAllowThreads();
29819 result = (bool)wxIsDragResultOk(arg1);
29820
29821 wxPyEndAllowThreads(__tstate);
29822 if (PyErr_Occurred()) SWIG_fail;
29823 }
29824 {
29825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29826 }
29827 return resultobj;
29828 fail:
29829 return NULL;
29830 }
29831
29832
29833 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
29834 PyObject *resultobj = NULL;
29835 wxWindow *arg1 = (wxWindow *) 0 ;
29836 wxCursor const &arg2_defvalue = wxNullCursor ;
29837 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
29838 wxCursor const &arg3_defvalue = wxNullCursor ;
29839 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
29840 wxCursor const &arg4_defvalue = wxNullCursor ;
29841 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
29842 wxPyDropSource *result;
29843 PyObject * obj0 = 0 ;
29844 PyObject * obj1 = 0 ;
29845 PyObject * obj2 = 0 ;
29846 PyObject * obj3 = 0 ;
29847 char *kwnames[] = {
29848 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
29849 };
29850
29851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29853 if (SWIG_arg_fail(1)) SWIG_fail;
29854 if (obj1) {
29855 {
29856 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29857 if (SWIG_arg_fail(2)) SWIG_fail;
29858 if (arg2 == NULL) {
29859 SWIG_null_ref("wxCursor");
29860 }
29861 if (SWIG_arg_fail(2)) SWIG_fail;
29862 }
29863 }
29864 if (obj2) {
29865 {
29866 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29867 if (SWIG_arg_fail(3)) SWIG_fail;
29868 if (arg3 == NULL) {
29869 SWIG_null_ref("wxCursor");
29870 }
29871 if (SWIG_arg_fail(3)) SWIG_fail;
29872 }
29873 }
29874 if (obj3) {
29875 {
29876 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29877 if (SWIG_arg_fail(4)) SWIG_fail;
29878 if (arg4 == NULL) {
29879 SWIG_null_ref("wxCursor");
29880 }
29881 if (SWIG_arg_fail(4)) SWIG_fail;
29882 }
29883 }
29884 {
29885 PyThreadState* __tstate = wxPyBeginAllowThreads();
29886 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
29887
29888 wxPyEndAllowThreads(__tstate);
29889 if (PyErr_Occurred()) SWIG_fail;
29890 }
29891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
29892 return resultobj;
29893 fail:
29894 return NULL;
29895 }
29896
29897
29898 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29899 PyObject *resultobj = NULL;
29900 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29901 PyObject *arg2 = (PyObject *) 0 ;
29902 PyObject *arg3 = (PyObject *) 0 ;
29903 int arg4 ;
29904 PyObject * obj0 = 0 ;
29905 PyObject * obj1 = 0 ;
29906 PyObject * obj2 = 0 ;
29907 PyObject * obj3 = 0 ;
29908 char *kwnames[] = {
29909 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
29910 };
29911
29912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29914 if (SWIG_arg_fail(1)) SWIG_fail;
29915 arg2 = obj1;
29916 arg3 = obj2;
29917 {
29918 arg4 = static_cast<int >(SWIG_As_int(obj3));
29919 if (SWIG_arg_fail(4)) SWIG_fail;
29920 }
29921 {
29922 PyThreadState* __tstate = wxPyBeginAllowThreads();
29923 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
29924
29925 wxPyEndAllowThreads(__tstate);
29926 if (PyErr_Occurred()) SWIG_fail;
29927 }
29928 Py_INCREF(Py_None); resultobj = Py_None;
29929 return resultobj;
29930 fail:
29931 return NULL;
29932 }
29933
29934
29935 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
29936 PyObject *resultobj = NULL;
29937 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29938 PyObject * obj0 = 0 ;
29939 char *kwnames[] = {
29940 (char *) "self", NULL
29941 };
29942
29943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
29944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29945 if (SWIG_arg_fail(1)) SWIG_fail;
29946 {
29947 PyThreadState* __tstate = wxPyBeginAllowThreads();
29948 delete arg1;
29949
29950 wxPyEndAllowThreads(__tstate);
29951 if (PyErr_Occurred()) SWIG_fail;
29952 }
29953 Py_INCREF(Py_None); resultobj = Py_None;
29954 return resultobj;
29955 fail:
29956 return NULL;
29957 }
29958
29959
29960 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29961 PyObject *resultobj = NULL;
29962 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29963 wxDataObject *arg2 = 0 ;
29964 PyObject * obj0 = 0 ;
29965 PyObject * obj1 = 0 ;
29966 char *kwnames[] = {
29967 (char *) "self",(char *) "data", NULL
29968 };
29969
29970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
29971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29972 if (SWIG_arg_fail(1)) SWIG_fail;
29973 {
29974 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29975 if (SWIG_arg_fail(2)) SWIG_fail;
29976 if (arg2 == NULL) {
29977 SWIG_null_ref("wxDataObject");
29978 }
29979 if (SWIG_arg_fail(2)) SWIG_fail;
29980 }
29981 {
29982 PyThreadState* __tstate = wxPyBeginAllowThreads();
29983 (arg1)->SetData(*arg2);
29984
29985 wxPyEndAllowThreads(__tstate);
29986 if (PyErr_Occurred()) SWIG_fail;
29987 }
29988 Py_INCREF(Py_None); resultobj = Py_None;
29989 return resultobj;
29990 fail:
29991 return NULL;
29992 }
29993
29994
29995 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29996 PyObject *resultobj = NULL;
29997 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29998 wxDataObject *result;
29999 PyObject * obj0 = 0 ;
30000 char *kwnames[] = {
30001 (char *) "self", NULL
30002 };
30003
30004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
30005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
30006 if (SWIG_arg_fail(1)) SWIG_fail;
30007 {
30008 PyThreadState* __tstate = wxPyBeginAllowThreads();
30009 result = (wxDataObject *)(arg1)->GetDataObject();
30010
30011 wxPyEndAllowThreads(__tstate);
30012 if (PyErr_Occurred()) SWIG_fail;
30013 }
30014 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
30015 return resultobj;
30016 fail:
30017 return NULL;
30018 }
30019
30020
30021 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30022 PyObject *resultobj = NULL;
30023 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
30024 wxDragResult arg2 ;
30025 wxCursor *arg3 = 0 ;
30026 PyObject * obj0 = 0 ;
30027 PyObject * obj1 = 0 ;
30028 PyObject * obj2 = 0 ;
30029 char *kwnames[] = {
30030 (char *) "self",(char *) "res",(char *) "cursor", NULL
30031 };
30032
30033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
30034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
30035 if (SWIG_arg_fail(1)) SWIG_fail;
30036 {
30037 arg2 = static_cast<wxDragResult >(SWIG_As_int(obj1));
30038 if (SWIG_arg_fail(2)) SWIG_fail;
30039 }
30040 {
30041 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30042 if (SWIG_arg_fail(3)) SWIG_fail;
30043 if (arg3 == NULL) {
30044 SWIG_null_ref("wxCursor");
30045 }
30046 if (SWIG_arg_fail(3)) SWIG_fail;
30047 }
30048 {
30049 PyThreadState* __tstate = wxPyBeginAllowThreads();
30050 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
30051
30052 wxPyEndAllowThreads(__tstate);
30053 if (PyErr_Occurred()) SWIG_fail;
30054 }
30055 Py_INCREF(Py_None); resultobj = Py_None;
30056 return resultobj;
30057 fail:
30058 return NULL;
30059 }
30060
30061
30062 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
30063 PyObject *resultobj = NULL;
30064 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
30065 int arg2 = (int) wxDrag_CopyOnly ;
30066 wxDragResult result;
30067 PyObject * obj0 = 0 ;
30068 PyObject * obj1 = 0 ;
30069 char *kwnames[] = {
30070 (char *) "self",(char *) "flags", NULL
30071 };
30072
30073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
30074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
30075 if (SWIG_arg_fail(1)) SWIG_fail;
30076 if (obj1) {
30077 {
30078 arg2 = static_cast<int >(SWIG_As_int(obj1));
30079 if (SWIG_arg_fail(2)) SWIG_fail;
30080 }
30081 }
30082 {
30083 PyThreadState* __tstate = wxPyBeginAllowThreads();
30084 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
30085
30086 wxPyEndAllowThreads(__tstate);
30087 if (PyErr_Occurred()) SWIG_fail;
30088 }
30089 resultobj = SWIG_From_int((result));
30090 return resultobj;
30091 fail:
30092 return NULL;
30093 }
30094
30095
30096 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
30097 PyObject *resultobj = NULL;
30098 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
30099 wxDragResult arg2 ;
30100 bool result;
30101 PyObject * obj0 = 0 ;
30102 PyObject * obj1 = 0 ;
30103 char *kwnames[] = {
30104 (char *) "self",(char *) "effect", NULL
30105 };
30106
30107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
30108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
30109 if (SWIG_arg_fail(1)) SWIG_fail;
30110 {
30111 arg2 = static_cast<wxDragResult >(SWIG_As_int(obj1));
30112 if (SWIG_arg_fail(2)) SWIG_fail;
30113 }
30114 {
30115 PyThreadState* __tstate = wxPyBeginAllowThreads();
30116 result = (bool)(arg1)->base_GiveFeedback(arg2);
30117
30118 wxPyEndAllowThreads(__tstate);
30119 if (PyErr_Occurred()) SWIG_fail;
30120 }
30121 {
30122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30123 }
30124 return resultobj;
30125 fail:
30126 return NULL;
30127 }
30128
30129
30130 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
30131 PyObject *obj;
30132 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30133 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
30134 Py_INCREF(obj);
30135 return Py_BuildValue((char *)"");
30136 }
30137 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30138 PyObject *resultobj = NULL;
30139 wxDataObject *arg1 = (wxDataObject *) NULL ;
30140 wxPyDropTarget *result;
30141 PyObject * obj0 = 0 ;
30142 char *kwnames[] = {
30143 (char *) "dataObject", NULL
30144 };
30145
30146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
30147 if (obj0) {
30148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30149 if (SWIG_arg_fail(1)) SWIG_fail;
30150 }
30151 {
30152 PyThreadState* __tstate = wxPyBeginAllowThreads();
30153 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
30154
30155 wxPyEndAllowThreads(__tstate);
30156 if (PyErr_Occurred()) SWIG_fail;
30157 }
30158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
30159 return resultobj;
30160 fail:
30161 return NULL;
30162 }
30163
30164
30165 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
30166 PyObject *resultobj = NULL;
30167 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30168 PyObject *arg2 = (PyObject *) 0 ;
30169 PyObject *arg3 = (PyObject *) 0 ;
30170 PyObject * obj0 = 0 ;
30171 PyObject * obj1 = 0 ;
30172 PyObject * obj2 = 0 ;
30173 char *kwnames[] = {
30174 (char *) "self",(char *) "self",(char *) "_class", NULL
30175 };
30176
30177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
30178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30179 if (SWIG_arg_fail(1)) SWIG_fail;
30180 arg2 = obj1;
30181 arg3 = obj2;
30182 {
30183 PyThreadState* __tstate = wxPyBeginAllowThreads();
30184 (arg1)->_setCallbackInfo(arg2,arg3);
30185
30186 wxPyEndAllowThreads(__tstate);
30187 if (PyErr_Occurred()) SWIG_fail;
30188 }
30189 Py_INCREF(Py_None); resultobj = Py_None;
30190 return resultobj;
30191 fail:
30192 return NULL;
30193 }
30194
30195
30196 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30197 PyObject *resultobj = NULL;
30198 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30199 PyObject * obj0 = 0 ;
30200 char *kwnames[] = {
30201 (char *) "self", NULL
30202 };
30203
30204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
30205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30206 if (SWIG_arg_fail(1)) SWIG_fail;
30207 {
30208 PyThreadState* __tstate = wxPyBeginAllowThreads();
30209 delete arg1;
30210
30211 wxPyEndAllowThreads(__tstate);
30212 if (PyErr_Occurred()) SWIG_fail;
30213 }
30214 Py_INCREF(Py_None); resultobj = Py_None;
30215 return resultobj;
30216 fail:
30217 return NULL;
30218 }
30219
30220
30221 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
30222 PyObject *resultobj = NULL;
30223 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30224 wxDataObject *result;
30225 PyObject * obj0 = 0 ;
30226 char *kwnames[] = {
30227 (char *) "self", NULL
30228 };
30229
30230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
30231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30232 if (SWIG_arg_fail(1)) SWIG_fail;
30233 {
30234 PyThreadState* __tstate = wxPyBeginAllowThreads();
30235 result = (wxDataObject *)(arg1)->GetDataObject();
30236
30237 wxPyEndAllowThreads(__tstate);
30238 if (PyErr_Occurred()) SWIG_fail;
30239 }
30240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
30241 return resultobj;
30242 fail:
30243 return NULL;
30244 }
30245
30246
30247 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
30248 PyObject *resultobj = NULL;
30249 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30250 wxDataObject *arg2 = (wxDataObject *) 0 ;
30251 PyObject * obj0 = 0 ;
30252 PyObject * obj1 = 0 ;
30253 char *kwnames[] = {
30254 (char *) "self",(char *) "dataObject", NULL
30255 };
30256
30257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
30258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30259 if (SWIG_arg_fail(1)) SWIG_fail;
30260 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30261 if (SWIG_arg_fail(2)) SWIG_fail;
30262 {
30263 PyThreadState* __tstate = wxPyBeginAllowThreads();
30264 (arg1)->SetDataObject(arg2);
30265
30266 wxPyEndAllowThreads(__tstate);
30267 if (PyErr_Occurred()) SWIG_fail;
30268 }
30269 Py_INCREF(Py_None); resultobj = Py_None;
30270 return resultobj;
30271 fail:
30272 return NULL;
30273 }
30274
30275
30276 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
30277 PyObject *resultobj = NULL;
30278 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30279 int arg2 ;
30280 int arg3 ;
30281 wxDragResult arg4 ;
30282 wxDragResult result;
30283 PyObject * obj0 = 0 ;
30284 PyObject * obj1 = 0 ;
30285 PyObject * obj2 = 0 ;
30286 PyObject * obj3 = 0 ;
30287 char *kwnames[] = {
30288 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30289 };
30290
30291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30293 if (SWIG_arg_fail(1)) SWIG_fail;
30294 {
30295 arg2 = static_cast<int >(SWIG_As_int(obj1));
30296 if (SWIG_arg_fail(2)) SWIG_fail;
30297 }
30298 {
30299 arg3 = static_cast<int >(SWIG_As_int(obj2));
30300 if (SWIG_arg_fail(3)) SWIG_fail;
30301 }
30302 {
30303 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30304 if (SWIG_arg_fail(4)) SWIG_fail;
30305 }
30306 {
30307 PyThreadState* __tstate = wxPyBeginAllowThreads();
30308 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,arg4);
30309
30310 wxPyEndAllowThreads(__tstate);
30311 if (PyErr_Occurred()) SWIG_fail;
30312 }
30313 resultobj = SWIG_From_int((result));
30314 return resultobj;
30315 fail:
30316 return NULL;
30317 }
30318
30319
30320 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
30321 PyObject *resultobj = NULL;
30322 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30323 int arg2 ;
30324 int arg3 ;
30325 wxDragResult arg4 ;
30326 wxDragResult result;
30327 PyObject * obj0 = 0 ;
30328 PyObject * obj1 = 0 ;
30329 PyObject * obj2 = 0 ;
30330 PyObject * obj3 = 0 ;
30331 char *kwnames[] = {
30332 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30333 };
30334
30335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30337 if (SWIG_arg_fail(1)) SWIG_fail;
30338 {
30339 arg2 = static_cast<int >(SWIG_As_int(obj1));
30340 if (SWIG_arg_fail(2)) SWIG_fail;
30341 }
30342 {
30343 arg3 = static_cast<int >(SWIG_As_int(obj2));
30344 if (SWIG_arg_fail(3)) SWIG_fail;
30345 }
30346 {
30347 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30348 if (SWIG_arg_fail(4)) SWIG_fail;
30349 }
30350 {
30351 PyThreadState* __tstate = wxPyBeginAllowThreads();
30352 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,arg4);
30353
30354 wxPyEndAllowThreads(__tstate);
30355 if (PyErr_Occurred()) SWIG_fail;
30356 }
30357 resultobj = SWIG_From_int((result));
30358 return resultobj;
30359 fail:
30360 return NULL;
30361 }
30362
30363
30364 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
30365 PyObject *resultobj = NULL;
30366 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30367 PyObject * obj0 = 0 ;
30368 char *kwnames[] = {
30369 (char *) "self", NULL
30370 };
30371
30372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
30373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30374 if (SWIG_arg_fail(1)) SWIG_fail;
30375 {
30376 PyThreadState* __tstate = wxPyBeginAllowThreads();
30377 (arg1)->base_OnLeave();
30378
30379 wxPyEndAllowThreads(__tstate);
30380 if (PyErr_Occurred()) SWIG_fail;
30381 }
30382 Py_INCREF(Py_None); resultobj = Py_None;
30383 return resultobj;
30384 fail:
30385 return NULL;
30386 }
30387
30388
30389 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
30390 PyObject *resultobj = NULL;
30391 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30392 int arg2 ;
30393 int arg3 ;
30394 bool result;
30395 PyObject * obj0 = 0 ;
30396 PyObject * obj1 = 0 ;
30397 PyObject * obj2 = 0 ;
30398 char *kwnames[] = {
30399 (char *) "self",(char *) "x",(char *) "y", NULL
30400 };
30401
30402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
30403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30404 if (SWIG_arg_fail(1)) SWIG_fail;
30405 {
30406 arg2 = static_cast<int >(SWIG_As_int(obj1));
30407 if (SWIG_arg_fail(2)) SWIG_fail;
30408 }
30409 {
30410 arg3 = static_cast<int >(SWIG_As_int(obj2));
30411 if (SWIG_arg_fail(3)) SWIG_fail;
30412 }
30413 {
30414 PyThreadState* __tstate = wxPyBeginAllowThreads();
30415 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
30416
30417 wxPyEndAllowThreads(__tstate);
30418 if (PyErr_Occurred()) SWIG_fail;
30419 }
30420 {
30421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30422 }
30423 return resultobj;
30424 fail:
30425 return NULL;
30426 }
30427
30428
30429 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30430 PyObject *resultobj = NULL;
30431 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30432 bool result;
30433 PyObject * obj0 = 0 ;
30434 char *kwnames[] = {
30435 (char *) "self", NULL
30436 };
30437
30438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
30439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30440 if (SWIG_arg_fail(1)) SWIG_fail;
30441 {
30442 PyThreadState* __tstate = wxPyBeginAllowThreads();
30443 result = (bool)(arg1)->GetData();
30444
30445 wxPyEndAllowThreads(__tstate);
30446 if (PyErr_Occurred()) SWIG_fail;
30447 }
30448 {
30449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30450 }
30451 return resultobj;
30452 fail:
30453 return NULL;
30454 }
30455
30456
30457 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
30458 PyObject *resultobj = NULL;
30459 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30460 wxDragResult arg2 ;
30461 PyObject * obj0 = 0 ;
30462 PyObject * obj1 = 0 ;
30463 char *kwnames[] = {
30464 (char *) "self",(char *) "action", NULL
30465 };
30466
30467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
30468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30469 if (SWIG_arg_fail(1)) SWIG_fail;
30470 {
30471 arg2 = static_cast<wxDragResult >(SWIG_As_int(obj1));
30472 if (SWIG_arg_fail(2)) SWIG_fail;
30473 }
30474 {
30475 PyThreadState* __tstate = wxPyBeginAllowThreads();
30476 (arg1)->SetDefaultAction(arg2);
30477
30478 wxPyEndAllowThreads(__tstate);
30479 if (PyErr_Occurred()) SWIG_fail;
30480 }
30481 Py_INCREF(Py_None); resultobj = Py_None;
30482 return resultobj;
30483 fail:
30484 return NULL;
30485 }
30486
30487
30488 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
30489 PyObject *resultobj = NULL;
30490 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30491 wxDragResult result;
30492 PyObject * obj0 = 0 ;
30493 char *kwnames[] = {
30494 (char *) "self", NULL
30495 };
30496
30497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
30498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30499 if (SWIG_arg_fail(1)) SWIG_fail;
30500 {
30501 PyThreadState* __tstate = wxPyBeginAllowThreads();
30502 result = (wxDragResult)(arg1)->GetDefaultAction();
30503
30504 wxPyEndAllowThreads(__tstate);
30505 if (PyErr_Occurred()) SWIG_fail;
30506 }
30507 resultobj = SWIG_From_int((result));
30508 return resultobj;
30509 fail:
30510 return NULL;
30511 }
30512
30513
30514 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
30515 PyObject *obj;
30516 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30517 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
30518 Py_INCREF(obj);
30519 return Py_BuildValue((char *)"");
30520 }
30521 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30522 PyObject *resultobj = NULL;
30523 wxPyTextDropTarget *result;
30524 char *kwnames[] = {
30525 NULL
30526 };
30527
30528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
30529 {
30530 PyThreadState* __tstate = wxPyBeginAllowThreads();
30531 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
30532
30533 wxPyEndAllowThreads(__tstate);
30534 if (PyErr_Occurred()) SWIG_fail;
30535 }
30536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
30537 return resultobj;
30538 fail:
30539 return NULL;
30540 }
30541
30542
30543 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
30544 PyObject *resultobj = NULL;
30545 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30546 PyObject *arg2 = (PyObject *) 0 ;
30547 PyObject *arg3 = (PyObject *) 0 ;
30548 PyObject * obj0 = 0 ;
30549 PyObject * obj1 = 0 ;
30550 PyObject * obj2 = 0 ;
30551 char *kwnames[] = {
30552 (char *) "self",(char *) "self",(char *) "_class", NULL
30553 };
30554
30555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
30556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30557 if (SWIG_arg_fail(1)) SWIG_fail;
30558 arg2 = obj1;
30559 arg3 = obj2;
30560 {
30561 PyThreadState* __tstate = wxPyBeginAllowThreads();
30562 (arg1)->_setCallbackInfo(arg2,arg3);
30563
30564 wxPyEndAllowThreads(__tstate);
30565 if (PyErr_Occurred()) SWIG_fail;
30566 }
30567 Py_INCREF(Py_None); resultobj = Py_None;
30568 return resultobj;
30569 fail:
30570 return NULL;
30571 }
30572
30573
30574 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
30575 PyObject *resultobj = NULL;
30576 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30577 int arg2 ;
30578 int arg3 ;
30579 wxDragResult arg4 ;
30580 wxDragResult result;
30581 PyObject * obj0 = 0 ;
30582 PyObject * obj1 = 0 ;
30583 PyObject * obj2 = 0 ;
30584 PyObject * obj3 = 0 ;
30585 char *kwnames[] = {
30586 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30587 };
30588
30589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30591 if (SWIG_arg_fail(1)) SWIG_fail;
30592 {
30593 arg2 = static_cast<int >(SWIG_As_int(obj1));
30594 if (SWIG_arg_fail(2)) SWIG_fail;
30595 }
30596 {
30597 arg3 = static_cast<int >(SWIG_As_int(obj2));
30598 if (SWIG_arg_fail(3)) SWIG_fail;
30599 }
30600 {
30601 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30602 if (SWIG_arg_fail(4)) SWIG_fail;
30603 }
30604 {
30605 PyThreadState* __tstate = wxPyBeginAllowThreads();
30606 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,arg4);
30607
30608 wxPyEndAllowThreads(__tstate);
30609 if (PyErr_Occurred()) SWIG_fail;
30610 }
30611 resultobj = SWIG_From_int((result));
30612 return resultobj;
30613 fail:
30614 return NULL;
30615 }
30616
30617
30618 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
30619 PyObject *resultobj = NULL;
30620 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30621 int arg2 ;
30622 int arg3 ;
30623 wxDragResult arg4 ;
30624 wxDragResult result;
30625 PyObject * obj0 = 0 ;
30626 PyObject * obj1 = 0 ;
30627 PyObject * obj2 = 0 ;
30628 PyObject * obj3 = 0 ;
30629 char *kwnames[] = {
30630 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30631 };
30632
30633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30635 if (SWIG_arg_fail(1)) SWIG_fail;
30636 {
30637 arg2 = static_cast<int >(SWIG_As_int(obj1));
30638 if (SWIG_arg_fail(2)) SWIG_fail;
30639 }
30640 {
30641 arg3 = static_cast<int >(SWIG_As_int(obj2));
30642 if (SWIG_arg_fail(3)) SWIG_fail;
30643 }
30644 {
30645 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30646 if (SWIG_arg_fail(4)) SWIG_fail;
30647 }
30648 {
30649 PyThreadState* __tstate = wxPyBeginAllowThreads();
30650 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,arg4);
30651
30652 wxPyEndAllowThreads(__tstate);
30653 if (PyErr_Occurred()) SWIG_fail;
30654 }
30655 resultobj = SWIG_From_int((result));
30656 return resultobj;
30657 fail:
30658 return NULL;
30659 }
30660
30661
30662 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
30663 PyObject *resultobj = NULL;
30664 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30665 PyObject * obj0 = 0 ;
30666 char *kwnames[] = {
30667 (char *) "self", NULL
30668 };
30669
30670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
30671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30672 if (SWIG_arg_fail(1)) SWIG_fail;
30673 {
30674 PyThreadState* __tstate = wxPyBeginAllowThreads();
30675 (arg1)->base_OnLeave();
30676
30677 wxPyEndAllowThreads(__tstate);
30678 if (PyErr_Occurred()) SWIG_fail;
30679 }
30680 Py_INCREF(Py_None); resultobj = Py_None;
30681 return resultobj;
30682 fail:
30683 return NULL;
30684 }
30685
30686
30687 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
30688 PyObject *resultobj = NULL;
30689 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30690 int arg2 ;
30691 int arg3 ;
30692 bool result;
30693 PyObject * obj0 = 0 ;
30694 PyObject * obj1 = 0 ;
30695 PyObject * obj2 = 0 ;
30696 char *kwnames[] = {
30697 (char *) "self",(char *) "x",(char *) "y", NULL
30698 };
30699
30700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
30701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30702 if (SWIG_arg_fail(1)) SWIG_fail;
30703 {
30704 arg2 = static_cast<int >(SWIG_As_int(obj1));
30705 if (SWIG_arg_fail(2)) SWIG_fail;
30706 }
30707 {
30708 arg3 = static_cast<int >(SWIG_As_int(obj2));
30709 if (SWIG_arg_fail(3)) SWIG_fail;
30710 }
30711 {
30712 PyThreadState* __tstate = wxPyBeginAllowThreads();
30713 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
30714
30715 wxPyEndAllowThreads(__tstate);
30716 if (PyErr_Occurred()) SWIG_fail;
30717 }
30718 {
30719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30720 }
30721 return resultobj;
30722 fail:
30723 return NULL;
30724 }
30725
30726
30727 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
30728 PyObject *resultobj = NULL;
30729 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30730 int arg2 ;
30731 int arg3 ;
30732 wxDragResult arg4 ;
30733 wxDragResult result;
30734 PyObject * obj0 = 0 ;
30735 PyObject * obj1 = 0 ;
30736 PyObject * obj2 = 0 ;
30737 PyObject * obj3 = 0 ;
30738 char *kwnames[] = {
30739 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30740 };
30741
30742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30744 if (SWIG_arg_fail(1)) SWIG_fail;
30745 {
30746 arg2 = static_cast<int >(SWIG_As_int(obj1));
30747 if (SWIG_arg_fail(2)) SWIG_fail;
30748 }
30749 {
30750 arg3 = static_cast<int >(SWIG_As_int(obj2));
30751 if (SWIG_arg_fail(3)) SWIG_fail;
30752 }
30753 {
30754 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30755 if (SWIG_arg_fail(4)) SWIG_fail;
30756 }
30757 {
30758 PyThreadState* __tstate = wxPyBeginAllowThreads();
30759 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,arg4);
30760
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 resultobj = SWIG_From_int((result));
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
30772 PyObject *obj;
30773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30774 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
30775 Py_INCREF(obj);
30776 return Py_BuildValue((char *)"");
30777 }
30778 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30779 PyObject *resultobj = NULL;
30780 wxPyFileDropTarget *result;
30781 char *kwnames[] = {
30782 NULL
30783 };
30784
30785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
30786 {
30787 PyThreadState* __tstate = wxPyBeginAllowThreads();
30788 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
30789
30790 wxPyEndAllowThreads(__tstate);
30791 if (PyErr_Occurred()) SWIG_fail;
30792 }
30793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
30794 return resultobj;
30795 fail:
30796 return NULL;
30797 }
30798
30799
30800 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
30801 PyObject *resultobj = NULL;
30802 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30803 PyObject *arg2 = (PyObject *) 0 ;
30804 PyObject *arg3 = (PyObject *) 0 ;
30805 PyObject * obj0 = 0 ;
30806 PyObject * obj1 = 0 ;
30807 PyObject * obj2 = 0 ;
30808 char *kwnames[] = {
30809 (char *) "self",(char *) "self",(char *) "_class", NULL
30810 };
30811
30812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
30813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30814 if (SWIG_arg_fail(1)) SWIG_fail;
30815 arg2 = obj1;
30816 arg3 = obj2;
30817 {
30818 PyThreadState* __tstate = wxPyBeginAllowThreads();
30819 (arg1)->_setCallbackInfo(arg2,arg3);
30820
30821 wxPyEndAllowThreads(__tstate);
30822 if (PyErr_Occurred()) SWIG_fail;
30823 }
30824 Py_INCREF(Py_None); resultobj = Py_None;
30825 return resultobj;
30826 fail:
30827 return NULL;
30828 }
30829
30830
30831 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
30832 PyObject *resultobj = NULL;
30833 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30834 int arg2 ;
30835 int arg3 ;
30836 wxDragResult arg4 ;
30837 wxDragResult result;
30838 PyObject * obj0 = 0 ;
30839 PyObject * obj1 = 0 ;
30840 PyObject * obj2 = 0 ;
30841 PyObject * obj3 = 0 ;
30842 char *kwnames[] = {
30843 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30844 };
30845
30846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30848 if (SWIG_arg_fail(1)) SWIG_fail;
30849 {
30850 arg2 = static_cast<int >(SWIG_As_int(obj1));
30851 if (SWIG_arg_fail(2)) SWIG_fail;
30852 }
30853 {
30854 arg3 = static_cast<int >(SWIG_As_int(obj2));
30855 if (SWIG_arg_fail(3)) SWIG_fail;
30856 }
30857 {
30858 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30859 if (SWIG_arg_fail(4)) SWIG_fail;
30860 }
30861 {
30862 PyThreadState* __tstate = wxPyBeginAllowThreads();
30863 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,arg4);
30864
30865 wxPyEndAllowThreads(__tstate);
30866 if (PyErr_Occurred()) SWIG_fail;
30867 }
30868 resultobj = SWIG_From_int((result));
30869 return resultobj;
30870 fail:
30871 return NULL;
30872 }
30873
30874
30875 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
30876 PyObject *resultobj = NULL;
30877 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30878 int arg2 ;
30879 int arg3 ;
30880 wxDragResult arg4 ;
30881 wxDragResult result;
30882 PyObject * obj0 = 0 ;
30883 PyObject * obj1 = 0 ;
30884 PyObject * obj2 = 0 ;
30885 PyObject * obj3 = 0 ;
30886 char *kwnames[] = {
30887 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30888 };
30889
30890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30892 if (SWIG_arg_fail(1)) SWIG_fail;
30893 {
30894 arg2 = static_cast<int >(SWIG_As_int(obj1));
30895 if (SWIG_arg_fail(2)) SWIG_fail;
30896 }
30897 {
30898 arg3 = static_cast<int >(SWIG_As_int(obj2));
30899 if (SWIG_arg_fail(3)) SWIG_fail;
30900 }
30901 {
30902 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30903 if (SWIG_arg_fail(4)) SWIG_fail;
30904 }
30905 {
30906 PyThreadState* __tstate = wxPyBeginAllowThreads();
30907 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,arg4);
30908
30909 wxPyEndAllowThreads(__tstate);
30910 if (PyErr_Occurred()) SWIG_fail;
30911 }
30912 resultobj = SWIG_From_int((result));
30913 return resultobj;
30914 fail:
30915 return NULL;
30916 }
30917
30918
30919 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
30920 PyObject *resultobj = NULL;
30921 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30922 PyObject * obj0 = 0 ;
30923 char *kwnames[] = {
30924 (char *) "self", NULL
30925 };
30926
30927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
30928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30929 if (SWIG_arg_fail(1)) SWIG_fail;
30930 {
30931 PyThreadState* __tstate = wxPyBeginAllowThreads();
30932 (arg1)->base_OnLeave();
30933
30934 wxPyEndAllowThreads(__tstate);
30935 if (PyErr_Occurred()) SWIG_fail;
30936 }
30937 Py_INCREF(Py_None); resultobj = Py_None;
30938 return resultobj;
30939 fail:
30940 return NULL;
30941 }
30942
30943
30944 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
30945 PyObject *resultobj = NULL;
30946 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30947 int arg2 ;
30948 int arg3 ;
30949 bool result;
30950 PyObject * obj0 = 0 ;
30951 PyObject * obj1 = 0 ;
30952 PyObject * obj2 = 0 ;
30953 char *kwnames[] = {
30954 (char *) "self",(char *) "x",(char *) "y", NULL
30955 };
30956
30957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
30958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30959 if (SWIG_arg_fail(1)) SWIG_fail;
30960 {
30961 arg2 = static_cast<int >(SWIG_As_int(obj1));
30962 if (SWIG_arg_fail(2)) SWIG_fail;
30963 }
30964 {
30965 arg3 = static_cast<int >(SWIG_As_int(obj2));
30966 if (SWIG_arg_fail(3)) SWIG_fail;
30967 }
30968 {
30969 PyThreadState* __tstate = wxPyBeginAllowThreads();
30970 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
30971
30972 wxPyEndAllowThreads(__tstate);
30973 if (PyErr_Occurred()) SWIG_fail;
30974 }
30975 {
30976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30977 }
30978 return resultobj;
30979 fail:
30980 return NULL;
30981 }
30982
30983
30984 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
30985 PyObject *resultobj = NULL;
30986 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30987 int arg2 ;
30988 int arg3 ;
30989 wxDragResult arg4 ;
30990 wxDragResult result;
30991 PyObject * obj0 = 0 ;
30992 PyObject * obj1 = 0 ;
30993 PyObject * obj2 = 0 ;
30994 PyObject * obj3 = 0 ;
30995 char *kwnames[] = {
30996 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30997 };
30998
30999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
31001 if (SWIG_arg_fail(1)) SWIG_fail;
31002 {
31003 arg2 = static_cast<int >(SWIG_As_int(obj1));
31004 if (SWIG_arg_fail(2)) SWIG_fail;
31005 }
31006 {
31007 arg3 = static_cast<int >(SWIG_As_int(obj2));
31008 if (SWIG_arg_fail(3)) SWIG_fail;
31009 }
31010 {
31011 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
31012 if (SWIG_arg_fail(4)) SWIG_fail;
31013 }
31014 {
31015 PyThreadState* __tstate = wxPyBeginAllowThreads();
31016 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,arg4);
31017
31018 wxPyEndAllowThreads(__tstate);
31019 if (PyErr_Occurred()) SWIG_fail;
31020 }
31021 resultobj = SWIG_From_int((result));
31022 return resultobj;
31023 fail:
31024 return NULL;
31025 }
31026
31027
31028 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
31029 PyObject *obj;
31030 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31031 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
31032 Py_INCREF(obj);
31033 return Py_BuildValue((char *)"");
31034 }
31035 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
31036 PyObject *resultobj = NULL;
31037 wxClipboard *result;
31038 char *kwnames[] = {
31039 NULL
31040 };
31041
31042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
31043 {
31044 PyThreadState* __tstate = wxPyBeginAllowThreads();
31045 result = (wxClipboard *)new wxClipboard();
31046
31047 wxPyEndAllowThreads(__tstate);
31048 if (PyErr_Occurred()) SWIG_fail;
31049 }
31050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
31051 return resultobj;
31052 fail:
31053 return NULL;
31054 }
31055
31056
31057 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
31058 PyObject *resultobj = NULL;
31059 wxClipboard *arg1 = (wxClipboard *) 0 ;
31060 PyObject * obj0 = 0 ;
31061 char *kwnames[] = {
31062 (char *) "self", NULL
31063 };
31064
31065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
31066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31067 if (SWIG_arg_fail(1)) SWIG_fail;
31068 {
31069 PyThreadState* __tstate = wxPyBeginAllowThreads();
31070 delete arg1;
31071
31072 wxPyEndAllowThreads(__tstate);
31073 if (PyErr_Occurred()) SWIG_fail;
31074 }
31075 Py_INCREF(Py_None); resultobj = Py_None;
31076 return resultobj;
31077 fail:
31078 return NULL;
31079 }
31080
31081
31082 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
31083 PyObject *resultobj = NULL;
31084 wxClipboard *arg1 = (wxClipboard *) 0 ;
31085 bool result;
31086 PyObject * obj0 = 0 ;
31087 char *kwnames[] = {
31088 (char *) "self", NULL
31089 };
31090
31091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
31092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31093 if (SWIG_arg_fail(1)) SWIG_fail;
31094 {
31095 PyThreadState* __tstate = wxPyBeginAllowThreads();
31096 result = (bool)(arg1)->Open();
31097
31098 wxPyEndAllowThreads(__tstate);
31099 if (PyErr_Occurred()) SWIG_fail;
31100 }
31101 {
31102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31103 }
31104 return resultobj;
31105 fail:
31106 return NULL;
31107 }
31108
31109
31110 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
31111 PyObject *resultobj = NULL;
31112 wxClipboard *arg1 = (wxClipboard *) 0 ;
31113 PyObject * obj0 = 0 ;
31114 char *kwnames[] = {
31115 (char *) "self", NULL
31116 };
31117
31118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
31119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31120 if (SWIG_arg_fail(1)) SWIG_fail;
31121 {
31122 PyThreadState* __tstate = wxPyBeginAllowThreads();
31123 (arg1)->Close();
31124
31125 wxPyEndAllowThreads(__tstate);
31126 if (PyErr_Occurred()) SWIG_fail;
31127 }
31128 Py_INCREF(Py_None); resultobj = Py_None;
31129 return resultobj;
31130 fail:
31131 return NULL;
31132 }
31133
31134
31135 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
31136 PyObject *resultobj = NULL;
31137 wxClipboard *arg1 = (wxClipboard *) 0 ;
31138 bool result;
31139 PyObject * obj0 = 0 ;
31140 char *kwnames[] = {
31141 (char *) "self", NULL
31142 };
31143
31144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
31145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31146 if (SWIG_arg_fail(1)) SWIG_fail;
31147 {
31148 PyThreadState* __tstate = wxPyBeginAllowThreads();
31149 result = (bool)((wxClipboard const *)arg1)->IsOpened();
31150
31151 wxPyEndAllowThreads(__tstate);
31152 if (PyErr_Occurred()) SWIG_fail;
31153 }
31154 {
31155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31156 }
31157 return resultobj;
31158 fail:
31159 return NULL;
31160 }
31161
31162
31163 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
31164 PyObject *resultobj = NULL;
31165 wxClipboard *arg1 = (wxClipboard *) 0 ;
31166 wxDataObject *arg2 = (wxDataObject *) 0 ;
31167 bool result;
31168 PyObject * obj0 = 0 ;
31169 PyObject * obj1 = 0 ;
31170 char *kwnames[] = {
31171 (char *) "self",(char *) "data", NULL
31172 };
31173
31174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
31175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31176 if (SWIG_arg_fail(1)) SWIG_fail;
31177 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31178 if (SWIG_arg_fail(2)) SWIG_fail;
31179 {
31180 PyThreadState* __tstate = wxPyBeginAllowThreads();
31181 result = (bool)(arg1)->AddData(arg2);
31182
31183 wxPyEndAllowThreads(__tstate);
31184 if (PyErr_Occurred()) SWIG_fail;
31185 }
31186 {
31187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31188 }
31189 return resultobj;
31190 fail:
31191 return NULL;
31192 }
31193
31194
31195 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
31196 PyObject *resultobj = NULL;
31197 wxClipboard *arg1 = (wxClipboard *) 0 ;
31198 wxDataObject *arg2 = (wxDataObject *) 0 ;
31199 bool result;
31200 PyObject * obj0 = 0 ;
31201 PyObject * obj1 = 0 ;
31202 char *kwnames[] = {
31203 (char *) "self",(char *) "data", NULL
31204 };
31205
31206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
31207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31208 if (SWIG_arg_fail(1)) SWIG_fail;
31209 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31210 if (SWIG_arg_fail(2)) SWIG_fail;
31211 {
31212 PyThreadState* __tstate = wxPyBeginAllowThreads();
31213 result = (bool)(arg1)->SetData(arg2);
31214
31215 wxPyEndAllowThreads(__tstate);
31216 if (PyErr_Occurred()) SWIG_fail;
31217 }
31218 {
31219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31220 }
31221 return resultobj;
31222 fail:
31223 return NULL;
31224 }
31225
31226
31227 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
31228 PyObject *resultobj = NULL;
31229 wxClipboard *arg1 = (wxClipboard *) 0 ;
31230 wxDataFormat *arg2 = 0 ;
31231 bool result;
31232 PyObject * obj0 = 0 ;
31233 PyObject * obj1 = 0 ;
31234 char *kwnames[] = {
31235 (char *) "self",(char *) "format", NULL
31236 };
31237
31238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
31239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31240 if (SWIG_arg_fail(1)) SWIG_fail;
31241 {
31242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
31243 if (SWIG_arg_fail(2)) SWIG_fail;
31244 if (arg2 == NULL) {
31245 SWIG_null_ref("wxDataFormat");
31246 }
31247 if (SWIG_arg_fail(2)) SWIG_fail;
31248 }
31249 {
31250 PyThreadState* __tstate = wxPyBeginAllowThreads();
31251 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
31252
31253 wxPyEndAllowThreads(__tstate);
31254 if (PyErr_Occurred()) SWIG_fail;
31255 }
31256 {
31257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31258 }
31259 return resultobj;
31260 fail:
31261 return NULL;
31262 }
31263
31264
31265 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
31266 PyObject *resultobj = NULL;
31267 wxClipboard *arg1 = (wxClipboard *) 0 ;
31268 wxDataObject *arg2 = 0 ;
31269 bool result;
31270 PyObject * obj0 = 0 ;
31271 PyObject * obj1 = 0 ;
31272 char *kwnames[] = {
31273 (char *) "self",(char *) "data", NULL
31274 };
31275
31276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
31277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31278 if (SWIG_arg_fail(1)) SWIG_fail;
31279 {
31280 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
31281 if (SWIG_arg_fail(2)) SWIG_fail;
31282 if (arg2 == NULL) {
31283 SWIG_null_ref("wxDataObject");
31284 }
31285 if (SWIG_arg_fail(2)) SWIG_fail;
31286 }
31287 {
31288 PyThreadState* __tstate = wxPyBeginAllowThreads();
31289 result = (bool)(arg1)->GetData(*arg2);
31290
31291 wxPyEndAllowThreads(__tstate);
31292 if (PyErr_Occurred()) SWIG_fail;
31293 }
31294 {
31295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31296 }
31297 return resultobj;
31298 fail:
31299 return NULL;
31300 }
31301
31302
31303 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
31304 PyObject *resultobj = NULL;
31305 wxClipboard *arg1 = (wxClipboard *) 0 ;
31306 PyObject * obj0 = 0 ;
31307 char *kwnames[] = {
31308 (char *) "self", NULL
31309 };
31310
31311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
31312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31313 if (SWIG_arg_fail(1)) SWIG_fail;
31314 {
31315 PyThreadState* __tstate = wxPyBeginAllowThreads();
31316 (arg1)->Clear();
31317
31318 wxPyEndAllowThreads(__tstate);
31319 if (PyErr_Occurred()) SWIG_fail;
31320 }
31321 Py_INCREF(Py_None); resultobj = Py_None;
31322 return resultobj;
31323 fail:
31324 return NULL;
31325 }
31326
31327
31328 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
31329 PyObject *resultobj = NULL;
31330 wxClipboard *arg1 = (wxClipboard *) 0 ;
31331 bool result;
31332 PyObject * obj0 = 0 ;
31333 char *kwnames[] = {
31334 (char *) "self", NULL
31335 };
31336
31337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
31338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31339 if (SWIG_arg_fail(1)) SWIG_fail;
31340 {
31341 PyThreadState* __tstate = wxPyBeginAllowThreads();
31342 result = (bool)(arg1)->Flush();
31343
31344 wxPyEndAllowThreads(__tstate);
31345 if (PyErr_Occurred()) SWIG_fail;
31346 }
31347 {
31348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31349 }
31350 return resultobj;
31351 fail:
31352 return NULL;
31353 }
31354
31355
31356 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
31357 PyObject *resultobj = NULL;
31358 wxClipboard *arg1 = (wxClipboard *) 0 ;
31359 bool arg2 = (bool) true ;
31360 PyObject * obj0 = 0 ;
31361 PyObject * obj1 = 0 ;
31362 char *kwnames[] = {
31363 (char *) "self",(char *) "primary", NULL
31364 };
31365
31366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
31367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31368 if (SWIG_arg_fail(1)) SWIG_fail;
31369 if (obj1) {
31370 {
31371 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
31372 if (SWIG_arg_fail(2)) SWIG_fail;
31373 }
31374 }
31375 {
31376 PyThreadState* __tstate = wxPyBeginAllowThreads();
31377 (arg1)->UsePrimarySelection(arg2);
31378
31379 wxPyEndAllowThreads(__tstate);
31380 if (PyErr_Occurred()) SWIG_fail;
31381 }
31382 Py_INCREF(Py_None); resultobj = Py_None;
31383 return resultobj;
31384 fail:
31385 return NULL;
31386 }
31387
31388
31389 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31390 PyObject *resultobj = NULL;
31391 wxClipboard *result;
31392 char *kwnames[] = {
31393 NULL
31394 };
31395
31396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
31397 {
31398 PyThreadState* __tstate = wxPyBeginAllowThreads();
31399 result = (wxClipboard *)wxClipboard::Get();
31400
31401 wxPyEndAllowThreads(__tstate);
31402 if (PyErr_Occurred()) SWIG_fail;
31403 }
31404 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
31405 return resultobj;
31406 fail:
31407 return NULL;
31408 }
31409
31410
31411 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
31412 PyObject *obj;
31413 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31414 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
31415 Py_INCREF(obj);
31416 return Py_BuildValue((char *)"");
31417 }
31418 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
31419 PyObject *resultobj = NULL;
31420 wxClipboard *arg1 = (wxClipboard *) NULL ;
31421 wxClipboardLocker *result;
31422 PyObject * obj0 = 0 ;
31423 char *kwnames[] = {
31424 (char *) "clipboard", NULL
31425 };
31426
31427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
31428 if (obj0) {
31429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31430 if (SWIG_arg_fail(1)) SWIG_fail;
31431 }
31432 {
31433 PyThreadState* __tstate = wxPyBeginAllowThreads();
31434 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
31435
31436 wxPyEndAllowThreads(__tstate);
31437 if (PyErr_Occurred()) SWIG_fail;
31438 }
31439 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
31440 return resultobj;
31441 fail:
31442 return NULL;
31443 }
31444
31445
31446 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
31447 PyObject *resultobj = NULL;
31448 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
31449 PyObject * obj0 = 0 ;
31450 char *kwnames[] = {
31451 (char *) "self", NULL
31452 };
31453
31454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
31455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
31456 if (SWIG_arg_fail(1)) SWIG_fail;
31457 {
31458 PyThreadState* __tstate = wxPyBeginAllowThreads();
31459 delete arg1;
31460
31461 wxPyEndAllowThreads(__tstate);
31462 if (PyErr_Occurred()) SWIG_fail;
31463 }
31464 Py_INCREF(Py_None); resultobj = Py_None;
31465 return resultobj;
31466 fail:
31467 return NULL;
31468 }
31469
31470
31471 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
31472 PyObject *resultobj = NULL;
31473 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
31474 bool result;
31475 PyObject * obj0 = 0 ;
31476 char *kwnames[] = {
31477 (char *) "self", NULL
31478 };
31479
31480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
31481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
31482 if (SWIG_arg_fail(1)) SWIG_fail;
31483 {
31484 PyThreadState* __tstate = wxPyBeginAllowThreads();
31485 result = (bool)wxClipboardLocker___nonzero__(arg1);
31486
31487 wxPyEndAllowThreads(__tstate);
31488 if (PyErr_Occurred()) SWIG_fail;
31489 }
31490 {
31491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31492 }
31493 return resultobj;
31494 fail:
31495 return NULL;
31496 }
31497
31498
31499 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
31500 PyObject *obj;
31501 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31502 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
31503 Py_INCREF(obj);
31504 return Py_BuildValue((char *)"");
31505 }
31506 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
31507 PyObject *resultobj = NULL;
31508 int arg1 = (int) 0 ;
31509 int arg2 = (int) 0 ;
31510 int arg3 = (int) 0 ;
31511 int arg4 = (int) 0 ;
31512 wxVideoMode *result;
31513 PyObject * obj0 = 0 ;
31514 PyObject * obj1 = 0 ;
31515 PyObject * obj2 = 0 ;
31516 PyObject * obj3 = 0 ;
31517 char *kwnames[] = {
31518 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
31519 };
31520
31521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31522 if (obj0) {
31523 {
31524 arg1 = static_cast<int >(SWIG_As_int(obj0));
31525 if (SWIG_arg_fail(1)) SWIG_fail;
31526 }
31527 }
31528 if (obj1) {
31529 {
31530 arg2 = static_cast<int >(SWIG_As_int(obj1));
31531 if (SWIG_arg_fail(2)) SWIG_fail;
31532 }
31533 }
31534 if (obj2) {
31535 {
31536 arg3 = static_cast<int >(SWIG_As_int(obj2));
31537 if (SWIG_arg_fail(3)) SWIG_fail;
31538 }
31539 }
31540 if (obj3) {
31541 {
31542 arg4 = static_cast<int >(SWIG_As_int(obj3));
31543 if (SWIG_arg_fail(4)) SWIG_fail;
31544 }
31545 }
31546 {
31547 PyThreadState* __tstate = wxPyBeginAllowThreads();
31548 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
31549
31550 wxPyEndAllowThreads(__tstate);
31551 if (PyErr_Occurred()) SWIG_fail;
31552 }
31553 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
31554 return resultobj;
31555 fail:
31556 return NULL;
31557 }
31558
31559
31560 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
31561 PyObject *resultobj = NULL;
31562 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31563 PyObject * obj0 = 0 ;
31564 char *kwnames[] = {
31565 (char *) "self", NULL
31566 };
31567
31568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
31569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31570 if (SWIG_arg_fail(1)) SWIG_fail;
31571 {
31572 PyThreadState* __tstate = wxPyBeginAllowThreads();
31573 delete arg1;
31574
31575 wxPyEndAllowThreads(__tstate);
31576 if (PyErr_Occurred()) SWIG_fail;
31577 }
31578 Py_INCREF(Py_None); resultobj = Py_None;
31579 return resultobj;
31580 fail:
31581 return NULL;
31582 }
31583
31584
31585 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
31586 PyObject *resultobj = NULL;
31587 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31588 wxVideoMode *arg2 = 0 ;
31589 bool result;
31590 PyObject * obj0 = 0 ;
31591 PyObject * obj1 = 0 ;
31592 char *kwnames[] = {
31593 (char *) "self",(char *) "other", NULL
31594 };
31595
31596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
31597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31598 if (SWIG_arg_fail(1)) SWIG_fail;
31599 {
31600 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31601 if (SWIG_arg_fail(2)) SWIG_fail;
31602 if (arg2 == NULL) {
31603 SWIG_null_ref("wxVideoMode");
31604 }
31605 if (SWIG_arg_fail(2)) SWIG_fail;
31606 }
31607 {
31608 PyThreadState* __tstate = wxPyBeginAllowThreads();
31609 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
31610
31611 wxPyEndAllowThreads(__tstate);
31612 if (PyErr_Occurred()) SWIG_fail;
31613 }
31614 {
31615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31616 }
31617 return resultobj;
31618 fail:
31619 return NULL;
31620 }
31621
31622
31623 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
31624 PyObject *resultobj = NULL;
31625 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31626 int result;
31627 PyObject * obj0 = 0 ;
31628 char *kwnames[] = {
31629 (char *) "self", NULL
31630 };
31631
31632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
31633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31634 if (SWIG_arg_fail(1)) SWIG_fail;
31635 {
31636 PyThreadState* __tstate = wxPyBeginAllowThreads();
31637 result = (int)((wxVideoMode const *)arg1)->GetWidth();
31638
31639 wxPyEndAllowThreads(__tstate);
31640 if (PyErr_Occurred()) SWIG_fail;
31641 }
31642 {
31643 resultobj = SWIG_From_int(static_cast<int >(result));
31644 }
31645 return resultobj;
31646 fail:
31647 return NULL;
31648 }
31649
31650
31651 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
31652 PyObject *resultobj = NULL;
31653 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31654 int result;
31655 PyObject * obj0 = 0 ;
31656 char *kwnames[] = {
31657 (char *) "self", NULL
31658 };
31659
31660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
31661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31662 if (SWIG_arg_fail(1)) SWIG_fail;
31663 {
31664 PyThreadState* __tstate = wxPyBeginAllowThreads();
31665 result = (int)((wxVideoMode const *)arg1)->GetHeight();
31666
31667 wxPyEndAllowThreads(__tstate);
31668 if (PyErr_Occurred()) SWIG_fail;
31669 }
31670 {
31671 resultobj = SWIG_From_int(static_cast<int >(result));
31672 }
31673 return resultobj;
31674 fail:
31675 return NULL;
31676 }
31677
31678
31679 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
31680 PyObject *resultobj = NULL;
31681 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31682 int result;
31683 PyObject * obj0 = 0 ;
31684 char *kwnames[] = {
31685 (char *) "self", NULL
31686 };
31687
31688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
31689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31690 if (SWIG_arg_fail(1)) SWIG_fail;
31691 {
31692 PyThreadState* __tstate = wxPyBeginAllowThreads();
31693 result = (int)((wxVideoMode const *)arg1)->GetDepth();
31694
31695 wxPyEndAllowThreads(__tstate);
31696 if (PyErr_Occurred()) SWIG_fail;
31697 }
31698 {
31699 resultobj = SWIG_From_int(static_cast<int >(result));
31700 }
31701 return resultobj;
31702 fail:
31703 return NULL;
31704 }
31705
31706
31707 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
31708 PyObject *resultobj = NULL;
31709 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31710 bool result;
31711 PyObject * obj0 = 0 ;
31712 char *kwnames[] = {
31713 (char *) "self", NULL
31714 };
31715
31716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
31717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31718 if (SWIG_arg_fail(1)) SWIG_fail;
31719 {
31720 PyThreadState* __tstate = wxPyBeginAllowThreads();
31721 result = (bool)((wxVideoMode const *)arg1)->IsOk();
31722
31723 wxPyEndAllowThreads(__tstate);
31724 if (PyErr_Occurred()) SWIG_fail;
31725 }
31726 {
31727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31728 }
31729 return resultobj;
31730 fail:
31731 return NULL;
31732 }
31733
31734
31735 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
31736 PyObject *resultobj = NULL;
31737 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31738 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
31739 bool result;
31740 PyObject * obj0 = 0 ;
31741 PyObject * obj1 = 0 ;
31742 char *kwnames[] = {
31743 (char *) "self",(char *) "other", NULL
31744 };
31745
31746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
31747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31748 if (SWIG_arg_fail(1)) SWIG_fail;
31749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31750 if (SWIG_arg_fail(2)) SWIG_fail;
31751 {
31752 PyThreadState* __tstate = wxPyBeginAllowThreads();
31753 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
31754
31755 wxPyEndAllowThreads(__tstate);
31756 if (PyErr_Occurred()) SWIG_fail;
31757 }
31758 {
31759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31760 }
31761 return resultobj;
31762 fail:
31763 return NULL;
31764 }
31765
31766
31767 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
31768 PyObject *resultobj = NULL;
31769 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31770 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
31771 bool result;
31772 PyObject * obj0 = 0 ;
31773 PyObject * obj1 = 0 ;
31774 char *kwnames[] = {
31775 (char *) "self",(char *) "other", NULL
31776 };
31777
31778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
31779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31780 if (SWIG_arg_fail(1)) SWIG_fail;
31781 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31782 if (SWIG_arg_fail(2)) SWIG_fail;
31783 {
31784 PyThreadState* __tstate = wxPyBeginAllowThreads();
31785 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
31786
31787 wxPyEndAllowThreads(__tstate);
31788 if (PyErr_Occurred()) SWIG_fail;
31789 }
31790 {
31791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31792 }
31793 return resultobj;
31794 fail:
31795 return NULL;
31796 }
31797
31798
31799 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
31800 PyObject *resultobj = NULL;
31801 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31802 int arg2 ;
31803 PyObject * obj0 = 0 ;
31804 PyObject * obj1 = 0 ;
31805 char *kwnames[] = {
31806 (char *) "self",(char *) "w", NULL
31807 };
31808
31809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
31810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31811 if (SWIG_arg_fail(1)) SWIG_fail;
31812 {
31813 arg2 = static_cast<int >(SWIG_As_int(obj1));
31814 if (SWIG_arg_fail(2)) SWIG_fail;
31815 }
31816 if (arg1) (arg1)->w = arg2;
31817
31818 Py_INCREF(Py_None); resultobj = Py_None;
31819 return resultobj;
31820 fail:
31821 return NULL;
31822 }
31823
31824
31825 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
31826 PyObject *resultobj = NULL;
31827 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31828 int result;
31829 PyObject * obj0 = 0 ;
31830 char *kwnames[] = {
31831 (char *) "self", NULL
31832 };
31833
31834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
31835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31836 if (SWIG_arg_fail(1)) SWIG_fail;
31837 result = (int) ((arg1)->w);
31838
31839 {
31840 resultobj = SWIG_From_int(static_cast<int >(result));
31841 }
31842 return resultobj;
31843 fail:
31844 return NULL;
31845 }
31846
31847
31848 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
31849 PyObject *resultobj = NULL;
31850 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31851 int arg2 ;
31852 PyObject * obj0 = 0 ;
31853 PyObject * obj1 = 0 ;
31854 char *kwnames[] = {
31855 (char *) "self",(char *) "h", NULL
31856 };
31857
31858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
31859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31860 if (SWIG_arg_fail(1)) SWIG_fail;
31861 {
31862 arg2 = static_cast<int >(SWIG_As_int(obj1));
31863 if (SWIG_arg_fail(2)) SWIG_fail;
31864 }
31865 if (arg1) (arg1)->h = arg2;
31866
31867 Py_INCREF(Py_None); resultobj = Py_None;
31868 return resultobj;
31869 fail:
31870 return NULL;
31871 }
31872
31873
31874 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
31875 PyObject *resultobj = NULL;
31876 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31877 int result;
31878 PyObject * obj0 = 0 ;
31879 char *kwnames[] = {
31880 (char *) "self", NULL
31881 };
31882
31883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
31884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31885 if (SWIG_arg_fail(1)) SWIG_fail;
31886 result = (int) ((arg1)->h);
31887
31888 {
31889 resultobj = SWIG_From_int(static_cast<int >(result));
31890 }
31891 return resultobj;
31892 fail:
31893 return NULL;
31894 }
31895
31896
31897 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
31898 PyObject *resultobj = NULL;
31899 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31900 int arg2 ;
31901 PyObject * obj0 = 0 ;
31902 PyObject * obj1 = 0 ;
31903 char *kwnames[] = {
31904 (char *) "self",(char *) "bpp", NULL
31905 };
31906
31907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
31908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31909 if (SWIG_arg_fail(1)) SWIG_fail;
31910 {
31911 arg2 = static_cast<int >(SWIG_As_int(obj1));
31912 if (SWIG_arg_fail(2)) SWIG_fail;
31913 }
31914 if (arg1) (arg1)->bpp = arg2;
31915
31916 Py_INCREF(Py_None); resultobj = Py_None;
31917 return resultobj;
31918 fail:
31919 return NULL;
31920 }
31921
31922
31923 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
31924 PyObject *resultobj = NULL;
31925 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31926 int result;
31927 PyObject * obj0 = 0 ;
31928 char *kwnames[] = {
31929 (char *) "self", NULL
31930 };
31931
31932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
31933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31934 if (SWIG_arg_fail(1)) SWIG_fail;
31935 result = (int) ((arg1)->bpp);
31936
31937 {
31938 resultobj = SWIG_From_int(static_cast<int >(result));
31939 }
31940 return resultobj;
31941 fail:
31942 return NULL;
31943 }
31944
31945
31946 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
31947 PyObject *resultobj = NULL;
31948 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31949 int arg2 ;
31950 PyObject * obj0 = 0 ;
31951 PyObject * obj1 = 0 ;
31952 char *kwnames[] = {
31953 (char *) "self",(char *) "refresh", NULL
31954 };
31955
31956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
31957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31958 if (SWIG_arg_fail(1)) SWIG_fail;
31959 {
31960 arg2 = static_cast<int >(SWIG_As_int(obj1));
31961 if (SWIG_arg_fail(2)) SWIG_fail;
31962 }
31963 if (arg1) (arg1)->refresh = arg2;
31964
31965 Py_INCREF(Py_None); resultobj = Py_None;
31966 return resultobj;
31967 fail:
31968 return NULL;
31969 }
31970
31971
31972 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
31973 PyObject *resultobj = NULL;
31974 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31975 int result;
31976 PyObject * obj0 = 0 ;
31977 char *kwnames[] = {
31978 (char *) "self", NULL
31979 };
31980
31981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
31982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31983 if (SWIG_arg_fail(1)) SWIG_fail;
31984 result = (int) ((arg1)->refresh);
31985
31986 {
31987 resultobj = SWIG_From_int(static_cast<int >(result));
31988 }
31989 return resultobj;
31990 fail:
31991 return NULL;
31992 }
31993
31994
31995 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
31996 PyObject *obj;
31997 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31998 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
31999 Py_INCREF(obj);
32000 return Py_BuildValue((char *)"");
32001 }
32002 static int _wrap_DefaultVideoMode_set(PyObject *) {
32003 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
32004 return 1;
32005 }
32006
32007
32008 static PyObject *_wrap_DefaultVideoMode_get(void) {
32009 PyObject *pyobj = NULL;
32010
32011 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
32012 return pyobj;
32013 }
32014
32015
32016 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
32017 PyObject *resultobj = NULL;
32018 size_t arg1 = (size_t) 0 ;
32019 wxDisplay *result;
32020 PyObject * obj0 = 0 ;
32021 char *kwnames[] = {
32022 (char *) "index", NULL
32023 };
32024
32025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
32026 if (obj0) {
32027 {
32028 arg1 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj0));
32029 if (SWIG_arg_fail(1)) SWIG_fail;
32030 }
32031 }
32032 {
32033 PyThreadState* __tstate = wxPyBeginAllowThreads();
32034 result = (wxDisplay *)new wxDisplay(arg1);
32035
32036 wxPyEndAllowThreads(__tstate);
32037 if (PyErr_Occurred()) SWIG_fail;
32038 }
32039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
32040 return resultobj;
32041 fail:
32042 return NULL;
32043 }
32044
32045
32046 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
32047 PyObject *resultobj = NULL;
32048 wxDisplay *arg1 = (wxDisplay *) 0 ;
32049 PyObject * obj0 = 0 ;
32050 char *kwnames[] = {
32051 (char *) "self", NULL
32052 };
32053
32054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
32055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32056 if (SWIG_arg_fail(1)) SWIG_fail;
32057 {
32058 PyThreadState* __tstate = wxPyBeginAllowThreads();
32059 delete arg1;
32060
32061 wxPyEndAllowThreads(__tstate);
32062 if (PyErr_Occurred()) SWIG_fail;
32063 }
32064 Py_INCREF(Py_None); resultobj = Py_None;
32065 return resultobj;
32066 fail:
32067 return NULL;
32068 }
32069
32070
32071 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
32072 PyObject *resultobj = NULL;
32073 size_t result;
32074 char *kwnames[] = {
32075 NULL
32076 };
32077
32078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
32079 {
32080 PyThreadState* __tstate = wxPyBeginAllowThreads();
32081 result = (size_t)wxDisplay::GetCount();
32082
32083 wxPyEndAllowThreads(__tstate);
32084 if (PyErr_Occurred()) SWIG_fail;
32085 }
32086 {
32087 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
32088 }
32089 return resultobj;
32090 fail:
32091 return NULL;
32092 }
32093
32094
32095 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
32096 PyObject *resultobj = NULL;
32097 wxPoint *arg1 = 0 ;
32098 int result;
32099 wxPoint temp1 ;
32100 PyObject * obj0 = 0 ;
32101 char *kwnames[] = {
32102 (char *) "pt", NULL
32103 };
32104
32105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
32106 {
32107 arg1 = &temp1;
32108 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
32109 }
32110 {
32111 PyThreadState* __tstate = wxPyBeginAllowThreads();
32112 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
32113
32114 wxPyEndAllowThreads(__tstate);
32115 if (PyErr_Occurred()) SWIG_fail;
32116 }
32117 {
32118 resultobj = SWIG_From_int(static_cast<int >(result));
32119 }
32120 return resultobj;
32121 fail:
32122 return NULL;
32123 }
32124
32125
32126 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32127 PyObject *resultobj = NULL;
32128 wxWindow *arg1 = (wxWindow *) 0 ;
32129 int result;
32130 PyObject * obj0 = 0 ;
32131 char *kwnames[] = {
32132 (char *) "window", NULL
32133 };
32134
32135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
32136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32137 if (SWIG_arg_fail(1)) SWIG_fail;
32138 {
32139 PyThreadState* __tstate = wxPyBeginAllowThreads();
32140 result = (int)wxDisplay::GetFromWindow(arg1);
32141
32142 wxPyEndAllowThreads(__tstate);
32143 if (PyErr_Occurred()) SWIG_fail;
32144 }
32145 {
32146 resultobj = SWIG_From_int(static_cast<int >(result));
32147 }
32148 return resultobj;
32149 fail:
32150 return NULL;
32151 }
32152
32153
32154 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
32155 PyObject *resultobj = NULL;
32156 wxDisplay *arg1 = (wxDisplay *) 0 ;
32157 bool result;
32158 PyObject * obj0 = 0 ;
32159 char *kwnames[] = {
32160 (char *) "self", NULL
32161 };
32162
32163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
32164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32165 if (SWIG_arg_fail(1)) SWIG_fail;
32166 {
32167 PyThreadState* __tstate = wxPyBeginAllowThreads();
32168 result = (bool)((wxDisplay const *)arg1)->IsOk();
32169
32170 wxPyEndAllowThreads(__tstate);
32171 if (PyErr_Occurred()) SWIG_fail;
32172 }
32173 {
32174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32175 }
32176 return resultobj;
32177 fail:
32178 return NULL;
32179 }
32180
32181
32182 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
32183 PyObject *resultobj = NULL;
32184 wxDisplay *arg1 = (wxDisplay *) 0 ;
32185 wxRect result;
32186 PyObject * obj0 = 0 ;
32187 char *kwnames[] = {
32188 (char *) "self", NULL
32189 };
32190
32191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
32192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32193 if (SWIG_arg_fail(1)) SWIG_fail;
32194 {
32195 PyThreadState* __tstate = wxPyBeginAllowThreads();
32196 result = ((wxDisplay const *)arg1)->GetGeometry();
32197
32198 wxPyEndAllowThreads(__tstate);
32199 if (PyErr_Occurred()) SWIG_fail;
32200 }
32201 {
32202 wxRect * resultptr;
32203 resultptr = new wxRect(static_cast<wxRect & >(result));
32204 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
32205 }
32206 return resultobj;
32207 fail:
32208 return NULL;
32209 }
32210
32211
32212 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
32213 PyObject *resultobj = NULL;
32214 wxDisplay *arg1 = (wxDisplay *) 0 ;
32215 wxString result;
32216 PyObject * obj0 = 0 ;
32217 char *kwnames[] = {
32218 (char *) "self", NULL
32219 };
32220
32221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
32222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32223 if (SWIG_arg_fail(1)) SWIG_fail;
32224 {
32225 PyThreadState* __tstate = wxPyBeginAllowThreads();
32226 result = ((wxDisplay const *)arg1)->GetName();
32227
32228 wxPyEndAllowThreads(__tstate);
32229 if (PyErr_Occurred()) SWIG_fail;
32230 }
32231 {
32232 #if wxUSE_UNICODE
32233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32234 #else
32235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32236 #endif
32237 }
32238 return resultobj;
32239 fail:
32240 return NULL;
32241 }
32242
32243
32244 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
32245 PyObject *resultobj = NULL;
32246 wxDisplay *arg1 = (wxDisplay *) 0 ;
32247 bool result;
32248 PyObject * obj0 = 0 ;
32249 char *kwnames[] = {
32250 (char *) "self", NULL
32251 };
32252
32253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
32254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32255 if (SWIG_arg_fail(1)) SWIG_fail;
32256 {
32257 PyThreadState* __tstate = wxPyBeginAllowThreads();
32258 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
32259
32260 wxPyEndAllowThreads(__tstate);
32261 if (PyErr_Occurred()) SWIG_fail;
32262 }
32263 {
32264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32265 }
32266 return resultobj;
32267 fail:
32268 return NULL;
32269 }
32270
32271
32272 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
32273 PyObject *resultobj = NULL;
32274 wxDisplay *arg1 = (wxDisplay *) 0 ;
32275 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
32276 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
32277 PyObject *result;
32278 PyObject * obj0 = 0 ;
32279 PyObject * obj1 = 0 ;
32280 char *kwnames[] = {
32281 (char *) "self",(char *) "mode", NULL
32282 };
32283
32284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
32285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32286 if (SWIG_arg_fail(1)) SWIG_fail;
32287 if (obj1) {
32288 {
32289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
32290 if (SWIG_arg_fail(2)) SWIG_fail;
32291 if (arg2 == NULL) {
32292 SWIG_null_ref("wxVideoMode");
32293 }
32294 if (SWIG_arg_fail(2)) SWIG_fail;
32295 }
32296 }
32297 {
32298 PyThreadState* __tstate = wxPyBeginAllowThreads();
32299 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
32300
32301 wxPyEndAllowThreads(__tstate);
32302 if (PyErr_Occurred()) SWIG_fail;
32303 }
32304 resultobj = result;
32305 return resultobj;
32306 fail:
32307 return NULL;
32308 }
32309
32310
32311 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
32312 PyObject *resultobj = NULL;
32313 wxDisplay *arg1 = (wxDisplay *) 0 ;
32314 wxVideoMode result;
32315 PyObject * obj0 = 0 ;
32316 char *kwnames[] = {
32317 (char *) "self", NULL
32318 };
32319
32320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
32321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32322 if (SWIG_arg_fail(1)) SWIG_fail;
32323 {
32324 PyThreadState* __tstate = wxPyBeginAllowThreads();
32325 result = ((wxDisplay const *)arg1)->GetCurrentMode();
32326
32327 wxPyEndAllowThreads(__tstate);
32328 if (PyErr_Occurred()) SWIG_fail;
32329 }
32330 {
32331 wxVideoMode * resultptr;
32332 resultptr = new wxVideoMode(static_cast<wxVideoMode & >(result));
32333 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
32334 }
32335 return resultobj;
32336 fail:
32337 return NULL;
32338 }
32339
32340
32341 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
32342 PyObject *resultobj = NULL;
32343 wxDisplay *arg1 = (wxDisplay *) 0 ;
32344 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
32345 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
32346 bool result;
32347 PyObject * obj0 = 0 ;
32348 PyObject * obj1 = 0 ;
32349 char *kwnames[] = {
32350 (char *) "self",(char *) "mode", NULL
32351 };
32352
32353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
32354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32355 if (SWIG_arg_fail(1)) SWIG_fail;
32356 if (obj1) {
32357 {
32358 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
32359 if (SWIG_arg_fail(2)) SWIG_fail;
32360 if (arg2 == NULL) {
32361 SWIG_null_ref("wxVideoMode");
32362 }
32363 if (SWIG_arg_fail(2)) SWIG_fail;
32364 }
32365 }
32366 {
32367 PyThreadState* __tstate = wxPyBeginAllowThreads();
32368 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
32369
32370 wxPyEndAllowThreads(__tstate);
32371 if (PyErr_Occurred()) SWIG_fail;
32372 }
32373 {
32374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32375 }
32376 return resultobj;
32377 fail:
32378 return NULL;
32379 }
32380
32381
32382 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
32383 PyObject *resultobj = NULL;
32384 wxDisplay *arg1 = (wxDisplay *) 0 ;
32385 PyObject * obj0 = 0 ;
32386 char *kwnames[] = {
32387 (char *) "self", NULL
32388 };
32389
32390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
32391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32392 if (SWIG_arg_fail(1)) SWIG_fail;
32393 {
32394 PyThreadState* __tstate = wxPyBeginAllowThreads();
32395 (arg1)->ResetMode();
32396
32397 wxPyEndAllowThreads(__tstate);
32398 if (PyErr_Occurred()) SWIG_fail;
32399 }
32400 Py_INCREF(Py_None); resultobj = Py_None;
32401 return resultobj;
32402 fail:
32403 return NULL;
32404 }
32405
32406
32407 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
32408 PyObject *obj;
32409 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32410 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
32411 Py_INCREF(obj);
32412 return Py_BuildValue((char *)"");
32413 }
32414 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
32415 PyObject *resultobj = NULL;
32416 wxStandardPaths *result;
32417 char *kwnames[] = {
32418 NULL
32419 };
32420
32421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
32422 {
32423 PyThreadState* __tstate = wxPyBeginAllowThreads();
32424 result = (wxStandardPaths *)wxStandardPaths_Get();
32425
32426 wxPyEndAllowThreads(__tstate);
32427 if (PyErr_Occurred()) SWIG_fail;
32428 }
32429 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
32430 return resultobj;
32431 fail:
32432 return NULL;
32433 }
32434
32435
32436 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
32437 PyObject *resultobj = NULL;
32438 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32439 wxString result;
32440 PyObject * obj0 = 0 ;
32441 char *kwnames[] = {
32442 (char *) "self", NULL
32443 };
32444
32445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
32446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32447 if (SWIG_arg_fail(1)) SWIG_fail;
32448 {
32449 PyThreadState* __tstate = wxPyBeginAllowThreads();
32450 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
32451
32452 wxPyEndAllowThreads(__tstate);
32453 if (PyErr_Occurred()) SWIG_fail;
32454 }
32455 {
32456 #if wxUSE_UNICODE
32457 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32458 #else
32459 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32460 #endif
32461 }
32462 return resultobj;
32463 fail:
32464 return NULL;
32465 }
32466
32467
32468 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
32469 PyObject *resultobj = NULL;
32470 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32471 wxString result;
32472 PyObject * obj0 = 0 ;
32473 char *kwnames[] = {
32474 (char *) "self", NULL
32475 };
32476
32477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
32478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32479 if (SWIG_arg_fail(1)) SWIG_fail;
32480 {
32481 PyThreadState* __tstate = wxPyBeginAllowThreads();
32482 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
32483
32484 wxPyEndAllowThreads(__tstate);
32485 if (PyErr_Occurred()) SWIG_fail;
32486 }
32487 {
32488 #if wxUSE_UNICODE
32489 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32490 #else
32491 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32492 #endif
32493 }
32494 return resultobj;
32495 fail:
32496 return NULL;
32497 }
32498
32499
32500 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
32501 PyObject *resultobj = NULL;
32502 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32503 wxString result;
32504 PyObject * obj0 = 0 ;
32505 char *kwnames[] = {
32506 (char *) "self", NULL
32507 };
32508
32509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
32510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32511 if (SWIG_arg_fail(1)) SWIG_fail;
32512 {
32513 PyThreadState* __tstate = wxPyBeginAllowThreads();
32514 result = ((wxStandardPaths const *)arg1)->GetDataDir();
32515
32516 wxPyEndAllowThreads(__tstate);
32517 if (PyErr_Occurred()) SWIG_fail;
32518 }
32519 {
32520 #if wxUSE_UNICODE
32521 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32522 #else
32523 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32524 #endif
32525 }
32526 return resultobj;
32527 fail:
32528 return NULL;
32529 }
32530
32531
32532 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
32533 PyObject *resultobj = NULL;
32534 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32535 wxString result;
32536 PyObject * obj0 = 0 ;
32537 char *kwnames[] = {
32538 (char *) "self", NULL
32539 };
32540
32541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
32542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32543 if (SWIG_arg_fail(1)) SWIG_fail;
32544 {
32545 PyThreadState* __tstate = wxPyBeginAllowThreads();
32546 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
32547
32548 wxPyEndAllowThreads(__tstate);
32549 if (PyErr_Occurred()) SWIG_fail;
32550 }
32551 {
32552 #if wxUSE_UNICODE
32553 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32554 #else
32555 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32556 #endif
32557 }
32558 return resultobj;
32559 fail:
32560 return NULL;
32561 }
32562
32563
32564 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
32565 PyObject *resultobj = NULL;
32566 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32567 wxString result;
32568 PyObject * obj0 = 0 ;
32569 char *kwnames[] = {
32570 (char *) "self", NULL
32571 };
32572
32573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
32574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32575 if (SWIG_arg_fail(1)) SWIG_fail;
32576 {
32577 PyThreadState* __tstate = wxPyBeginAllowThreads();
32578 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
32579
32580 wxPyEndAllowThreads(__tstate);
32581 if (PyErr_Occurred()) SWIG_fail;
32582 }
32583 {
32584 #if wxUSE_UNICODE
32585 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32586 #else
32587 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32588 #endif
32589 }
32590 return resultobj;
32591 fail:
32592 return NULL;
32593 }
32594
32595
32596 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
32597 PyObject *resultobj = NULL;
32598 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32599 wxString result;
32600 PyObject * obj0 = 0 ;
32601 char *kwnames[] = {
32602 (char *) "self", NULL
32603 };
32604
32605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
32606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32607 if (SWIG_arg_fail(1)) SWIG_fail;
32608 {
32609 PyThreadState* __tstate = wxPyBeginAllowThreads();
32610 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
32611
32612 wxPyEndAllowThreads(__tstate);
32613 if (PyErr_Occurred()) SWIG_fail;
32614 }
32615 {
32616 #if wxUSE_UNICODE
32617 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32618 #else
32619 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32620 #endif
32621 }
32622 return resultobj;
32623 fail:
32624 return NULL;
32625 }
32626
32627
32628 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
32629 PyObject *resultobj = NULL;
32630 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32631 wxString result;
32632 PyObject * obj0 = 0 ;
32633 char *kwnames[] = {
32634 (char *) "self", NULL
32635 };
32636
32637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
32638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32639 if (SWIG_arg_fail(1)) SWIG_fail;
32640 {
32641 PyThreadState* __tstate = wxPyBeginAllowThreads();
32642 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
32643
32644 wxPyEndAllowThreads(__tstate);
32645 if (PyErr_Occurred()) SWIG_fail;
32646 }
32647 {
32648 #if wxUSE_UNICODE
32649 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32650 #else
32651 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32652 #endif
32653 }
32654 return resultobj;
32655 fail:
32656 return NULL;
32657 }
32658
32659
32660 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
32661 PyObject *resultobj = NULL;
32662 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32663 wxString *arg2 = 0 ;
32664 bool temp2 = false ;
32665 PyObject * obj0 = 0 ;
32666 PyObject * obj1 = 0 ;
32667 char *kwnames[] = {
32668 (char *) "self",(char *) "prefix", NULL
32669 };
32670
32671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
32672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32673 if (SWIG_arg_fail(1)) SWIG_fail;
32674 {
32675 arg2 = wxString_in_helper(obj1);
32676 if (arg2 == NULL) SWIG_fail;
32677 temp2 = true;
32678 }
32679 {
32680 PyThreadState* __tstate = wxPyBeginAllowThreads();
32681 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
32682
32683 wxPyEndAllowThreads(__tstate);
32684 if (PyErr_Occurred()) SWIG_fail;
32685 }
32686 Py_INCREF(Py_None); resultobj = Py_None;
32687 {
32688 if (temp2)
32689 delete arg2;
32690 }
32691 return resultobj;
32692 fail:
32693 {
32694 if (temp2)
32695 delete arg2;
32696 }
32697 return NULL;
32698 }
32699
32700
32701 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
32702 PyObject *resultobj = NULL;
32703 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32704 wxString result;
32705 PyObject * obj0 = 0 ;
32706 char *kwnames[] = {
32707 (char *) "self", NULL
32708 };
32709
32710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
32711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32712 if (SWIG_arg_fail(1)) SWIG_fail;
32713 {
32714 PyThreadState* __tstate = wxPyBeginAllowThreads();
32715 result = wxStandardPaths_GetInstallPrefix(arg1);
32716
32717 wxPyEndAllowThreads(__tstate);
32718 if (PyErr_Occurred()) SWIG_fail;
32719 }
32720 {
32721 #if wxUSE_UNICODE
32722 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32723 #else
32724 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32725 #endif
32726 }
32727 return resultobj;
32728 fail:
32729 return NULL;
32730 }
32731
32732
32733 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
32734 PyObject *obj;
32735 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32736 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
32737 Py_INCREF(obj);
32738 return Py_BuildValue((char *)"");
32739 }
32740 static PyMethodDef SwigMethods[] = {
32741 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
32742 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
32743 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
32744 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
32745 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
32746 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
32747 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
32748 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
32749 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
32750 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
32751 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
32752 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
32753 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
32754 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
32755 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
32756 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
32757 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
32758 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
32759 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
32760 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
32761 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
32762 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
32763 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32764 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
32765 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
32766 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
32767 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
32768 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
32769 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
32770 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
32771 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
32772 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
32773 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
32774 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
32775 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
32776 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
32777 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
32778 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
32779 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
32780 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
32781 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
32782 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
32783 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
32784 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
32785 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
32786 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
32787 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
32788 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
32789 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
32790 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
32791 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
32792 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
32793 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
32794 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
32795 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
32796 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
32797 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32798 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32799 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
32800 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
32801 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
32802 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
32803 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
32804 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
32805 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32806 { (char *)"GetXDisplay", (PyCFunction) _wrap_GetXDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
32807 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32808 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
32809 { (char *)"FindWindowAtPointer", (PyCFunction) _wrap_FindWindowAtPointer, METH_VARARGS | METH_KEYWORDS, NULL},
32810 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32811 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32812 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32813 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
32814 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
32815 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
32816 { (char *)"new_MouseState", (PyCFunction) _wrap_new_MouseState, METH_VARARGS | METH_KEYWORDS, NULL},
32817 { (char *)"delete_MouseState", (PyCFunction) _wrap_delete_MouseState, METH_VARARGS | METH_KEYWORDS, NULL},
32818 { (char *)"MouseState_GetX", (PyCFunction) _wrap_MouseState_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
32819 { (char *)"MouseState_GetY", (PyCFunction) _wrap_MouseState_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
32820 { (char *)"MouseState_LeftDown", (PyCFunction) _wrap_MouseState_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
32821 { (char *)"MouseState_MiddleDown", (PyCFunction) _wrap_MouseState_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
32822 { (char *)"MouseState_RightDown", (PyCFunction) _wrap_MouseState_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
32823 { (char *)"MouseState_ControlDown", (PyCFunction) _wrap_MouseState_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
32824 { (char *)"MouseState_ShiftDown", (PyCFunction) _wrap_MouseState_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
32825 { (char *)"MouseState_AltDown", (PyCFunction) _wrap_MouseState_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
32826 { (char *)"MouseState_MetaDown", (PyCFunction) _wrap_MouseState_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
32827 { (char *)"MouseState_CmdDown", (PyCFunction) _wrap_MouseState_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
32828 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
32829 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
32830 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
32831 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
32832 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
32833 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
32834 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
32835 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
32836 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
32837 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
32838 { (char *)"GetMouseState", (PyCFunction) _wrap_GetMouseState, METH_VARARGS | METH_KEYWORDS, NULL},
32839 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
32840 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32841 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32842 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32843 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32844 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
32845 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
32846 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
32847 { (char *)"delete_ToolTip", (PyCFunction) _wrap_delete_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
32848 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
32849 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
32850 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32851 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
32852 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
32853 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
32854 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
32855 { (char *)"delete_Caret", (PyCFunction) _wrap_delete_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
32856 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
32857 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32858 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
32859 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32860 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
32861 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32862 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
32863 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32864 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
32865 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
32866 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
32867 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32868 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
32869 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
32870 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
32871 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
32872 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
32873 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32874 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32875 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
32876 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
32877 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
32878 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
32879 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32880 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32881 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
32882 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
32883 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
32884 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
32885 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
32886 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
32887 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
32888 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
32889 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
32890 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
32891 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
32892 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
32893 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
32894 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
32895 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
32896 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
32897 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
32898 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
32899 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
32900 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32901 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
32902 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
32903 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
32904 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
32905 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
32906 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
32907 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
32908 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
32909 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32910 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
32911 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
32912 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
32913 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
32914 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32915 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32916 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
32917 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
32918 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32919 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
32920 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
32921 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32922 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
32923 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
32924 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
32925 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
32926 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
32927 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
32928 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
32929 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32930 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
32931 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
32932 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
32933 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
32934 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
32935 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
32936 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
32937 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
32938 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
32939 { (char *)"delete_Log", (PyCFunction) _wrap_delete_Log, METH_VARARGS | METH_KEYWORDS, NULL},
32940 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
32941 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
32942 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
32943 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32944 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
32945 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32946 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32947 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
32948 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
32949 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
32950 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
32951 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
32952 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32953 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32954 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32955 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
32956 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
32957 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
32958 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
32959 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32960 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32961 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
32962 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
32963 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
32964 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
32965 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
32966 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
32967 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
32968 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
32969 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
32970 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
32971 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
32972 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32973 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
32974 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
32975 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
32976 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
32977 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
32978 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
32979 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
32980 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
32981 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
32982 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
32983 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
32984 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
32985 { (char *)"new_LogBuffer", (PyCFunction) _wrap_new_LogBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
32986 { (char *)"LogBuffer_GetBuffer", (PyCFunction) _wrap_LogBuffer_GetBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
32987 { (char *)"LogBuffer_Flush", (PyCFunction) _wrap_LogBuffer_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32988 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
32989 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
32990 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
32991 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
32992 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
32993 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
32994 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
32995 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32996 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
32997 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
32998 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
32999 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
33000 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
33001 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
33002 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
33003 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
33004 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
33005 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
33006 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
33007 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
33008 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33009 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
33010 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
33011 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
33012 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
33013 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
33014 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33015 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
33016 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
33017 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
33018 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
33019 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
33020 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
33021 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
33022 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
33023 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
33024 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
33025 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
33026 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
33027 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
33028 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
33029 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
33030 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
33031 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
33032 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
33033 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
33034 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
33035 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
33036 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
33037 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
33038 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
33039 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33040 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33041 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
33042 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33043 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33044 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33045 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33046 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33047 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
33048 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
33049 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
33050 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
33051 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
33052 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
33053 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
33054 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
33055 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
33056 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
33057 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
33058 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
33059 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
33060 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
33061 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
33062 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
33063 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
33064 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
33065 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
33066 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
33067 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
33068 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
33069 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
33070 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
33071 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
33072 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
33073 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
33074 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
33075 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
33076 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
33077 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
33078 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
33079 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
33080 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
33081 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
33082 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
33083 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33084 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33085 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
33086 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
33087 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
33088 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
33089 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
33090 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
33091 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33092 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33093 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
33094 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
33095 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
33096 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
33097 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
33098 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
33099 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
33100 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
33101 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
33102 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
33103 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
33104 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
33105 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
33106 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
33107 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
33108 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
33109 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
33110 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33111 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
33112 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33113 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
33114 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
33115 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
33116 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
33117 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33118 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33119 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
33120 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
33121 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
33122 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
33123 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
33124 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
33125 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
33126 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
33127 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
33128 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
33129 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
33130 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
33131 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
33132 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33133 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
33134 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33135 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33136 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
33137 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33138 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
33139 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
33140 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33141 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
33142 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
33143 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
33144 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
33145 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
33146 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
33147 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
33148 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
33149 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
33150 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
33151 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
33152 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
33153 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
33154 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
33155 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
33156 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33157 { (char *)"delete_ArtProvider", (PyCFunction) _wrap_delete_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33158 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33159 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33160 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33161 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33162 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
33163 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
33164 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
33165 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
33166 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
33167 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
33168 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
33169 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
33170 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
33171 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
33172 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
33173 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
33174 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33175 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33176 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33177 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33178 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
33179 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
33180 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33181 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33182 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
33183 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
33184 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
33185 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
33186 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
33187 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
33188 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
33189 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
33190 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
33191 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
33192 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
33193 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33194 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33195 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33196 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33197 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
33198 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
33199 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
33200 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
33201 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
33202 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
33203 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
33204 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
33205 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
33206 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
33207 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
33208 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
33209 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
33210 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
33211 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
33212 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
33213 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
33214 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
33215 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
33216 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
33217 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
33218 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
33219 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
33220 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
33221 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
33222 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
33223 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
33224 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
33225 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
33226 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33227 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
33228 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
33229 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
33230 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33231 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
33232 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
33233 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
33234 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
33235 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
33236 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
33237 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
33238 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
33239 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
33240 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
33241 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
33242 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
33243 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
33244 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
33245 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
33246 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
33247 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
33248 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
33249 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
33250 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
33251 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
33252 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
33253 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33254 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
33255 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
33256 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
33257 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
33258 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
33259 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
33260 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
33261 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33262 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33263 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33264 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33265 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33266 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33267 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33268 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
33269 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
33270 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
33271 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
33272 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
33273 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
33274 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
33275 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
33276 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
33277 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
33278 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
33279 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
33280 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
33281 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
33282 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
33283 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
33284 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
33285 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
33286 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
33287 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
33288 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
33289 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
33290 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
33291 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
33292 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
33293 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
33294 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33295 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
33296 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33297 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
33298 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
33299 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
33300 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
33301 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
33302 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
33303 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33304 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
33305 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
33306 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
33307 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
33308 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
33309 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
33310 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
33311 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
33312 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
33313 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
33314 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
33315 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
33316 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
33317 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
33318 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
33319 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
33320 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
33321 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
33322 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
33323 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
33324 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
33325 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
33326 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
33327 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33328 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
33329 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33330 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
33331 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
33332 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
33333 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
33334 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
33335 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
33336 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
33337 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
33338 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
33339 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
33340 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
33341 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
33342 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
33343 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
33344 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
33345 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
33346 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
33347 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
33348 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
33349 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
33350 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
33351 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
33352 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
33353 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
33354 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
33355 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
33356 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
33357 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
33358 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
33359 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
33360 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
33361 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
33362 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
33363 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
33364 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
33365 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
33366 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
33367 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
33368 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
33369 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33370 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
33371 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
33372 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
33373 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
33374 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
33375 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
33376 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
33377 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
33378 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
33379 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
33380 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
33381 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
33382 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
33383 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
33384 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
33385 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
33386 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
33387 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
33388 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
33389 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
33390 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
33391 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
33392 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
33393 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
33394 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
33395 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
33396 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
33397 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
33398 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
33399 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
33400 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
33401 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
33402 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
33403 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
33404 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
33405 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
33406 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
33407 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
33408 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
33409 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
33410 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
33411 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
33412 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
33413 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
33414 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
33415 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
33416 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33417 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
33418 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
33419 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
33420 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
33421 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
33422 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33423 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33424 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33425 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
33426 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
33427 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
33428 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
33429 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
33430 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
33431 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
33432 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33433 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33434 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
33435 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
33436 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
33437 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
33438 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
33439 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33440 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
33441 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
33442 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33443 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33444 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
33445 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
33446 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33447 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
33448 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
33449 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33450 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
33451 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
33452 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
33453 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
33454 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33455 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
33456 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
33457 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
33458 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
33459 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33460 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33461 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
33462 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33463 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
33464 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
33465 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
33466 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33467 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33468 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
33469 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33470 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
33471 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
33472 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
33473 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
33474 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33475 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
33476 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
33477 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
33478 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33479 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
33480 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
33481 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
33482 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33483 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
33484 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
33485 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
33486 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
33487 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
33488 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33489 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
33490 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33491 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33492 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
33493 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
33494 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
33495 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
33496 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33497 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33498 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33499 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33500 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33501 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
33502 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
33503 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
33504 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
33505 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
33506 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
33507 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
33508 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
33509 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33510 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33511 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
33512 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
33513 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
33514 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
33515 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
33516 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
33517 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33518 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33519 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
33520 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
33521 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
33522 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
33523 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
33524 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
33525 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
33526 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
33527 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
33528 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
33529 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
33530 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
33531 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33532 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
33533 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
33534 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
33535 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
33536 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
33537 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
33538 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
33539 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
33540 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
33541 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
33542 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
33543 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
33544 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
33545 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
33546 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
33547 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
33548 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
33549 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
33550 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
33551 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33552 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
33553 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
33554 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
33555 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
33556 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
33557 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
33558 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
33559 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
33560 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
33561 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
33562 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
33563 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
33564 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
33565 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
33566 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
33567 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
33568 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
33569 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
33570 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
33571 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
33572 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
33573 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
33574 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
33575 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
33576 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
33577 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
33578 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
33579 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
33580 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
33581 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
33582 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
33583 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
33584 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
33585 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
33586 { NULL, NULL, 0, NULL }
33587 };
33588
33589
33590 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
33591
33592 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
33593 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
33594 }
33595 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
33596 return (void *)((wxEvent *) ((wxMenuEvent *) x));
33597 }
33598 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
33599 return (void *)((wxEvent *) ((wxCloseEvent *) x));
33600 }
33601 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
33602 return (void *)((wxEvent *) ((wxMouseEvent *) x));
33603 }
33604 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
33605 return (void *)((wxEvent *) ((wxEraseEvent *) x));
33606 }
33607 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
33608 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
33609 }
33610 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
33611 return (void *)((wxEvent *) ((wxTimerEvent *) x));
33612 }
33613 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
33614 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
33615 }
33616 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
33617 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
33618 }
33619 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
33620 return (void *)((wxEvent *) ((wxPyEvent *) x));
33621 }
33622 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
33623 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
33624 }
33625 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
33626 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
33627 }
33628 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
33629 return (void *)((wxEvent *) ((wxIdleEvent *) x));
33630 }
33631 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
33632 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
33633 }
33634 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
33635 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
33636 }
33637 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
33638 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
33639 }
33640 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
33641 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
33642 }
33643 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
33644 return (void *)((wxEvent *) ((wxActivateEvent *) x));
33645 }
33646 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
33647 return (void *)((wxEvent *) ((wxSizeEvent *) x));
33648 }
33649 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
33650 return (void *)((wxEvent *) ((wxMoveEvent *) x));
33651 }
33652 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
33653 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
33654 }
33655 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
33656 return (void *)((wxEvent *) ((wxPaintEvent *) x));
33657 }
33658 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
33659 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
33660 }
33661 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
33662 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
33663 }
33664 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
33665 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
33666 }
33667 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
33668 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
33669 }
33670 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
33671 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
33672 }
33673 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
33674 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
33675 }
33676 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
33677 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
33678 }
33679 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
33680 return (void *)((wxEvent *) ((wxFocusEvent *) x));
33681 }
33682 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
33683 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
33684 }
33685 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
33686 return (void *)((wxEvent *) ((wxProcessEvent *) x));
33687 }
33688 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
33689 return (void *)((wxEvent *) ((wxShowEvent *) x));
33690 }
33691 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
33692 return (void *)((wxEvent *) ((wxCommandEvent *) x));
33693 }
33694 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
33695 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
33696 }
33697 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
33698 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
33699 }
33700 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
33701 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
33702 }
33703 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
33704 return (void *)((wxEvent *) ((wxKeyEvent *) x));
33705 }
33706 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
33707 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
33708 }
33709 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
33710 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
33711 }
33712 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
33713 return (void *)((wxConfigBase *) ((wxConfig *) x));
33714 }
33715 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
33716 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
33717 }
33718 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
33719 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
33720 }
33721 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
33722 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
33723 }
33724 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
33725 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
33726 }
33727 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
33728 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
33729 }
33730 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
33731 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
33732 }
33733 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
33734 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
33735 }
33736 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
33737 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
33738 }
33739 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
33740 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
33741 }
33742 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
33743 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
33744 }
33745 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
33746 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
33747 }
33748 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
33749 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
33750 }
33751 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
33752 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
33753 }
33754 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
33755 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
33756 }
33757 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
33758 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
33759 }
33760 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
33761 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
33762 }
33763 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
33764 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
33765 }
33766 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
33767 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
33768 }
33769 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
33770 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
33771 }
33772 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
33773 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
33774 }
33775 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
33776 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
33777 }
33778 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
33779 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
33780 }
33781 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
33782 return (void *)((wxEvtHandler *) ((wxWindow *) x));
33783 }
33784 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
33785 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
33786 }
33787 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
33788 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
33789 }
33790 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
33791 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
33792 }
33793 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
33794 return (void *)((wxEvtHandler *) ((wxValidator *) x));
33795 }
33796 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
33797 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
33798 }
33799 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
33800 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
33801 }
33802 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
33803 return (void *)((wxEvtHandler *) ((wxMenu *) x));
33804 }
33805 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
33806 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
33807 }
33808 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
33809 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
33810 }
33811 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
33812 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
33813 }
33814 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
33815 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
33816 }
33817 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
33818 return (void *)((wxObject *) ((wxSizerItem *) x));
33819 }
33820 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
33821 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
33822 }
33823 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
33824 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
33825 }
33826 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
33827 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
33828 }
33829 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
33830 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
33831 }
33832 static void *_p_wxSizerTo_p_wxObject(void *x) {
33833 return (void *)((wxObject *) ((wxSizer *) x));
33834 }
33835 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
33836 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
33837 }
33838 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
33839 return (void *)((wxObject *) ((wxFileHistory *) x));
33840 }
33841 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
33842 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
33843 }
33844 static void *_p_wxEventTo_p_wxObject(void *x) {
33845 return (void *)((wxObject *) ((wxEvent *) x));
33846 }
33847 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
33848 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
33849 }
33850 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
33851 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
33852 }
33853 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
33854 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
33855 }
33856 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
33857 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
33858 }
33859 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
33860 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
33861 }
33862 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
33863 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
33864 }
33865 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
33866 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
33867 }
33868 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
33869 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
33870 }
33871 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
33872 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
33873 }
33874 static void *_p_wxControlTo_p_wxObject(void *x) {
33875 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
33876 }
33877 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
33878 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
33879 }
33880 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
33881 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
33882 }
33883 static void *_p_wxFSFileTo_p_wxObject(void *x) {
33884 return (void *)((wxObject *) ((wxFSFile *) x));
33885 }
33886 static void *_p_wxClipboardTo_p_wxObject(void *x) {
33887 return (void *)((wxObject *) ((wxClipboard *) x));
33888 }
33889 static void *_p_wxPySizerTo_p_wxObject(void *x) {
33890 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
33891 }
33892 static void *_p_wxPyEventTo_p_wxObject(void *x) {
33893 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
33894 }
33895 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
33896 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
33897 }
33898 static void *_p_wxShowEventTo_p_wxObject(void *x) {
33899 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
33900 }
33901 static void *_p_wxToolTipTo_p_wxObject(void *x) {
33902 return (void *)((wxObject *) ((wxToolTip *) x));
33903 }
33904 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
33905 return (void *)((wxObject *) ((wxMenuItem *) x));
33906 }
33907 static void *_p_wxDateEventTo_p_wxObject(void *x) {
33908 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
33909 }
33910 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
33911 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
33912 }
33913 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
33914 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
33915 }
33916 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
33917 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
33918 }
33919 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
33920 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
33921 }
33922 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
33923 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
33924 }
33925 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
33926 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
33927 }
33928 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
33929 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
33930 }
33931 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
33932 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
33933 }
33934 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
33935 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
33936 }
33937 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
33938 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
33939 }
33940 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
33941 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
33942 }
33943 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
33944 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
33945 }
33946 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
33947 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
33948 }
33949 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
33950 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
33951 }
33952 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
33953 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
33954 }
33955 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
33956 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
33957 }
33958 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
33959 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
33960 }
33961 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
33962 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
33963 }
33964 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
33965 return (void *)((wxObject *) ((wxImageHandler *) x));
33966 }
33967 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
33968 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
33969 }
33970 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
33971 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
33972 }
33973 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
33974 return (void *)((wxObject *) ((wxEvtHandler *) x));
33975 }
33976 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
33977 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
33978 }
33979 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
33980 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
33981 }
33982 static void *_p_wxImageTo_p_wxObject(void *x) {
33983 return (void *)((wxObject *) ((wxImage *) x));
33984 }
33985 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
33986 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
33987 }
33988 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
33989 return (void *)((wxObject *) ((wxSystemOptions *) x));
33990 }
33991 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
33992 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
33993 }
33994 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
33995 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
33996 }
33997 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
33998 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
33999 }
34000 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
34001 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
34002 }
34003 static void *_p_wxWindowTo_p_wxObject(void *x) {
34004 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
34005 }
34006 static void *_p_wxMenuTo_p_wxObject(void *x) {
34007 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
34008 }
34009 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
34010 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
34011 }
34012 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
34013 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
34014 }
34015 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
34016 return (void *)((wxObject *) ((wxFileSystem *) x));
34017 }
34018 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
34019 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
34020 }
34021 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
34022 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
34023 }
34024 static void *_p_wxPyAppTo_p_wxObject(void *x) {
34025 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
34026 }
34027 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
34028 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
34029 }
34030 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
34031 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
34032 }
34033 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
34034 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
34035 }
34036 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
34037 return (void *)((wxObject *) ((wxBusyInfo *) x));
34038 }
34039 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
34040 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
34041 }
34042 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
34043 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
34044 }
34045 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
34046 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
34047 }
34048 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
34049 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
34050 }
34051 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
34052 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
34053 }
34054 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
34055 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
34056 }
34057 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
34058 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
34059 }
34060 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
34061 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
34062 }
34063 static void *_p_wxValidatorTo_p_wxObject(void *x) {
34064 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
34065 }
34066 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
34067 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
34068 }
34069 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
34070 return (void *)((wxLog *) ((wxLogBuffer *) x));
34071 }
34072 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
34073 return (void *)((wxLog *) ((wxLogStderr *) x));
34074 }
34075 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
34076 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
34077 }
34078 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
34079 return (void *)((wxLog *) ((wxLogWindow *) x));
34080 }
34081 static void *_p_wxLogChainTo_p_wxLog(void *x) {
34082 return (void *)((wxLog *) ((wxLogChain *) x));
34083 }
34084 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
34085 return (void *)((wxLog *) ((wxLogGui *) x));
34086 }
34087 static void *_p_wxPyLogTo_p_wxLog(void *x) {
34088 return (void *)((wxLog *) ((wxPyLog *) x));
34089 }
34090 static void *_p_wxControlTo_p_wxWindow(void *x) {
34091 return (void *)((wxWindow *) ((wxControl *) x));
34092 }
34093 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
34094 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
34095 }
34096 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
34097 return (void *)((wxWindow *) ((wxMenuBar *) x));
34098 }
34099 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
34100 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
34101 }
34102 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
34103 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
34104 }
34105 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
34106 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, 0};
34107 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
34108 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, 0};
34109 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, 0};
34110 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, 0};
34111 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, 0};
34112 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, 0};
34113 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, 0};
34114 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, 0};
34115 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, 0};
34116 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, 0};
34117 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, 0};
34118 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, 0};
34119 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, 0};
34120 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, 0};
34121 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, 0};
34122 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, 0};
34123 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, 0};
34124 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, 0};
34125 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, 0};
34126 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, 0};
34127 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, 0};
34128 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, 0};
34129 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, 0};
34130 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, 0};
34131 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, 0};
34132 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, 0};
34133 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, 0};
34134 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, 0};
34135 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, 0};
34136 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0};
34137 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, 0};
34138 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0};
34139 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0};
34140 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0};
34141 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0};
34142 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0};
34143 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0};
34144 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0};
34145 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0};
34146 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0};
34147 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0};
34148 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0};
34149 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0};
34150 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0};
34151 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0};
34152 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0};
34153 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0};
34154 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0};
34155 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0};
34156 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0};
34157 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0};
34158 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0};
34159 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0};
34160 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0};
34161 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0};
34162 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0};
34163 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0};
34164 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0};
34165 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0};
34166 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0};
34167 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0};
34168 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0};
34169 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0};
34170 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0};
34171 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0};
34172 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0};
34173 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0};
34174 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, 0};
34175 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0};
34176 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0};
34177 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0};
34178 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0};
34179 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0};
34180 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0};
34181 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, 0};
34182 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, 0};
34183 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, 0};
34184 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, 0};
34185 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, 0};
34186 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, 0};
34187 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, 0};
34188 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, 0};
34189 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, 0};
34190 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, 0};
34191 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, 0};
34192 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, 0};
34193 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, 0};
34194 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, 0};
34195 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, 0};
34196 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, 0};
34197 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, 0};
34198 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, 0};
34199 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, 0};
34200 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, 0};
34201 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, 0};
34202 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, 0};
34203 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, 0};
34204 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, 0};
34205 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, 0};
34206 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, 0};
34207 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, 0};
34208 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0};
34209 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0};
34210 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0};
34211 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0};
34212 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0};
34213 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0};
34214 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0};
34215 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0};
34216 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0};
34217 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0};
34218 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0};
34219 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0};
34220 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0};
34221 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0};
34222 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0};
34223 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0};
34224 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0};
34225 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0};
34226 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0};
34227 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0};
34228 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0};
34229 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0};
34230 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0};
34231 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0};
34232 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0};
34233 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0};
34234 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0};
34235 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0};
34236 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0};
34237 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0};
34238 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, 0};
34239 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, 0};
34240 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, 0};
34241 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, 0};
34242 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, 0};
34243 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, 0};
34244 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, 0};
34245 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, 0};
34246 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, 0};
34247 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, 0};
34248 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, 0};
34249 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, 0};
34250 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, 0};
34251 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, 0};
34252 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, 0};
34253 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, 0};
34254 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, 0};
34255 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, 0};
34256 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, 0};
34257 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, 0};
34258 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, 0};
34259 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, 0};
34260 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, 0};
34261 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, 0};
34262 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, 0};
34263 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, 0};
34264 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, 0};
34265 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, 0};
34266 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, 0};
34267 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, 0};
34268 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, 0};
34269 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, 0};
34270 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, 0};
34271 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, 0};
34272 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, 0};
34273 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, 0};
34274 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, 0};
34275 static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
34276 static swig_type_info _swigt__std__ptrdiff_t = {"_std__ptrdiff_t", "std::ptrdiff_t", 0, 0, 0};
34277 static swig_type_info _swigt__unsigned_int = {"_unsigned_int", "unsigned int|std::size_t", 0, 0, 0};
34278
34279 static swig_type_info *swig_type_initial[] = {
34280 &_swigt__p_char,
34281 &_swigt__p_form_ops_t,
34282 &_swigt__p_int,
34283 &_swigt__p_unsigned_char,
34284 &_swigt__p_unsigned_int,
34285 &_swigt__p_unsigned_long,
34286 &_swigt__p_void,
34287 &_swigt__p_wxANIHandler,
34288 &_swigt__p_wxAcceleratorTable,
34289 &_swigt__p_wxActivateEvent,
34290 &_swigt__p_wxArrayString,
34291 &_swigt__p_wxBMPHandler,
34292 &_swigt__p_wxBitmap,
34293 &_swigt__p_wxBitmapDataObject,
34294 &_swigt__p_wxBoxSizer,
34295 &_swigt__p_wxBusyCursor,
34296 &_swigt__p_wxBusyInfo,
34297 &_swigt__p_wxCURHandler,
34298 &_swigt__p_wxCaret,
34299 &_swigt__p_wxChar,
34300 &_swigt__p_wxChildFocusEvent,
34301 &_swigt__p_wxClipboard,
34302 &_swigt__p_wxClipboardLocker,
34303 &_swigt__p_wxCloseEvent,
34304 &_swigt__p_wxColour,
34305 &_swigt__p_wxCommandEvent,
34306 &_swigt__p_wxConfig,
34307 &_swigt__p_wxConfigBase,
34308 &_swigt__p_wxConfigPathChanger,
34309 &_swigt__p_wxContextMenuEvent,
34310 &_swigt__p_wxControl,
34311 &_swigt__p_wxControlWithItems,
34312 &_swigt__p_wxCursor,
34313 &_swigt__p_wxCustomDataObject,
34314 &_swigt__p_wxDC,
34315 &_swigt__p_wxDataFormat,
34316 &_swigt__p_wxDataObject,
34317 &_swigt__p_wxDataObjectComposite,
34318 &_swigt__p_wxDataObjectSimple,
34319 &_swigt__p_wxDateEvent,
34320 &_swigt__p_wxDateSpan,
34321 &_swigt__p_wxDateTime,
34322 &_swigt__p_wxDateTime__TimeZone,
34323 &_swigt__p_wxDisplay,
34324 &_swigt__p_wxDisplayChangedEvent,
34325 &_swigt__p_wxDropFilesEvent,
34326 &_swigt__p_wxDuplexMode,
34327 &_swigt__p_wxEraseEvent,
34328 &_swigt__p_wxEvent,
34329 &_swigt__p_wxEvtHandler,
34330 &_swigt__p_wxFSFile,
34331 &_swigt__p_wxFileConfig,
34332 &_swigt__p_wxFileDataObject,
34333 &_swigt__p_wxFileHistory,
34334 &_swigt__p_wxFileSystem,
34335 &_swigt__p_wxFileType,
34336 &_swigt__p_wxFileTypeInfo,
34337 &_swigt__p_wxFlexGridSizer,
34338 &_swigt__p_wxFocusEvent,
34339 &_swigt__p_wxFont,
34340 &_swigt__p_wxFrame,
34341 &_swigt__p_wxGBSizerItem,
34342 &_swigt__p_wxGIFHandler,
34343 &_swigt__p_wxGridBagSizer,
34344 &_swigt__p_wxGridSizer,
34345 &_swigt__p_wxICOHandler,
34346 &_swigt__p_wxIcon,
34347 &_swigt__p_wxIconizeEvent,
34348 &_swigt__p_wxIdleEvent,
34349 &_swigt__p_wxImage,
34350 &_swigt__p_wxImageHandler,
34351 &_swigt__p_wxIndividualLayoutConstraint,
34352 &_swigt__p_wxInitDialogEvent,
34353 &_swigt__p_wxJPEGHandler,
34354 &_swigt__p_wxJoystick,
34355 &_swigt__p_wxJoystickEvent,
34356 &_swigt__p_wxKeyEvent,
34357 &_swigt__p_wxKillError,
34358 &_swigt__p_wxLayoutConstraints,
34359 &_swigt__p_wxLog,
34360 &_swigt__p_wxLogBuffer,
34361 &_swigt__p_wxLogChain,
34362 &_swigt__p_wxLogGui,
34363 &_swigt__p_wxLogNull,
34364 &_swigt__p_wxLogStderr,
34365 &_swigt__p_wxLogTextCtrl,
34366 &_swigt__p_wxLogWindow,
34367 &_swigt__p_wxMaximizeEvent,
34368 &_swigt__p_wxMemorySize,
34369 &_swigt__p_wxMenu,
34370 &_swigt__p_wxMenuBar,
34371 &_swigt__p_wxMenuEvent,
34372 &_swigt__p_wxMenuItem,
34373 &_swigt__p_wxMetafile,
34374 &_swigt__p_wxMetafileDataObject,
34375 &_swigt__p_wxMimeTypesManager,
34376 &_swigt__p_wxMouseCaptureChangedEvent,
34377 &_swigt__p_wxMouseEvent,
34378 &_swigt__p_wxMouseState,
34379 &_swigt__p_wxMoveEvent,
34380 &_swigt__p_wxMutexGuiLocker,
34381 &_swigt__p_wxNavigationKeyEvent,
34382 &_swigt__p_wxNcPaintEvent,
34383 &_swigt__p_wxNotifyEvent,
34384 &_swigt__p_wxObject,
34385 &_swigt__p_wxOutputStream,
34386 &_swigt__p_wxPCXHandler,
34387 &_swigt__p_wxPNGHandler,
34388 &_swigt__p_wxPNMHandler,
34389 &_swigt__p_wxPaintEvent,
34390 &_swigt__p_wxPaletteChangedEvent,
34391 &_swigt__p_wxPaperSize,
34392 &_swigt__p_wxPoint,
34393 &_swigt__p_wxProcessEvent,
34394 &_swigt__p_wxPyApp,
34395 &_swigt__p_wxPyArtProvider,
34396 &_swigt__p_wxPyBitmapDataObject,
34397 &_swigt__p_wxPyCommandEvent,
34398 &_swigt__p_wxPyDataObjectSimple,
34399 &_swigt__p_wxPyDropSource,
34400 &_swigt__p_wxPyDropTarget,
34401 &_swigt__p_wxPyEvent,
34402 &_swigt__p_wxPyFileDropTarget,
34403 &_swigt__p_wxPyImageHandler,
34404 &_swigt__p_wxPyLog,
34405 &_swigt__p_wxPyProcess,
34406 &_swigt__p_wxPySizer,
34407 &_swigt__p_wxPyTextDataObject,
34408 &_swigt__p_wxPyTextDropTarget,
34409 &_swigt__p_wxPyTimer,
34410 &_swigt__p_wxPyTipProvider,
34411 &_swigt__p_wxPyValidator,
34412 &_swigt__p_wxQueryNewPaletteEvent,
34413 &_swigt__p_wxRect,
34414 &_swigt__p_wxScrollEvent,
34415 &_swigt__p_wxScrollWinEvent,
34416 &_swigt__p_wxSetCursorEvent,
34417 &_swigt__p_wxShowEvent,
34418 &_swigt__p_wxSingleInstanceChecker,
34419 &_swigt__p_wxSize,
34420 &_swigt__p_wxSizeEvent,
34421 &_swigt__p_wxSizer,
34422 &_swigt__p_wxSizerItem,
34423 &_swigt__p_wxSound,
34424 &_swigt__p_wxStandardPaths,
34425 &_swigt__p_wxStaticBoxSizer,
34426 &_swigt__p_wxStdDialogButtonSizer,
34427 &_swigt__p_wxStopWatch,
34428 &_swigt__p_wxString,
34429 &_swigt__p_wxSysColourChangedEvent,
34430 &_swigt__p_wxSystemOptions,
34431 &_swigt__p_wxSystemSettings,
34432 &_swigt__p_wxTIFFHandler,
34433 &_swigt__p_wxTextCtrl,
34434 &_swigt__p_wxTextDataObject,
34435 &_swigt__p_wxTimeSpan,
34436 &_swigt__p_wxTimer,
34437 &_swigt__p_wxTimerEvent,
34438 &_swigt__p_wxTimerRunner,
34439 &_swigt__p_wxTipProvider,
34440 &_swigt__p_wxToolTip,
34441 &_swigt__p_wxURLDataObject,
34442 &_swigt__p_wxUpdateUIEvent,
34443 &_swigt__p_wxValidator,
34444 &_swigt__p_wxVideoMode,
34445 &_swigt__p_wxWindow,
34446 &_swigt__p_wxWindowCreateEvent,
34447 &_swigt__p_wxWindowDestroyEvent,
34448 &_swigt__p_wxWindowDisabler,
34449 &_swigt__p_wxXPMHandler,
34450 &_swigt__ptrdiff_t,
34451 &_swigt__std__ptrdiff_t,
34452 &_swigt__unsigned_int,
34453 };
34454
34455 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
34456 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
34457 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
34458 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
34459 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
34460 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
34461 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
34462 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
34463 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
34464 static swig_cast_info _swigc__p_wxBitmapDataObject[] = { {&_swigt__p_wxBitmapDataObject, 0, 0, 0}, {&_swigt__p_wxPyBitmapDataObject, _p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject, 0, 0},{0, 0, 0, 0}};
34465 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
34466 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
34467 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
34468 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
34469 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
34470 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
34471 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
34472 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
34473 static swig_cast_info _swigc__p_wxConfigBase[] = { {&_swigt__p_wxFileConfig, _p_wxFileConfigTo_p_wxConfigBase, 0, 0}, {&_swigt__p_wxConfigBase, 0, 0, 0}, {&_swigt__p_wxConfig, _p_wxConfigTo_p_wxConfigBase, 0, 0},{0, 0, 0, 0}};
34474 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
34475 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
34476 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
34477 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
34478 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
34479 static swig_cast_info _swigc__p_wxDataObject[] = { {&_swigt__p_wxDataObjectSimple, _p_wxDataObjectSimpleTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxPyDataObjectSimple, _p_wxPyDataObjectSimpleTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxDataObjectComposite, _p_wxDataObjectCompositeTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxDataObject, 0, 0, 0}, {&_swigt__p_wxTextDataObject, _p_wxTextDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxPyTextDataObject, _p_wxPyTextDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxBitmapDataObject, _p_wxBitmapDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxPyBitmapDataObject, _p_wxPyBitmapDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxFileDataObject, _p_wxFileDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxCustomDataObject, _p_wxCustomDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxMetafileDataObject, _p_wxMetafileDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxURLDataObject, _p_wxURLDataObjectTo_p_wxDataObject, 0, 0},{0, 0, 0, 0}};
34480 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
34481 static swig_cast_info _swigc__p_wxDataObjectSimple[] = { {&_swigt__p_wxDataObjectSimple, 0, 0, 0}, {&_swigt__p_wxPyDataObjectSimple, _p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxTextDataObject, _p_wxTextDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxPyTextDataObject, _p_wxPyTextDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxBitmapDataObject, _p_wxBitmapDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxPyBitmapDataObject, _p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxFileDataObject, _p_wxFileDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxCustomDataObject, _p_wxCustomDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxMetafileDataObject, _p_wxMetafileDataObjectTo_p_wxDataObjectSimple, 0, 0},{0, 0, 0, 0}};
34482 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
34483 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
34484 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
34485 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
34486 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
34487 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
34488 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
34489 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
34490 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
34491 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
34492 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
34493 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
34494 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
34495 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
34496 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
34497 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
34498 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
34499 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
34500 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
34501 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
34502 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
34503 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
34504 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
34505 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
34506 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
34507 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
34508 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
34509 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34510 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34511 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34512 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34513 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
34514 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
34515 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
34516 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
34517 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
34518 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
34519 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
34520 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
34521 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
34522 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
34523 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
34524 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
34525 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
34526 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
34527 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
34528 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
34529 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
34530 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
34531 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
34532 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
34533 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
34534 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
34535 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
34536 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
34537 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
34538 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
34539 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
34540 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
34541 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
34542 static swig_cast_info _swigc__p_wxLog[] = { {&_swigt__p_wxLogBuffer, _p_wxLogBufferTo_p_wxLog, 0, 0}, {&_swigt__p_wxLogStderr, _p_wxLogStderrTo_p_wxLog, 0, 0}, {&_swigt__p_wxLogTextCtrl, _p_wxLogTextCtrlTo_p_wxLog, 0, 0}, {&_swigt__p_wxLogWindow, _p_wxLogWindowTo_p_wxLog, 0, 0}, {&_swigt__p_wxLogChain, _p_wxLogChainTo_p_wxLog, 0, 0}, {&_swigt__p_wxLogGui, _p_wxLogGuiTo_p_wxLog, 0, 0}, {&_swigt__p_wxPyLog, _p_wxPyLogTo_p_wxLog, 0, 0}, {&_swigt__p_wxLog, 0, 0, 0},{0, 0, 0, 0}};
34543 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
34544 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
34545 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
34546 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
34547 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
34548 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
34549 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
34550 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
34551 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
34552 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
34553 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
34554 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
34555 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
34556 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
34557 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
34558 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
34559 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
34560 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
34561 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
34562 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
34563 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
34564 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
34565 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
34566 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
34567 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
34568 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
34569 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
34570 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
34571 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
34572 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
34573 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
34574 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
34575 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
34576 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
34577 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
34578 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
34579 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
34580 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
34581 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
34582 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
34583 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
34584 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
34585 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
34586 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
34587 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_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_wxFileHistory, _p_wxFileHistoryTo_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_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_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_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_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_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_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_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_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_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_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_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_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_wxProcessEvent, _p_wxProcessEventTo_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}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
34588 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
34589 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
34590 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
34591 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
34592 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
34593 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
34594 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
34595 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
34596 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0}, {&_swigt__p_wxPyTextDropTarget, _p_wxPyTextDropTargetTo_p_wxPyDropTarget, 0, 0}, {&_swigt__p_wxPyFileDropTarget, _p_wxPyFileDropTargetTo_p_wxPyDropTarget, 0, 0},{0, 0, 0, 0}};
34597 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
34598 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
34599 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
34600 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
34601 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
34602 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
34603 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
34604 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
34605 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
34606 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
34607 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
34608 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
34609 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
34610 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
34611 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
34612 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
34613 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
34614 static swig_cast_info _swigc__p_wxTextDataObject[] = { {&_swigt__p_wxTextDataObject, 0, 0, 0}, {&_swigt__p_wxPyTextDataObject, _p_wxPyTextDataObjectTo_p_wxTextDataObject, 0, 0},{0, 0, 0, 0}};
34615 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
34616 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
34617 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
34618 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
34619 static swig_cast_info _swigc__p_wxTipProvider[] = { {&_swigt__p_wxTipProvider, 0, 0, 0}, {&_swigt__p_wxPyTipProvider, _p_wxPyTipProviderTo_p_wxTipProvider, 0, 0},{0, 0, 0, 0}};
34620 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
34621 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
34622 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
34623 static 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}};
34624 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
34625 static swig_cast_info _swigc__ptrdiff_t[] = { {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
34626 static swig_cast_info _swigc__std__ptrdiff_t[] = { {&_swigt__std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
34627 static swig_cast_info _swigc__unsigned_int[] = { {&_swigt__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
34628
34629 static swig_cast_info *swig_cast_initial[] = {
34630 _swigc__p_char,
34631 _swigc__p_form_ops_t,
34632 _swigc__p_int,
34633 _swigc__p_unsigned_char,
34634 _swigc__p_unsigned_int,
34635 _swigc__p_unsigned_long,
34636 _swigc__p_void,
34637 _swigc__p_wxANIHandler,
34638 _swigc__p_wxAcceleratorTable,
34639 _swigc__p_wxActivateEvent,
34640 _swigc__p_wxArrayString,
34641 _swigc__p_wxBMPHandler,
34642 _swigc__p_wxBitmap,
34643 _swigc__p_wxBitmapDataObject,
34644 _swigc__p_wxBoxSizer,
34645 _swigc__p_wxBusyCursor,
34646 _swigc__p_wxBusyInfo,
34647 _swigc__p_wxCURHandler,
34648 _swigc__p_wxCaret,
34649 _swigc__p_wxChar,
34650 _swigc__p_wxChildFocusEvent,
34651 _swigc__p_wxClipboard,
34652 _swigc__p_wxClipboardLocker,
34653 _swigc__p_wxCloseEvent,
34654 _swigc__p_wxColour,
34655 _swigc__p_wxCommandEvent,
34656 _swigc__p_wxConfig,
34657 _swigc__p_wxConfigBase,
34658 _swigc__p_wxConfigPathChanger,
34659 _swigc__p_wxContextMenuEvent,
34660 _swigc__p_wxControl,
34661 _swigc__p_wxControlWithItems,
34662 _swigc__p_wxCursor,
34663 _swigc__p_wxCustomDataObject,
34664 _swigc__p_wxDC,
34665 _swigc__p_wxDataFormat,
34666 _swigc__p_wxDataObject,
34667 _swigc__p_wxDataObjectComposite,
34668 _swigc__p_wxDataObjectSimple,
34669 _swigc__p_wxDateEvent,
34670 _swigc__p_wxDateSpan,
34671 _swigc__p_wxDateTime,
34672 _swigc__p_wxDateTime__TimeZone,
34673 _swigc__p_wxDisplay,
34674 _swigc__p_wxDisplayChangedEvent,
34675 _swigc__p_wxDropFilesEvent,
34676 _swigc__p_wxDuplexMode,
34677 _swigc__p_wxEraseEvent,
34678 _swigc__p_wxEvent,
34679 _swigc__p_wxEvtHandler,
34680 _swigc__p_wxFSFile,
34681 _swigc__p_wxFileConfig,
34682 _swigc__p_wxFileDataObject,
34683 _swigc__p_wxFileHistory,
34684 _swigc__p_wxFileSystem,
34685 _swigc__p_wxFileType,
34686 _swigc__p_wxFileTypeInfo,
34687 _swigc__p_wxFlexGridSizer,
34688 _swigc__p_wxFocusEvent,
34689 _swigc__p_wxFont,
34690 _swigc__p_wxFrame,
34691 _swigc__p_wxGBSizerItem,
34692 _swigc__p_wxGIFHandler,
34693 _swigc__p_wxGridBagSizer,
34694 _swigc__p_wxGridSizer,
34695 _swigc__p_wxICOHandler,
34696 _swigc__p_wxIcon,
34697 _swigc__p_wxIconizeEvent,
34698 _swigc__p_wxIdleEvent,
34699 _swigc__p_wxImage,
34700 _swigc__p_wxImageHandler,
34701 _swigc__p_wxIndividualLayoutConstraint,
34702 _swigc__p_wxInitDialogEvent,
34703 _swigc__p_wxJPEGHandler,
34704 _swigc__p_wxJoystick,
34705 _swigc__p_wxJoystickEvent,
34706 _swigc__p_wxKeyEvent,
34707 _swigc__p_wxKillError,
34708 _swigc__p_wxLayoutConstraints,
34709 _swigc__p_wxLog,
34710 _swigc__p_wxLogBuffer,
34711 _swigc__p_wxLogChain,
34712 _swigc__p_wxLogGui,
34713 _swigc__p_wxLogNull,
34714 _swigc__p_wxLogStderr,
34715 _swigc__p_wxLogTextCtrl,
34716 _swigc__p_wxLogWindow,
34717 _swigc__p_wxMaximizeEvent,
34718 _swigc__p_wxMemorySize,
34719 _swigc__p_wxMenu,
34720 _swigc__p_wxMenuBar,
34721 _swigc__p_wxMenuEvent,
34722 _swigc__p_wxMenuItem,
34723 _swigc__p_wxMetafile,
34724 _swigc__p_wxMetafileDataObject,
34725 _swigc__p_wxMimeTypesManager,
34726 _swigc__p_wxMouseCaptureChangedEvent,
34727 _swigc__p_wxMouseEvent,
34728 _swigc__p_wxMouseState,
34729 _swigc__p_wxMoveEvent,
34730 _swigc__p_wxMutexGuiLocker,
34731 _swigc__p_wxNavigationKeyEvent,
34732 _swigc__p_wxNcPaintEvent,
34733 _swigc__p_wxNotifyEvent,
34734 _swigc__p_wxObject,
34735 _swigc__p_wxOutputStream,
34736 _swigc__p_wxPCXHandler,
34737 _swigc__p_wxPNGHandler,
34738 _swigc__p_wxPNMHandler,
34739 _swigc__p_wxPaintEvent,
34740 _swigc__p_wxPaletteChangedEvent,
34741 _swigc__p_wxPaperSize,
34742 _swigc__p_wxPoint,
34743 _swigc__p_wxProcessEvent,
34744 _swigc__p_wxPyApp,
34745 _swigc__p_wxPyArtProvider,
34746 _swigc__p_wxPyBitmapDataObject,
34747 _swigc__p_wxPyCommandEvent,
34748 _swigc__p_wxPyDataObjectSimple,
34749 _swigc__p_wxPyDropSource,
34750 _swigc__p_wxPyDropTarget,
34751 _swigc__p_wxPyEvent,
34752 _swigc__p_wxPyFileDropTarget,
34753 _swigc__p_wxPyImageHandler,
34754 _swigc__p_wxPyLog,
34755 _swigc__p_wxPyProcess,
34756 _swigc__p_wxPySizer,
34757 _swigc__p_wxPyTextDataObject,
34758 _swigc__p_wxPyTextDropTarget,
34759 _swigc__p_wxPyTimer,
34760 _swigc__p_wxPyTipProvider,
34761 _swigc__p_wxPyValidator,
34762 _swigc__p_wxQueryNewPaletteEvent,
34763 _swigc__p_wxRect,
34764 _swigc__p_wxScrollEvent,
34765 _swigc__p_wxScrollWinEvent,
34766 _swigc__p_wxSetCursorEvent,
34767 _swigc__p_wxShowEvent,
34768 _swigc__p_wxSingleInstanceChecker,
34769 _swigc__p_wxSize,
34770 _swigc__p_wxSizeEvent,
34771 _swigc__p_wxSizer,
34772 _swigc__p_wxSizerItem,
34773 _swigc__p_wxSound,
34774 _swigc__p_wxStandardPaths,
34775 _swigc__p_wxStaticBoxSizer,
34776 _swigc__p_wxStdDialogButtonSizer,
34777 _swigc__p_wxStopWatch,
34778 _swigc__p_wxString,
34779 _swigc__p_wxSysColourChangedEvent,
34780 _swigc__p_wxSystemOptions,
34781 _swigc__p_wxSystemSettings,
34782 _swigc__p_wxTIFFHandler,
34783 _swigc__p_wxTextCtrl,
34784 _swigc__p_wxTextDataObject,
34785 _swigc__p_wxTimeSpan,
34786 _swigc__p_wxTimer,
34787 _swigc__p_wxTimerEvent,
34788 _swigc__p_wxTimerRunner,
34789 _swigc__p_wxTipProvider,
34790 _swigc__p_wxToolTip,
34791 _swigc__p_wxURLDataObject,
34792 _swigc__p_wxUpdateUIEvent,
34793 _swigc__p_wxValidator,
34794 _swigc__p_wxVideoMode,
34795 _swigc__p_wxWindow,
34796 _swigc__p_wxWindowCreateEvent,
34797 _swigc__p_wxWindowDestroyEvent,
34798 _swigc__p_wxWindowDisabler,
34799 _swigc__p_wxXPMHandler,
34800 _swigc__ptrdiff_t,
34801 _swigc__std__ptrdiff_t,
34802 _swigc__unsigned_int,
34803 };
34804
34805
34806 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
34807
34808 static swig_const_info swig_const_table[] = {
34809 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
34810 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
34811 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
34812 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
34813 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
34814 {0, 0, 0, 0.0, 0, 0}};
34815
34816 #ifdef __cplusplus
34817 }
34818 #endif
34819 /*************************************************************************
34820 * Type initialization:
34821 * This problem is tough by the requirement that no dynamic
34822 * memory is used. Also, since swig_type_info structures store pointers to
34823 * swig_cast_info structures and swig_cast_info structures store pointers back
34824 * to swig_type_info structures, we need some lookup code at initialization.
34825 * The idea is that swig generates all the structures that are needed.
34826 * The runtime then collects these partially filled structures.
34827 * The SWIG_InitializeModule function takes these initial arrays out of
34828 * swig_module, and does all the lookup, filling in the swig_module.types
34829 * array with the correct data and linking the correct swig_cast_info
34830 * structures together.
34831
34832 * The generated swig_type_info structures are assigned staticly to an initial
34833 * array. We just loop though that array, and handle each type individually.
34834 * First we lookup if this type has been already loaded, and if so, use the
34835 * loaded structure instead of the generated one. Then we have to fill in the
34836 * cast linked list. The cast data is initially stored in something like a
34837 * two-dimensional array. Each row corresponds to a type (there are the same
34838 * number of rows as there are in the swig_type_initial array). Each entry in
34839 * a column is one of the swig_cast_info structures for that type.
34840 * The cast_initial array is actually an array of arrays, because each row has
34841 * a variable number of columns. So to actually build the cast linked list,
34842 * we find the array of casts associated with the type, and loop through it
34843 * adding the casts to the list. The one last trick we need to do is making
34844 * sure the type pointer in the swig_cast_info struct is correct.
34845
34846 * First off, we lookup the cast->type name to see if it is already loaded.
34847 * There are three cases to handle:
34848 * 1) If the cast->type has already been loaded AND the type we are adding
34849 * casting info to has not been loaded (it is in this module), THEN we
34850 * replace the cast->type pointer with the type pointer that has already
34851 * been loaded.
34852 * 2) If BOTH types (the one we are adding casting info to, and the
34853 * cast->type) are loaded, THEN the cast info has already been loaded by
34854 * the previous module so we just ignore it.
34855 * 3) Finally, if cast->type has not already been loaded, then we add that
34856 * swig_cast_info to the linked list (because the cast->type) pointer will
34857 * be correct.
34858 **/
34859
34860 #ifdef __cplusplus
34861 extern "C" {
34862 #if 0
34863 } /* c-mode */
34864 #endif
34865 #endif
34866
34867 #if 0
34868 #define SWIGRUNTIME_DEBUG
34869 #endif
34870
34871 SWIGRUNTIME void
34872 SWIG_InitializeModule(void *clientdata) {
34873 size_t i;
34874 swig_module_info *module_head;
34875 static int init_run = 0;
34876
34877 clientdata = clientdata;
34878
34879 if (init_run) return;
34880 init_run = 1;
34881
34882 /* Initialize the swig_module */
34883 swig_module.type_initial = swig_type_initial;
34884 swig_module.cast_initial = swig_cast_initial;
34885
34886 /* Try and load any already created modules */
34887 module_head = SWIG_GetModule(clientdata);
34888 if (module_head) {
34889 swig_module.next = module_head->next;
34890 module_head->next = &swig_module;
34891 } else {
34892 /* This is the first module loaded */
34893 swig_module.next = &swig_module;
34894 SWIG_SetModule(clientdata, &swig_module);
34895 }
34896
34897 /* Now work on filling in swig_module.types */
34898 #ifdef SWIGRUNTIME_DEBUG
34899 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
34900 #endif
34901 for (i = 0; i < swig_module.size; ++i) {
34902 swig_type_info *type = 0;
34903 swig_type_info *ret;
34904 swig_cast_info *cast;
34905
34906 #ifdef SWIGRUNTIME_DEBUG
34907 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
34908 #endif
34909
34910 /* if there is another module already loaded */
34911 if (swig_module.next != &swig_module) {
34912 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
34913 }
34914 if (type) {
34915 /* Overwrite clientdata field */
34916 #ifdef SWIGRUNTIME_DEBUG
34917 printf("SWIG_InitializeModule: found type %s\n", type->name);
34918 #endif
34919 if (swig_module.type_initial[i]->clientdata) {
34920 type->clientdata = swig_module.type_initial[i]->clientdata;
34921 #ifdef SWIGRUNTIME_DEBUG
34922 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
34923 #endif
34924 }
34925 } else {
34926 type = swig_module.type_initial[i];
34927 }
34928
34929 /* Insert casting types */
34930 cast = swig_module.cast_initial[i];
34931 while (cast->type) {
34932 /* Don't need to add information already in the list */
34933 ret = 0;
34934 #ifdef SWIGRUNTIME_DEBUG
34935 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
34936 #endif
34937 if (swig_module.next != &swig_module) {
34938 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
34939 #ifdef SWIGRUNTIME_DEBUG
34940 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
34941 #endif
34942 }
34943 if (ret) {
34944 if (type == swig_module.type_initial[i]) {
34945 #ifdef SWIGRUNTIME_DEBUG
34946 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
34947 #endif
34948 cast->type = ret;
34949 ret = 0;
34950 } else {
34951 /* Check for casting already in the list */
34952 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
34953 #ifdef SWIGRUNTIME_DEBUG
34954 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
34955 #endif
34956 if (!ocast) ret = 0;
34957 }
34958 }
34959
34960 if (!ret) {
34961 #ifdef SWIGRUNTIME_DEBUG
34962 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
34963 #endif
34964 if (type->cast) {
34965 type->cast->prev = cast;
34966 cast->next = type->cast;
34967 }
34968 type->cast = cast;
34969 }
34970 cast++;
34971 }
34972 /* Set entry in modules->types array equal to the type */
34973 swig_module.types[i] = type;
34974 }
34975 swig_module.types[i] = 0;
34976
34977 #ifdef SWIGRUNTIME_DEBUG
34978 printf("**** SWIG_InitializeModule: Cast List ******\n");
34979 for (i = 0; i < swig_module.size; ++i) {
34980 int j = 0;
34981 swig_cast_info *cast = swig_module.cast_initial[i];
34982 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
34983 while (cast->type) {
34984 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
34985 cast++;
34986 ++j;
34987 }
34988 printf("---- Total casts: %d\n",j);
34989 }
34990 printf("**** SWIG_InitializeModule: Cast List ******\n");
34991 #endif
34992 }
34993
34994 /* This function will propagate the clientdata field of type to
34995 * any new swig_type_info structures that have been added into the list
34996 * of equivalent types. It is like calling
34997 * SWIG_TypeClientData(type, clientdata) a second time.
34998 */
34999 SWIGRUNTIME void
35000 SWIG_PropagateClientData(void) {
35001 size_t i;
35002 swig_cast_info *equiv;
35003 static int init_run = 0;
35004
35005 if (init_run) return;
35006 init_run = 1;
35007
35008 for (i = 0; i < swig_module.size; i++) {
35009 if (swig_module.types[i]->clientdata) {
35010 equiv = swig_module.types[i]->cast;
35011 while (equiv) {
35012 if (!equiv->converter) {
35013 if (equiv->type && !equiv->type->clientdata)
35014 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
35015 }
35016 equiv = equiv->next;
35017 }
35018 }
35019 }
35020 }
35021
35022 #ifdef __cplusplus
35023 #if 0
35024 {
35025 /* c-mode */
35026 #endif
35027 }
35028 #endif
35029
35030
35031
35032 #ifdef __cplusplus
35033 extern "C" {
35034 #endif
35035
35036 /* Python-specific SWIG API */
35037 #define SWIG_newvarlink() SWIG_Python_newvarlink()
35038 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
35039 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
35040
35041 /* -----------------------------------------------------------------------------
35042 * global variable support code.
35043 * ----------------------------------------------------------------------------- */
35044
35045 typedef struct swig_globalvar {
35046 char *name; /* Name of global variable */
35047 PyObject *(*get_attr)(void); /* Return the current value */
35048 int (*set_attr)(PyObject *); /* Set the value */
35049 struct swig_globalvar *next;
35050 } swig_globalvar;
35051
35052 typedef struct swig_varlinkobject {
35053 PyObject_HEAD
35054 swig_globalvar *vars;
35055 } swig_varlinkobject;
35056
35057 SWIGINTERN PyObject *
35058 swig_varlink_repr(swig_varlinkobject *v) {
35059 v = v;
35060 return PyString_FromString("<Swig global variables>");
35061 }
35062
35063 SWIGINTERN int
35064 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
35065 swig_globalvar *var;
35066 flags = flags;
35067 fprintf(fp,"Swig global variables { ");
35068 for (var = v->vars; var; var=var->next) {
35069 fprintf(fp,"%s", var->name);
35070 if (var->next) fprintf(fp,", ");
35071 }
35072 fprintf(fp," }\n");
35073 return 0;
35074 }
35075
35076 SWIGINTERN PyObject *
35077 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
35078 swig_globalvar *var = v->vars;
35079 while (var) {
35080 if (strcmp(var->name,n) == 0) {
35081 return (*var->get_attr)();
35082 }
35083 var = var->next;
35084 }
35085 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
35086 return NULL;
35087 }
35088
35089 SWIGINTERN int
35090 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
35091 swig_globalvar *var = v->vars;
35092 while (var) {
35093 if (strcmp(var->name,n) == 0) {
35094 return (*var->set_attr)(p);
35095 }
35096 var = var->next;
35097 }
35098 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
35099 return 1;
35100 }
35101
35102 SWIGINTERN PyTypeObject*
35103 swig_varlink_type(void) {
35104 static char varlink__doc__[] = "Swig var link object";
35105 static PyTypeObject varlink_type
35106 #if !defined(__cplusplus)
35107 ;
35108 static int type_init = 0;
35109 if (!type_init) {
35110 PyTypeObject tmp
35111 #endif
35112 = {
35113 PyObject_HEAD_INIT(&PyType_Type)
35114 0, /* Number of items in variable part (ob_size) */
35115 (char *)"swigvarlink", /* Type name (tp_name) */
35116 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
35117 0, /* Itemsize (tp_itemsize) */
35118 0, /* Deallocator (tp_dealloc) */
35119 (printfunc) swig_varlink_print, /* Print (tp_print) */
35120 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
35121 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
35122 0, /* tp_compare */
35123 (reprfunc) swig_varlink_repr, /* tp_repr */
35124 0, /* tp_as_number */
35125 0, /* tp_as_sequence */
35126 0, /* tp_as_mapping */
35127 0, /* tp_hash */
35128 0, /* tp_call */
35129 0, /* tp_str */
35130 0, /* tp_getattro */
35131 0, /* tp_setattro */
35132 0, /* tp_as_buffer */
35133 0, /* tp_flags */
35134 varlink__doc__, /* tp_doc */
35135 #if PY_VERSION_HEX >= 0x02000000
35136 0, /* tp_traverse */
35137 0, /* tp_clear */
35138 #endif
35139 #if PY_VERSION_HEX >= 0x02010000
35140 0, /* tp_richcompare */
35141 0, /* tp_weaklistoffset */
35142 #endif
35143 #if PY_VERSION_HEX >= 0x02020000
35144 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
35145 #endif
35146 #if PY_VERSION_HEX >= 0x02030000
35147 0, /* tp_del */
35148 #endif
35149 #ifdef COUNT_ALLOCS
35150 0,0,0,0 /* tp_alloc -> tp_next */
35151 #endif
35152 };
35153 #if !defined(__cplusplus)
35154 varlink_type = tmp;
35155 type_init = 1;
35156 }
35157 #endif
35158 return &varlink_type;
35159 }
35160
35161 /* Create a variable linking object for use later */
35162 SWIGINTERN PyObject *
35163 SWIG_Python_newvarlink(void) {
35164 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
35165 if (result) {
35166 result->vars = 0;
35167 }
35168 return ((PyObject*) result);
35169 }
35170
35171 SWIGINTERN void
35172 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
35173 swig_varlinkobject *v = (swig_varlinkobject *) p;
35174 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
35175 if (gv) {
35176 size_t size = strlen(name)+1;
35177 gv->name = (char *)malloc(size);
35178 if (gv->name) {
35179 strncpy(gv->name,name,size);
35180 gv->get_attr = get_attr;
35181 gv->set_attr = set_attr;
35182 gv->next = v->vars;
35183 }
35184 }
35185 v->vars = gv;
35186 }
35187
35188 /* -----------------------------------------------------------------------------
35189 * constants/methods manipulation
35190 * ----------------------------------------------------------------------------- */
35191
35192 /* Install Constants */
35193 SWIGINTERN void
35194 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
35195 PyObject *obj = 0;
35196 size_t i;
35197 for (i = 0; constants[i].type; ++i) {
35198 switch(constants[i].type) {
35199 case SWIG_PY_INT:
35200 obj = PyInt_FromLong(constants[i].lvalue);
35201 break;
35202 case SWIG_PY_FLOAT:
35203 obj = PyFloat_FromDouble(constants[i].dvalue);
35204 break;
35205 case SWIG_PY_STRING:
35206 if (constants[i].pvalue) {
35207 obj = PyString_FromString((char *) constants[i].pvalue);
35208 } else {
35209 Py_INCREF(Py_None);
35210 obj = Py_None;
35211 }
35212 break;
35213 case SWIG_PY_POINTER:
35214 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
35215 break;
35216 case SWIG_PY_BINARY:
35217 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
35218 break;
35219 default:
35220 obj = 0;
35221 break;
35222 }
35223 if (obj) {
35224 PyDict_SetItemString(d,constants[i].name,obj);
35225 Py_DECREF(obj);
35226 }
35227 }
35228 }
35229
35230 /* -----------------------------------------------------------------------------*/
35231 /* Fix SwigMethods to carry the callback ptrs when needed */
35232 /* -----------------------------------------------------------------------------*/
35233
35234 SWIGINTERN void
35235 SWIG_Python_FixMethods(PyMethodDef *methods,
35236 swig_const_info *const_table,
35237 swig_type_info **types,
35238 swig_type_info **types_initial) {
35239 size_t i;
35240 for (i = 0; methods[i].ml_name; ++i) {
35241 char *c = methods[i].ml_doc;
35242 if (c && (c = strstr(c, "swig_ptr: "))) {
35243 int j;
35244 swig_const_info *ci = 0;
35245 char *name = c + 10;
35246 for (j = 0; const_table[j].type; ++j) {
35247 if (strncmp(const_table[j].name, name,
35248 strlen(const_table[j].name)) == 0) {
35249 ci = &(const_table[j]);
35250 break;
35251 }
35252 }
35253 if (ci) {
35254 size_t shift = (ci->ptype) - types;
35255 swig_type_info *ty = types_initial[shift];
35256 size_t ldoc = (c - methods[i].ml_doc);
35257 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
35258 char *ndoc = (char*)malloc(ldoc + lptr + 10);
35259 if (ndoc) {
35260 char *buff = ndoc;
35261 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
35262 if (ptr) {
35263 strncpy(buff, methods[i].ml_doc, ldoc);
35264 buff += ldoc;
35265 strncpy(buff, "swig_ptr: ", 10);
35266 buff += 10;
35267 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
35268 methods[i].ml_doc = ndoc;
35269 }
35270 }
35271 }
35272 }
35273 }
35274 }
35275
35276 /* -----------------------------------------------------------------------------*
35277 * Initialize type list
35278 * -----------------------------------------------------------------------------*/
35279
35280 #ifdef __cplusplus
35281 }
35282 #endif
35283
35284 /* -----------------------------------------------------------------------------*
35285 * Partial Init method
35286 * -----------------------------------------------------------------------------*/
35287
35288 #ifdef __cplusplus
35289 extern "C"
35290 #endif
35291 SWIGEXPORT void SWIG_init(void) {
35292 static PyObject *SWIG_globals = 0;
35293 PyObject *m, *d;
35294 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
35295
35296 /* Fix SwigMethods to carry the callback ptrs when needed */
35297 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
35298
35299 m = Py_InitModule((char *) SWIG_name, SwigMethods);
35300 d = PyModule_GetDict(m);
35301
35302 SWIG_InitializeModule(0);
35303 SWIG_InstallConstants(d,swig_const_table);
35304
35305 {
35306 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int(static_cast<int >(wxSYS_OEM_FIXED_FONT)));
35307 }
35308 {
35309 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int(static_cast<int >(wxSYS_ANSI_FIXED_FONT)));
35310 }
35311 {
35312 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int(static_cast<int >(wxSYS_ANSI_VAR_FONT)));
35313 }
35314 {
35315 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int(static_cast<int >(wxSYS_SYSTEM_FONT)));
35316 }
35317 {
35318 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int(static_cast<int >(wxSYS_DEVICE_DEFAULT_FONT)));
35319 }
35320 {
35321 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int(static_cast<int >(wxSYS_DEFAULT_PALETTE)));
35322 }
35323 {
35324 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int(static_cast<int >(wxSYS_SYSTEM_FIXED_FONT)));
35325 }
35326 {
35327 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int(static_cast<int >(wxSYS_DEFAULT_GUI_FONT)));
35328 }
35329 {
35330 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int(static_cast<int >(wxSYS_ICONTITLE_FONT)));
35331 }
35332 {
35333 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_SCROLLBAR)));
35334 }
35335 {
35336 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BACKGROUND)));
35337 }
35338 {
35339 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_DESKTOP)));
35340 }
35341 {
35342 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_ACTIVECAPTION)));
35343 }
35344 {
35345 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INACTIVECAPTION)));
35346 }
35347 {
35348 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MENU)));
35349 }
35350 {
35351 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_WINDOW)));
35352 }
35353 {
35354 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_WINDOWFRAME)));
35355 }
35356 {
35357 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MENUTEXT)));
35358 }
35359 {
35360 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_WINDOWTEXT)));
35361 }
35362 {
35363 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_CAPTIONTEXT)));
35364 }
35365 {
35366 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_ACTIVEBORDER)));
35367 }
35368 {
35369 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INACTIVEBORDER)));
35370 }
35371 {
35372 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_APPWORKSPACE)));
35373 }
35374 {
35375 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_HIGHLIGHT)));
35376 }
35377 {
35378 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
35379 }
35380 {
35381 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNFACE)));
35382 }
35383 {
35384 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DFACE)));
35385 }
35386 {
35387 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNSHADOW)));
35388 }
35389 {
35390 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DSHADOW)));
35391 }
35392 {
35393 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_GRAYTEXT)));
35394 }
35395 {
35396 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNTEXT)));
35397 }
35398 {
35399 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
35400 }
35401 {
35402 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
35403 }
35404 {
35405 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNHILIGHT)));
35406 }
35407 {
35408 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DHIGHLIGHT)));
35409 }
35410 {
35411 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DHILIGHT)));
35412 }
35413 {
35414 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DDKSHADOW)));
35415 }
35416 {
35417 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DLIGHT)));
35418 }
35419 {
35420 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INFOTEXT)));
35421 }
35422 {
35423 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INFOBK)));
35424 }
35425 {
35426 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_LISTBOX)));
35427 }
35428 {
35429 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_HOTLIGHT)));
35430 }
35431 {
35432 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
35433 }
35434 {
35435 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
35436 }
35437 {
35438 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MENUHILIGHT)));
35439 }
35440 {
35441 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MENUBAR)));
35442 }
35443 {
35444 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MAX)));
35445 }
35446 {
35447 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int(static_cast<int >(wxSYS_MOUSE_BUTTONS)));
35448 }
35449 {
35450 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int(static_cast<int >(wxSYS_BORDER_X)));
35451 }
35452 {
35453 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int(static_cast<int >(wxSYS_BORDER_Y)));
35454 }
35455 {
35456 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int(static_cast<int >(wxSYS_CURSOR_X)));
35457 }
35458 {
35459 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int(static_cast<int >(wxSYS_CURSOR_Y)));
35460 }
35461 {
35462 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int(static_cast<int >(wxSYS_DCLICK_X)));
35463 }
35464 {
35465 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int(static_cast<int >(wxSYS_DCLICK_Y)));
35466 }
35467 {
35468 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int(static_cast<int >(wxSYS_DRAG_X)));
35469 }
35470 {
35471 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int(static_cast<int >(wxSYS_DRAG_Y)));
35472 }
35473 {
35474 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int(static_cast<int >(wxSYS_EDGE_X)));
35475 }
35476 {
35477 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int(static_cast<int >(wxSYS_EDGE_Y)));
35478 }
35479 {
35480 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int(static_cast<int >(wxSYS_HSCROLL_ARROW_X)));
35481 }
35482 {
35483 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int(static_cast<int >(wxSYS_HSCROLL_ARROW_Y)));
35484 }
35485 {
35486 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int(static_cast<int >(wxSYS_HTHUMB_X)));
35487 }
35488 {
35489 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int(static_cast<int >(wxSYS_ICON_X)));
35490 }
35491 {
35492 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int(static_cast<int >(wxSYS_ICON_Y)));
35493 }
35494 {
35495 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int(static_cast<int >(wxSYS_ICONSPACING_X)));
35496 }
35497 {
35498 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int(static_cast<int >(wxSYS_ICONSPACING_Y)));
35499 }
35500 {
35501 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int(static_cast<int >(wxSYS_WINDOWMIN_X)));
35502 }
35503 {
35504 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int(static_cast<int >(wxSYS_WINDOWMIN_Y)));
35505 }
35506 {
35507 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_X)));
35508 }
35509 {
35510 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_Y)));
35511 }
35512 {
35513 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int(static_cast<int >(wxSYS_FRAMESIZE_X)));
35514 }
35515 {
35516 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int(static_cast<int >(wxSYS_FRAMESIZE_Y)));
35517 }
35518 {
35519 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int(static_cast<int >(wxSYS_SMALLICON_X)));
35520 }
35521 {
35522 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int(static_cast<int >(wxSYS_SMALLICON_Y)));
35523 }
35524 {
35525 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int(static_cast<int >(wxSYS_HSCROLL_Y)));
35526 }
35527 {
35528 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int(static_cast<int >(wxSYS_VSCROLL_X)));
35529 }
35530 {
35531 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int(static_cast<int >(wxSYS_VSCROLL_ARROW_X)));
35532 }
35533 {
35534 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int(static_cast<int >(wxSYS_VSCROLL_ARROW_Y)));
35535 }
35536 {
35537 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int(static_cast<int >(wxSYS_VTHUMB_Y)));
35538 }
35539 {
35540 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int(static_cast<int >(wxSYS_CAPTION_Y)));
35541 }
35542 {
35543 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int(static_cast<int >(wxSYS_MENU_Y)));
35544 }
35545 {
35546 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int(static_cast<int >(wxSYS_NETWORK_PRESENT)));
35547 }
35548 {
35549 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int(static_cast<int >(wxSYS_PENWINDOWS_PRESENT)));
35550 }
35551 {
35552 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int(static_cast<int >(wxSYS_SHOW_SOUNDS)));
35553 }
35554 {
35555 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int(static_cast<int >(wxSYS_SWAP_BUTTONS)));
35556 }
35557 {
35558 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int(static_cast<int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
35559 }
35560 {
35561 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int(static_cast<int >(wxSYS_CAN_ICONIZE_FRAME)));
35562 }
35563 {
35564 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_NONE)));
35565 }
35566 {
35567 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_TINY)));
35568 }
35569 {
35570 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_PDA)));
35571 }
35572 {
35573 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_SMALL)));
35574 }
35575 {
35576 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_DESKTOP)));
35577 }
35578 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
35579 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
35580 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
35581 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
35582 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
35583 {
35584 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int(static_cast<int >(wxSHUTDOWN_POWEROFF)));
35585 }
35586 {
35587 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int(static_cast<int >(wxSHUTDOWN_REBOOT)));
35588 }
35589 {
35590 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int(static_cast<int >(wxTIMER_CONTINUOUS)));
35591 }
35592 {
35593 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int(static_cast<int >(wxTIMER_ONE_SHOT)));
35594 }
35595 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
35596
35597 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
35598
35599 {
35600 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int(static_cast<int >(wxLOG_FatalError)));
35601 }
35602 {
35603 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int(static_cast<int >(wxLOG_Error)));
35604 }
35605 {
35606 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int(static_cast<int >(wxLOG_Warning)));
35607 }
35608 {
35609 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int(static_cast<int >(wxLOG_Message)));
35610 }
35611 {
35612 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int(static_cast<int >(wxLOG_Status)));
35613 }
35614 {
35615 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int(static_cast<int >(wxLOG_Info)));
35616 }
35617 {
35618 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int(static_cast<int >(wxLOG_Debug)));
35619 }
35620 {
35621 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int(static_cast<int >(wxLOG_Trace)));
35622 }
35623 {
35624 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int(static_cast<int >(wxLOG_Progress)));
35625 }
35626 {
35627 PyDict_SetItemString(d,"LOG_User", SWIG_From_int(static_cast<int >(wxLOG_User)));
35628 }
35629 {
35630 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int(static_cast<int >(wxLOG_Max)));
35631 }
35632 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
35633 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
35634 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
35635 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
35636 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
35637 {
35638 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int(static_cast<int >(0x0001)));
35639 }
35640 {
35641 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int(static_cast<int >(0x0002)));
35642 }
35643 {
35644 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int(static_cast<int >(0x0004)));
35645 }
35646 {
35647 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int(static_cast<int >(0x0008)));
35648 }
35649 {
35650 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int(static_cast<int >(0x0100)));
35651 }
35652 {
35653 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int(static_cast<int >(wxPROCESS_DEFAULT)));
35654 }
35655 {
35656 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int(static_cast<int >(wxPROCESS_REDIRECT)));
35657 }
35658 {
35659 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int(static_cast<int >(wxKILL_OK)));
35660 }
35661 {
35662 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int(static_cast<int >(wxKILL_BAD_SIGNAL)));
35663 }
35664 {
35665 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int(static_cast<int >(wxKILL_ACCESS_DENIED)));
35666 }
35667 {
35668 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int(static_cast<int >(wxKILL_NO_PROCESS)));
35669 }
35670 {
35671 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int(static_cast<int >(wxKILL_ERROR)));
35672 }
35673 {
35674 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int(static_cast<int >(wxKILL_NOCHILDREN)));
35675 }
35676 {
35677 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int(static_cast<int >(wxKILL_CHILDREN)));
35678 }
35679 {
35680 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int(static_cast<int >(wxSIGNONE)));
35681 }
35682 {
35683 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int(static_cast<int >(wxSIGHUP)));
35684 }
35685 {
35686 PyDict_SetItemString(d,"SIGINT", SWIG_From_int(static_cast<int >(wxSIGINT)));
35687 }
35688 {
35689 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int(static_cast<int >(wxSIGQUIT)));
35690 }
35691 {
35692 PyDict_SetItemString(d,"SIGILL", SWIG_From_int(static_cast<int >(wxSIGILL)));
35693 }
35694 {
35695 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int(static_cast<int >(wxSIGTRAP)));
35696 }
35697 {
35698 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int(static_cast<int >(wxSIGABRT)));
35699 }
35700 {
35701 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int(static_cast<int >(wxSIGIOT)));
35702 }
35703 {
35704 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int(static_cast<int >(wxSIGEMT)));
35705 }
35706 {
35707 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int(static_cast<int >(wxSIGFPE)));
35708 }
35709 {
35710 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int(static_cast<int >(wxSIGKILL)));
35711 }
35712 {
35713 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int(static_cast<int >(wxSIGBUS)));
35714 }
35715 {
35716 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int(static_cast<int >(wxSIGSEGV)));
35717 }
35718 {
35719 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int(static_cast<int >(wxSIGSYS)));
35720 }
35721 {
35722 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int(static_cast<int >(wxSIGPIPE)));
35723 }
35724 {
35725 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int(static_cast<int >(wxSIGALRM)));
35726 }
35727 {
35728 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int(static_cast<int >(wxSIGTERM)));
35729 }
35730 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
35731 {
35732 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int(static_cast<int >(wxEXEC_ASYNC)));
35733 }
35734 {
35735 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int(static_cast<int >(wxEXEC_SYNC)));
35736 }
35737 {
35738 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int(static_cast<int >(wxEXEC_NOHIDE)));
35739 }
35740 {
35741 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int(static_cast<int >(wxEXEC_MAKE_GROUP_LEADER)));
35742 }
35743 {
35744 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int(static_cast<int >(wxEXEC_NODISABLE)));
35745 }
35746
35747 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
35748
35749 {
35750 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int(static_cast<int >(wxJOYSTICK1)));
35751 }
35752 {
35753 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int(static_cast<int >(wxJOYSTICK2)));
35754 }
35755 {
35756 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int(static_cast<int >(wxJOY_BUTTON_ANY)));
35757 }
35758 {
35759 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int(static_cast<int >(wxJOY_BUTTON1)));
35760 }
35761 {
35762 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int(static_cast<int >(wxJOY_BUTTON2)));
35763 }
35764 {
35765 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int(static_cast<int >(wxJOY_BUTTON3)));
35766 }
35767 {
35768 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int(static_cast<int >(wxJOY_BUTTON4)));
35769 }
35770 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
35771 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
35772 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
35773 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
35774 {
35775 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int(static_cast<int >(wxSOUND_SYNC)));
35776 }
35777 {
35778 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int(static_cast<int >(wxSOUND_ASYNC)));
35779 }
35780 {
35781 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int(static_cast<int >(wxSOUND_LOOP)));
35782 }
35783 {
35784 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int(static_cast<int >(wxMAILCAP_STANDARD)));
35785 }
35786 {
35787 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int(static_cast<int >(wxMAILCAP_NETSCAPE)));
35788 }
35789 {
35790 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int(static_cast<int >(wxMAILCAP_KDE)));
35791 }
35792 {
35793 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int(static_cast<int >(wxMAILCAP_GNOME)));
35794 }
35795 {
35796 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int(static_cast<int >(wxMAILCAP_ALL)));
35797 }
35798 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
35799 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
35800 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
35801 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
35802 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
35803 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
35804 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
35805 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
35806 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
35807 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
35808 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
35809 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
35810 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
35811 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
35812 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
35813 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
35814 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
35815 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
35816 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
35817 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
35818 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
35819 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
35820 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
35821 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
35822 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
35823 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
35824 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
35825 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
35826 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
35827 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
35828 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
35829 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
35830 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
35831 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
35832 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
35833 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
35834 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
35835 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
35836 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
35837 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
35838 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
35839 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
35840 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
35841 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
35842 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
35843 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
35844 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
35845 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
35846 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
35847 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
35848 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
35849 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW",_wrap_ART_NEW_get, _wrap_ART_NEW_set);
35850 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
35851 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
35852 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
35853 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
35854 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
35855
35856 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
35857
35858 {
35859 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int(static_cast<int >(wxCONFIG_USE_LOCAL_FILE)));
35860 }
35861 {
35862 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int(static_cast<int >(wxCONFIG_USE_GLOBAL_FILE)));
35863 }
35864 {
35865 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int(static_cast<int >(wxCONFIG_USE_RELATIVE_PATH)));
35866 }
35867 {
35868 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int(static_cast<int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
35869 }
35870 {
35871 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int(static_cast<int >(wxConfigBase::Type_Unknown)));
35872 }
35873 {
35874 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int(static_cast<int >(wxConfigBase::Type_String)));
35875 }
35876 {
35877 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int(static_cast<int >(wxConfigBase::Type_Boolean)));
35878 }
35879 {
35880 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int(static_cast<int >(wxConfigBase::Type_Integer)));
35881 }
35882 {
35883 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int(static_cast<int >(wxConfigBase::Type_Float)));
35884 }
35885 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
35886 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
35887 {
35888 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int(static_cast<int >(wxDateTime::Local)));
35889 }
35890 {
35891 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int(static_cast<int >(wxDateTime::GMT_12)));
35892 }
35893 {
35894 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int(static_cast<int >(wxDateTime::GMT_11)));
35895 }
35896 {
35897 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int(static_cast<int >(wxDateTime::GMT_10)));
35898 }
35899 {
35900 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int(static_cast<int >(wxDateTime::GMT_9)));
35901 }
35902 {
35903 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int(static_cast<int >(wxDateTime::GMT_8)));
35904 }
35905 {
35906 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int(static_cast<int >(wxDateTime::GMT_7)));
35907 }
35908 {
35909 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int(static_cast<int >(wxDateTime::GMT_6)));
35910 }
35911 {
35912 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int(static_cast<int >(wxDateTime::GMT_5)));
35913 }
35914 {
35915 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int(static_cast<int >(wxDateTime::GMT_4)));
35916 }
35917 {
35918 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int(static_cast<int >(wxDateTime::GMT_3)));
35919 }
35920 {
35921 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int(static_cast<int >(wxDateTime::GMT_2)));
35922 }
35923 {
35924 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int(static_cast<int >(wxDateTime::GMT_1)));
35925 }
35926 {
35927 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int(static_cast<int >(wxDateTime::GMT0)));
35928 }
35929 {
35930 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int(static_cast<int >(wxDateTime::GMT1)));
35931 }
35932 {
35933 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int(static_cast<int >(wxDateTime::GMT2)));
35934 }
35935 {
35936 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int(static_cast<int >(wxDateTime::GMT3)));
35937 }
35938 {
35939 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int(static_cast<int >(wxDateTime::GMT4)));
35940 }
35941 {
35942 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int(static_cast<int >(wxDateTime::GMT5)));
35943 }
35944 {
35945 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int(static_cast<int >(wxDateTime::GMT6)));
35946 }
35947 {
35948 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int(static_cast<int >(wxDateTime::GMT7)));
35949 }
35950 {
35951 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int(static_cast<int >(wxDateTime::GMT8)));
35952 }
35953 {
35954 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int(static_cast<int >(wxDateTime::GMT9)));
35955 }
35956 {
35957 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int(static_cast<int >(wxDateTime::GMT10)));
35958 }
35959 {
35960 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int(static_cast<int >(wxDateTime::GMT11)));
35961 }
35962 {
35963 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int(static_cast<int >(wxDateTime::GMT12)));
35964 }
35965 {
35966 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int(static_cast<int >(wxDateTime::WET)));
35967 }
35968 {
35969 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int(static_cast<int >(wxDateTime::WEST)));
35970 }
35971 {
35972 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int(static_cast<int >(wxDateTime::CET)));
35973 }
35974 {
35975 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int(static_cast<int >(wxDateTime::CEST)));
35976 }
35977 {
35978 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int(static_cast<int >(wxDateTime::EET)));
35979 }
35980 {
35981 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int(static_cast<int >(wxDateTime::EEST)));
35982 }
35983 {
35984 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int(static_cast<int >(wxDateTime::MSK)));
35985 }
35986 {
35987 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int(static_cast<int >(wxDateTime::MSD)));
35988 }
35989 {
35990 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int(static_cast<int >(wxDateTime::AST)));
35991 }
35992 {
35993 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int(static_cast<int >(wxDateTime::ADT)));
35994 }
35995 {
35996 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int(static_cast<int >(wxDateTime::EST)));
35997 }
35998 {
35999 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int(static_cast<int >(wxDateTime::EDT)));
36000 }
36001 {
36002 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int(static_cast<int >(wxDateTime::CST)));
36003 }
36004 {
36005 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int(static_cast<int >(wxDateTime::CDT)));
36006 }
36007 {
36008 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int(static_cast<int >(wxDateTime::MST)));
36009 }
36010 {
36011 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int(static_cast<int >(wxDateTime::MDT)));
36012 }
36013 {
36014 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int(static_cast<int >(wxDateTime::PST)));
36015 }
36016 {
36017 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int(static_cast<int >(wxDateTime::PDT)));
36018 }
36019 {
36020 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int(static_cast<int >(wxDateTime::HST)));
36021 }
36022 {
36023 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int(static_cast<int >(wxDateTime::AKST)));
36024 }
36025 {
36026 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int(static_cast<int >(wxDateTime::AKDT)));
36027 }
36028 {
36029 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int(static_cast<int >(wxDateTime::A_WST)));
36030 }
36031 {
36032 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int(static_cast<int >(wxDateTime::A_CST)));
36033 }
36034 {
36035 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int(static_cast<int >(wxDateTime::A_EST)));
36036 }
36037 {
36038 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int(static_cast<int >(wxDateTime::A_ESST)));
36039 }
36040 {
36041 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int(static_cast<int >(wxDateTime::UTC)));
36042 }
36043 {
36044 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int(static_cast<int >(wxDateTime::Gregorian)));
36045 }
36046 {
36047 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int(static_cast<int >(wxDateTime::Julian)));
36048 }
36049 {
36050 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Unknown)));
36051 }
36052 {
36053 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Standard)));
36054 }
36055 {
36056 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Alaska)));
36057 }
36058 {
36059 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Albania)));
36060 }
36061 {
36062 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria)));
36063 }
36064 {
36065 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Brixen)));
36066 }
36067 {
36068 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Salzburg)));
36069 }
36070 {
36071 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Tyrol)));
36072 }
36073 {
36074 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Carinthia)));
36075 }
36076 {
36077 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Styria)));
36078 }
36079 {
36080 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Belgium)));
36081 }
36082 {
36083 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Bulgaria)));
36084 }
36085 {
36086 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Bulgaria_1)));
36087 }
36088 {
36089 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Bulgaria_2)));
36090 }
36091 {
36092 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Bulgaria_3)));
36093 }
36094 {
36095 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Canada)));
36096 }
36097 {
36098 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int(static_cast<int >(wxDateTime::Gr_China)));
36099 }
36100 {
36101 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int(static_cast<int >(wxDateTime::Gr_China_1)));
36102 }
36103 {
36104 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int(static_cast<int >(wxDateTime::Gr_China_2)));
36105 }
36106 {
36107 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Czechoslovakia)));
36108 }
36109 {
36110 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Denmark)));
36111 }
36112 {
36113 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Egypt)));
36114 }
36115 {
36116 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Estonia)));
36117 }
36118 {
36119 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Finland)));
36120 }
36121 {
36122 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int(static_cast<int >(wxDateTime::Gr_France)));
36123 }
36124 {
36125 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int(static_cast<int >(wxDateTime::Gr_France_Alsace)));
36126 }
36127 {
36128 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int(static_cast<int >(wxDateTime::Gr_France_Lorraine)));
36129 }
36130 {
36131 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int(static_cast<int >(wxDateTime::Gr_France_Strasbourg)));
36132 }
36133 {
36134 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Germany)));
36135 }
36136 {
36137 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Germany_Catholic)));
36138 }
36139 {
36140 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Germany_Prussia)));
36141 }
36142 {
36143 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Germany_Protestant)));
36144 }
36145 {
36146 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int(static_cast<int >(wxDateTime::Gr_GreatBritain)));
36147 }
36148 {
36149 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Greece)));
36150 }
36151 {
36152 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Hungary)));
36153 }
36154 {
36155 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Ireland)));
36156 }
36157 {
36158 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Italy)));
36159 }
36160 {
36161 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Japan)));
36162 }
36163 {
36164 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Japan_1)));
36165 }
36166 {
36167 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Japan_2)));
36168 }
36169 {
36170 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Japan_3)));
36171 }
36172 {
36173 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Latvia)));
36174 }
36175 {
36176 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Lithuania)));
36177 }
36178 {
36179 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Luxemburg)));
36180 }
36181 {
36182 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands)));
36183 }
36184 {
36185 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands_Groningen)));
36186 }
36187 {
36188 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands_Gelderland)));
36189 }
36190 {
36191 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands_Utrecht)));
36192 }
36193 {
36194 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands_Friesland)));
36195 }
36196 {
36197 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Norway)));
36198 }
36199 {
36200 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Poland)));
36201 }
36202 {
36203 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Portugal)));
36204 }
36205 {
36206 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Romania)));
36207 }
36208 {
36209 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Russia)));
36210 }
36211 {
36212 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Scotland)));
36213 }
36214 {
36215 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Spain)));
36216 }
36217 {
36218 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Sweden)));
36219 }
36220 {
36221 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Switzerland)));
36222 }
36223 {
36224 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Switzerland_Catholic)));
36225 }
36226 {
36227 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Switzerland_Protestant)));
36228 }
36229 {
36230 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Turkey)));
36231 }
36232 {
36233 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int(static_cast<int >(wxDateTime::Gr_USA)));
36234 }
36235 {
36236 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Wales)));
36237 }
36238 {
36239 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Yugoslavia)));
36240 }
36241 {
36242 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int(static_cast<int >(wxDateTime::Country_Unknown)));
36243 }
36244 {
36245 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int(static_cast<int >(wxDateTime::Country_Default)));
36246 }
36247 {
36248 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int(static_cast<int >(wxDateTime::Country_WesternEurope_Start)));
36249 }
36250 {
36251 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int(static_cast<int >(wxDateTime::Country_EEC)));
36252 }
36253 {
36254 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int(static_cast<int >(wxDateTime::France)));
36255 }
36256 {
36257 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int(static_cast<int >(wxDateTime::Germany)));
36258 }
36259 {
36260 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int(static_cast<int >(wxDateTime::UK)));
36261 }
36262 {
36263 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int(static_cast<int >(wxDateTime::Country_WesternEurope_End)));
36264 }
36265 {
36266 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int(static_cast<int >(wxDateTime::Russia)));
36267 }
36268 {
36269 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int(static_cast<int >(wxDateTime::USA)));
36270 }
36271 {
36272 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int(static_cast<int >(wxDateTime::Jan)));
36273 }
36274 {
36275 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int(static_cast<int >(wxDateTime::Feb)));
36276 }
36277 {
36278 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int(static_cast<int >(wxDateTime::Mar)));
36279 }
36280 {
36281 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int(static_cast<int >(wxDateTime::Apr)));
36282 }
36283 {
36284 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int(static_cast<int >(wxDateTime::May)));
36285 }
36286 {
36287 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int(static_cast<int >(wxDateTime::Jun)));
36288 }
36289 {
36290 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int(static_cast<int >(wxDateTime::Jul)));
36291 }
36292 {
36293 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int(static_cast<int >(wxDateTime::Aug)));
36294 }
36295 {
36296 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int(static_cast<int >(wxDateTime::Sep)));
36297 }
36298 {
36299 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int(static_cast<int >(wxDateTime::Oct)));
36300 }
36301 {
36302 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int(static_cast<int >(wxDateTime::Nov)));
36303 }
36304 {
36305 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int(static_cast<int >(wxDateTime::Dec)));
36306 }
36307 {
36308 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int(static_cast<int >(wxDateTime::Inv_Month)));
36309 }
36310 {
36311 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int(static_cast<int >(wxDateTime::Sun)));
36312 }
36313 {
36314 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int(static_cast<int >(wxDateTime::Mon)));
36315 }
36316 {
36317 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int(static_cast<int >(wxDateTime::Tue)));
36318 }
36319 {
36320 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int(static_cast<int >(wxDateTime::Wed)));
36321 }
36322 {
36323 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int(static_cast<int >(wxDateTime::Thu)));
36324 }
36325 {
36326 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int(static_cast<int >(wxDateTime::Fri)));
36327 }
36328 {
36329 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int(static_cast<int >(wxDateTime::Sat)));
36330 }
36331 {
36332 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int(static_cast<int >(wxDateTime::Inv_WeekDay)));
36333 }
36334 {
36335 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int(static_cast<int >(wxDateTime::Inv_Year)));
36336 }
36337 {
36338 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int(static_cast<int >(wxDateTime::Name_Full)));
36339 }
36340 {
36341 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int(static_cast<int >(wxDateTime::Name_Abbr)));
36342 }
36343 {
36344 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int(static_cast<int >(wxDateTime::Default_First)));
36345 }
36346 {
36347 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int(static_cast<int >(wxDateTime::Monday_First)));
36348 }
36349 {
36350 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int(static_cast<int >(wxDateTime::Sunday_First)));
36351 }
36352 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
36353 {
36354 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int(static_cast<int >(wxDF_INVALID)));
36355 }
36356 {
36357 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int(static_cast<int >(wxDF_TEXT)));
36358 }
36359 {
36360 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int(static_cast<int >(wxDF_BITMAP)));
36361 }
36362 {
36363 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int(static_cast<int >(wxDF_METAFILE)));
36364 }
36365 {
36366 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int(static_cast<int >(wxDF_SYLK)));
36367 }
36368 {
36369 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int(static_cast<int >(wxDF_DIF)));
36370 }
36371 {
36372 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int(static_cast<int >(wxDF_TIFF)));
36373 }
36374 {
36375 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int(static_cast<int >(wxDF_OEMTEXT)));
36376 }
36377 {
36378 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int(static_cast<int >(wxDF_DIB)));
36379 }
36380 {
36381 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int(static_cast<int >(wxDF_PALETTE)));
36382 }
36383 {
36384 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int(static_cast<int >(wxDF_PENDATA)));
36385 }
36386 {
36387 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int(static_cast<int >(wxDF_RIFF)));
36388 }
36389 {
36390 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int(static_cast<int >(wxDF_WAVE)));
36391 }
36392 {
36393 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int(static_cast<int >(wxDF_UNICODETEXT)));
36394 }
36395 {
36396 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int(static_cast<int >(wxDF_ENHMETAFILE)));
36397 }
36398 {
36399 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int(static_cast<int >(wxDF_FILENAME)));
36400 }
36401 {
36402 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int(static_cast<int >(wxDF_LOCALE)));
36403 }
36404 {
36405 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int(static_cast<int >(wxDF_PRIVATE)));
36406 }
36407 {
36408 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int(static_cast<int >(wxDF_HTML)));
36409 }
36410 {
36411 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int(static_cast<int >(wxDF_MAX)));
36412 }
36413 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
36414 {
36415 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int(static_cast<int >(wxDataObject::Get)));
36416 }
36417 {
36418 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int(static_cast<int >(wxDataObject::Set)));
36419 }
36420 {
36421 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int(static_cast<int >(wxDataObject::Both)));
36422 }
36423 {
36424 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int(static_cast<int >(wxDrag_CopyOnly)));
36425 }
36426 {
36427 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int(static_cast<int >(wxDrag_AllowMove)));
36428 }
36429 {
36430 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int(static_cast<int >(wxDrag_DefaultMove)));
36431 }
36432 {
36433 PyDict_SetItemString(d,"DragError", SWIG_From_int(static_cast<int >(wxDragError)));
36434 }
36435 {
36436 PyDict_SetItemString(d,"DragNone", SWIG_From_int(static_cast<int >(wxDragNone)));
36437 }
36438 {
36439 PyDict_SetItemString(d,"DragCopy", SWIG_From_int(static_cast<int >(wxDragCopy)));
36440 }
36441 {
36442 PyDict_SetItemString(d,"DragMove", SWIG_From_int(static_cast<int >(wxDragMove)));
36443 }
36444 {
36445 PyDict_SetItemString(d,"DragLink", SWIG_From_int(static_cast<int >(wxDragLink)));
36446 }
36447 {
36448 PyDict_SetItemString(d,"DragCancel", SWIG_From_int(static_cast<int >(wxDragCancel)));
36449 }
36450
36451 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
36452 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
36453 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
36454 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
36455
36456 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
36457 }
36458
wxWidgets (Impactor)