]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
cleanup - reformatting
[wxWidgets.git] / wxPython / src / mac / _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 /*@/opt/swig/share/swig/1.3.27/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 /*@/opt/swig/share/swig/1.3.27/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
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 /*@/opt/swig/share/swig/1.3.27/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 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2721 #define SWIG_From_unsigned_SS_int SWIG_From_long
2722 /*@@*/
2723 #else
2724 /*@/opt/swig/share/swig/1.3.27/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 int wxDisplay_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
3146 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
3147 PyObject* pyList = NULL;
3148 wxArrayVideoModes arr = self->GetModes(mode);
3149 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3150 pyList = PyList_New(0);
3151 for (int i=0; i < arr.GetCount(); i++) {
3152 wxVideoMode* m = new wxVideoMode(arr.Item(i));
3153 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
3154 PyList_Append(pyList, pyObj);
3155 Py_DECREF(pyObj);
3156 }
3157 wxPyEndBlockThreads(blocked);
3158 return pyList;
3159 }
3160
3161 #include <wx/stdpaths.h>
3162
3163 static wxStandardPaths *wxStandardPaths_Get(){
3164 return (wxStandardPaths*) &wxStandardPaths::Get();
3165 }
3166 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
3167 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
3168 #ifdef __cplusplus
3169 extern "C" {
3170 #endif
3171 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3172 PyObject *resultobj = NULL;
3173 wxSystemColour arg1 ;
3174 wxColour result;
3175 PyObject * obj0 = 0 ;
3176 char *kwnames[] = {
3177 (char *) "index", NULL
3178 };
3179
3180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3181 {
3182 arg1 = static_cast<wxSystemColour >(SWIG_As_int(obj0));
3183 if (SWIG_arg_fail(1)) SWIG_fail;
3184 }
3185 {
3186 if (!wxPyCheckForApp()) SWIG_fail;
3187 PyThreadState* __tstate = wxPyBeginAllowThreads();
3188 result = wxSystemSettings::GetColour(arg1);
3189
3190 wxPyEndAllowThreads(__tstate);
3191 if (PyErr_Occurred()) SWIG_fail;
3192 }
3193 {
3194 wxColour * resultptr;
3195 resultptr = new wxColour(static_cast<wxColour & >(result));
3196 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3197 }
3198 return resultobj;
3199 fail:
3200 return NULL;
3201 }
3202
3203
3204 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3205 PyObject *resultobj = NULL;
3206 wxSystemFont arg1 ;
3207 wxFont result;
3208 PyObject * obj0 = 0 ;
3209 char *kwnames[] = {
3210 (char *) "index", NULL
3211 };
3212
3213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3214 {
3215 arg1 = static_cast<wxSystemFont >(SWIG_As_int(obj0));
3216 if (SWIG_arg_fail(1)) SWIG_fail;
3217 }
3218 {
3219 if (!wxPyCheckForApp()) SWIG_fail;
3220 PyThreadState* __tstate = wxPyBeginAllowThreads();
3221 result = wxSystemSettings::GetFont(arg1);
3222
3223 wxPyEndAllowThreads(__tstate);
3224 if (PyErr_Occurred()) SWIG_fail;
3225 }
3226 {
3227 wxFont * resultptr;
3228 resultptr = new wxFont(static_cast<wxFont & >(result));
3229 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3230 }
3231 return resultobj;
3232 fail:
3233 return NULL;
3234 }
3235
3236
3237 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3238 PyObject *resultobj = NULL;
3239 wxSystemMetric arg1 ;
3240 wxWindow *arg2 = (wxWindow *) NULL ;
3241 int result;
3242 PyObject * obj0 = 0 ;
3243 PyObject * obj1 = 0 ;
3244 char *kwnames[] = {
3245 (char *) "index",(char *) "win", NULL
3246 };
3247
3248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3249 {
3250 arg1 = static_cast<wxSystemMetric >(SWIG_As_int(obj0));
3251 if (SWIG_arg_fail(1)) SWIG_fail;
3252 }
3253 if (obj1) {
3254 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3255 if (SWIG_arg_fail(2)) SWIG_fail;
3256 }
3257 {
3258 if (!wxPyCheckForApp()) SWIG_fail;
3259 PyThreadState* __tstate = wxPyBeginAllowThreads();
3260 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
3261
3262 wxPyEndAllowThreads(__tstate);
3263 if (PyErr_Occurred()) SWIG_fail;
3264 }
3265 {
3266 resultobj = SWIG_From_int(static_cast<int >(result));
3267 }
3268 return resultobj;
3269 fail:
3270 return NULL;
3271 }
3272
3273
3274 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3275 PyObject *resultobj = NULL;
3276 wxSystemFeature arg1 ;
3277 bool result;
3278 PyObject * obj0 = 0 ;
3279 char *kwnames[] = {
3280 (char *) "index", NULL
3281 };
3282
3283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3284 {
3285 arg1 = static_cast<wxSystemFeature >(SWIG_As_int(obj0));
3286 if (SWIG_arg_fail(1)) SWIG_fail;
3287 }
3288 {
3289 if (!wxPyCheckForApp()) SWIG_fail;
3290 PyThreadState* __tstate = wxPyBeginAllowThreads();
3291 result = (bool)wxSystemSettings::HasFeature(arg1);
3292
3293 wxPyEndAllowThreads(__tstate);
3294 if (PyErr_Occurred()) SWIG_fail;
3295 }
3296 {
3297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3298 }
3299 return resultobj;
3300 fail:
3301 return NULL;
3302 }
3303
3304
3305 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3306 PyObject *resultobj = NULL;
3307 wxSystemScreenType result;
3308 char *kwnames[] = {
3309 NULL
3310 };
3311
3312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3313 {
3314 if (!wxPyCheckForApp()) SWIG_fail;
3315 PyThreadState* __tstate = wxPyBeginAllowThreads();
3316 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3317
3318 wxPyEndAllowThreads(__tstate);
3319 if (PyErr_Occurred()) SWIG_fail;
3320 }
3321 resultobj = SWIG_From_int((result));
3322 return resultobj;
3323 fail:
3324 return NULL;
3325 }
3326
3327
3328 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3329 PyObject *resultobj = NULL;
3330 wxSystemScreenType arg1 ;
3331 PyObject * obj0 = 0 ;
3332 char *kwnames[] = {
3333 (char *) "screen", NULL
3334 };
3335
3336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3337 {
3338 arg1 = static_cast<wxSystemScreenType >(SWIG_As_int(obj0));
3339 if (SWIG_arg_fail(1)) SWIG_fail;
3340 }
3341 {
3342 if (!wxPyCheckForApp()) SWIG_fail;
3343 PyThreadState* __tstate = wxPyBeginAllowThreads();
3344 wxSystemSettings::SetScreenType(arg1);
3345
3346 wxPyEndAllowThreads(__tstate);
3347 if (PyErr_Occurred()) SWIG_fail;
3348 }
3349 Py_INCREF(Py_None); resultobj = Py_None;
3350 return resultobj;
3351 fail:
3352 return NULL;
3353 }
3354
3355
3356 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3357 PyObject *obj;
3358 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3359 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3360 Py_INCREF(obj);
3361 return Py_BuildValue((char *)"");
3362 }
3363 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3364 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3365 return 1;
3366 }
3367
3368
3369 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3370 PyObject *pyobj = NULL;
3371
3372 {
3373 #if wxUSE_UNICODE
3374 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3375 #else
3376 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3377 #endif
3378 }
3379 return pyobj;
3380 }
3381
3382
3383 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3384 PyObject *resultobj = NULL;
3385 wxSystemOptions *result;
3386 char *kwnames[] = {
3387 NULL
3388 };
3389
3390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3391 {
3392 PyThreadState* __tstate = wxPyBeginAllowThreads();
3393 result = (wxSystemOptions *)new wxSystemOptions();
3394
3395 wxPyEndAllowThreads(__tstate);
3396 if (PyErr_Occurred()) SWIG_fail;
3397 }
3398 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3399 return resultobj;
3400 fail:
3401 return NULL;
3402 }
3403
3404
3405 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3406 PyObject *resultobj = NULL;
3407 wxString *arg1 = 0 ;
3408 wxString *arg2 = 0 ;
3409 bool temp1 = false ;
3410 bool temp2 = false ;
3411 PyObject * obj0 = 0 ;
3412 PyObject * obj1 = 0 ;
3413 char *kwnames[] = {
3414 (char *) "name",(char *) "value", NULL
3415 };
3416
3417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3418 {
3419 arg1 = wxString_in_helper(obj0);
3420 if (arg1 == NULL) SWIG_fail;
3421 temp1 = true;
3422 }
3423 {
3424 arg2 = wxString_in_helper(obj1);
3425 if (arg2 == NULL) SWIG_fail;
3426 temp2 = true;
3427 }
3428 {
3429 PyThreadState* __tstate = wxPyBeginAllowThreads();
3430 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3431
3432 wxPyEndAllowThreads(__tstate);
3433 if (PyErr_Occurred()) SWIG_fail;
3434 }
3435 Py_INCREF(Py_None); resultobj = Py_None;
3436 {
3437 if (temp1)
3438 delete arg1;
3439 }
3440 {
3441 if (temp2)
3442 delete arg2;
3443 }
3444 return resultobj;
3445 fail:
3446 {
3447 if (temp1)
3448 delete arg1;
3449 }
3450 {
3451 if (temp2)
3452 delete arg2;
3453 }
3454 return NULL;
3455 }
3456
3457
3458 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3459 PyObject *resultobj = NULL;
3460 wxString *arg1 = 0 ;
3461 int arg2 ;
3462 bool temp1 = false ;
3463 PyObject * obj0 = 0 ;
3464 PyObject * obj1 = 0 ;
3465 char *kwnames[] = {
3466 (char *) "name",(char *) "value", NULL
3467 };
3468
3469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3470 {
3471 arg1 = wxString_in_helper(obj0);
3472 if (arg1 == NULL) SWIG_fail;
3473 temp1 = true;
3474 }
3475 {
3476 arg2 = static_cast<int >(SWIG_As_int(obj1));
3477 if (SWIG_arg_fail(2)) SWIG_fail;
3478 }
3479 {
3480 PyThreadState* __tstate = wxPyBeginAllowThreads();
3481 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3482
3483 wxPyEndAllowThreads(__tstate);
3484 if (PyErr_Occurred()) SWIG_fail;
3485 }
3486 Py_INCREF(Py_None); resultobj = Py_None;
3487 {
3488 if (temp1)
3489 delete arg1;
3490 }
3491 return resultobj;
3492 fail:
3493 {
3494 if (temp1)
3495 delete arg1;
3496 }
3497 return NULL;
3498 }
3499
3500
3501 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3502 PyObject *resultobj = NULL;
3503 wxString *arg1 = 0 ;
3504 wxString result;
3505 bool temp1 = false ;
3506 PyObject * obj0 = 0 ;
3507 char *kwnames[] = {
3508 (char *) "name", NULL
3509 };
3510
3511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3512 {
3513 arg1 = wxString_in_helper(obj0);
3514 if (arg1 == NULL) SWIG_fail;
3515 temp1 = true;
3516 }
3517 {
3518 PyThreadState* __tstate = wxPyBeginAllowThreads();
3519 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3520
3521 wxPyEndAllowThreads(__tstate);
3522 if (PyErr_Occurred()) SWIG_fail;
3523 }
3524 {
3525 #if wxUSE_UNICODE
3526 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3527 #else
3528 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3529 #endif
3530 }
3531 {
3532 if (temp1)
3533 delete arg1;
3534 }
3535 return resultobj;
3536 fail:
3537 {
3538 if (temp1)
3539 delete arg1;
3540 }
3541 return NULL;
3542 }
3543
3544
3545 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3546 PyObject *resultobj = NULL;
3547 wxString *arg1 = 0 ;
3548 int result;
3549 bool temp1 = false ;
3550 PyObject * obj0 = 0 ;
3551 char *kwnames[] = {
3552 (char *) "name", NULL
3553 };
3554
3555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3556 {
3557 arg1 = wxString_in_helper(obj0);
3558 if (arg1 == NULL) SWIG_fail;
3559 temp1 = true;
3560 }
3561 {
3562 PyThreadState* __tstate = wxPyBeginAllowThreads();
3563 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3564
3565 wxPyEndAllowThreads(__tstate);
3566 if (PyErr_Occurred()) SWIG_fail;
3567 }
3568 {
3569 resultobj = SWIG_From_int(static_cast<int >(result));
3570 }
3571 {
3572 if (temp1)
3573 delete arg1;
3574 }
3575 return resultobj;
3576 fail:
3577 {
3578 if (temp1)
3579 delete arg1;
3580 }
3581 return NULL;
3582 }
3583
3584
3585 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3586 PyObject *resultobj = NULL;
3587 wxString *arg1 = 0 ;
3588 bool result;
3589 bool temp1 = false ;
3590 PyObject * obj0 = 0 ;
3591 char *kwnames[] = {
3592 (char *) "name", NULL
3593 };
3594
3595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3596 {
3597 arg1 = wxString_in_helper(obj0);
3598 if (arg1 == NULL) SWIG_fail;
3599 temp1 = true;
3600 }
3601 {
3602 PyThreadState* __tstate = wxPyBeginAllowThreads();
3603 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3604
3605 wxPyEndAllowThreads(__tstate);
3606 if (PyErr_Occurred()) SWIG_fail;
3607 }
3608 {
3609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3610 }
3611 {
3612 if (temp1)
3613 delete arg1;
3614 }
3615 return resultobj;
3616 fail:
3617 {
3618 if (temp1)
3619 delete arg1;
3620 }
3621 return NULL;
3622 }
3623
3624
3625 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3626 PyObject *resultobj = NULL;
3627 wxString *arg1 = 0 ;
3628 bool result;
3629 bool temp1 = false ;
3630 PyObject * obj0 = 0 ;
3631 char *kwnames[] = {
3632 (char *) "name", NULL
3633 };
3634
3635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3636 {
3637 arg1 = wxString_in_helper(obj0);
3638 if (arg1 == NULL) SWIG_fail;
3639 temp1 = true;
3640 }
3641 {
3642 PyThreadState* __tstate = wxPyBeginAllowThreads();
3643 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3644
3645 wxPyEndAllowThreads(__tstate);
3646 if (PyErr_Occurred()) SWIG_fail;
3647 }
3648 {
3649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3650 }
3651 {
3652 if (temp1)
3653 delete arg1;
3654 }
3655 return resultobj;
3656 fail:
3657 {
3658 if (temp1)
3659 delete arg1;
3660 }
3661 return NULL;
3662 }
3663
3664
3665 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3666 PyObject *obj;
3667 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3668 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3669 Py_INCREF(obj);
3670 return Py_BuildValue((char *)"");
3671 }
3672 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3673 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3674 return 1;
3675 }
3676
3677
3678 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3679 PyObject *pyobj = NULL;
3680
3681 {
3682 #if wxUSE_UNICODE
3683 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3684 #else
3685 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3686 #endif
3687 }
3688 return pyobj;
3689 }
3690
3691
3692 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3693 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3694 return 1;
3695 }
3696
3697
3698 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3699 PyObject *pyobj = NULL;
3700
3701 {
3702 #if wxUSE_UNICODE
3703 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3704 #else
3705 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3706 #endif
3707 }
3708 return pyobj;
3709 }
3710
3711
3712 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3713 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3714 return 1;
3715 }
3716
3717
3718 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3719 PyObject *pyobj = NULL;
3720
3721 {
3722 #if wxUSE_UNICODE
3723 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3724 #else
3725 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3726 #endif
3727 }
3728 return pyobj;
3729 }
3730
3731
3732 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3733 PyObject *resultobj = NULL;
3734 long result;
3735 char *kwnames[] = {
3736 NULL
3737 };
3738
3739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3740 {
3741 PyThreadState* __tstate = wxPyBeginAllowThreads();
3742 result = (long)wxNewId();
3743
3744 wxPyEndAllowThreads(__tstate);
3745 if (PyErr_Occurred()) SWIG_fail;
3746 }
3747 {
3748 resultobj = SWIG_From_long(static_cast<long >(result));
3749 }
3750 return resultobj;
3751 fail:
3752 return NULL;
3753 }
3754
3755
3756 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3757 PyObject *resultobj = NULL;
3758 long arg1 ;
3759 PyObject * obj0 = 0 ;
3760 char *kwnames[] = {
3761 (char *) "id", NULL
3762 };
3763
3764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3765 {
3766 arg1 = static_cast<long >(SWIG_As_long(obj0));
3767 if (SWIG_arg_fail(1)) SWIG_fail;
3768 }
3769 {
3770 PyThreadState* __tstate = wxPyBeginAllowThreads();
3771 wxRegisterId(arg1);
3772
3773 wxPyEndAllowThreads(__tstate);
3774 if (PyErr_Occurred()) SWIG_fail;
3775 }
3776 Py_INCREF(Py_None); resultobj = Py_None;
3777 return resultobj;
3778 fail:
3779 return NULL;
3780 }
3781
3782
3783 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3784 PyObject *resultobj = NULL;
3785 long result;
3786 char *kwnames[] = {
3787 NULL
3788 };
3789
3790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3791 {
3792 PyThreadState* __tstate = wxPyBeginAllowThreads();
3793 result = (long)wxGetCurrentId();
3794
3795 wxPyEndAllowThreads(__tstate);
3796 if (PyErr_Occurred()) SWIG_fail;
3797 }
3798 {
3799 resultobj = SWIG_From_long(static_cast<long >(result));
3800 }
3801 return resultobj;
3802 fail:
3803 return NULL;
3804 }
3805
3806
3807 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3808 PyObject *resultobj = NULL;
3809 int arg1 ;
3810 bool result;
3811 PyObject * obj0 = 0 ;
3812 char *kwnames[] = {
3813 (char *) "id", NULL
3814 };
3815
3816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3817 {
3818 arg1 = static_cast<int >(SWIG_As_int(obj0));
3819 if (SWIG_arg_fail(1)) SWIG_fail;
3820 }
3821 {
3822 PyThreadState* __tstate = wxPyBeginAllowThreads();
3823 result = (bool)wxIsStockID(arg1);
3824
3825 wxPyEndAllowThreads(__tstate);
3826 if (PyErr_Occurred()) SWIG_fail;
3827 }
3828 {
3829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3830 }
3831 return resultobj;
3832 fail:
3833 return NULL;
3834 }
3835
3836
3837 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3838 PyObject *resultobj = NULL;
3839 int arg1 ;
3840 wxString *arg2 = 0 ;
3841 bool result;
3842 bool temp2 = false ;
3843 PyObject * obj0 = 0 ;
3844 PyObject * obj1 = 0 ;
3845 char *kwnames[] = {
3846 (char *) "id",(char *) "label", NULL
3847 };
3848
3849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3850 {
3851 arg1 = static_cast<int >(SWIG_As_int(obj0));
3852 if (SWIG_arg_fail(1)) SWIG_fail;
3853 }
3854 {
3855 arg2 = wxString_in_helper(obj1);
3856 if (arg2 == NULL) SWIG_fail;
3857 temp2 = true;
3858 }
3859 {
3860 PyThreadState* __tstate = wxPyBeginAllowThreads();
3861 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3862
3863 wxPyEndAllowThreads(__tstate);
3864 if (PyErr_Occurred()) SWIG_fail;
3865 }
3866 {
3867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3868 }
3869 {
3870 if (temp2)
3871 delete arg2;
3872 }
3873 return resultobj;
3874 fail:
3875 {
3876 if (temp2)
3877 delete arg2;
3878 }
3879 return NULL;
3880 }
3881
3882
3883 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3884 PyObject *resultobj = NULL;
3885 int arg1 ;
3886 bool arg2 = (bool) true ;
3887 wxString arg3 = (wxString) wxPyEmptyString ;
3888 wxString result;
3889 PyObject * obj0 = 0 ;
3890 PyObject * obj1 = 0 ;
3891 PyObject * obj2 = 0 ;
3892 char *kwnames[] = {
3893 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3894 };
3895
3896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3897 {
3898 arg1 = static_cast<int >(SWIG_As_int(obj0));
3899 if (SWIG_arg_fail(1)) SWIG_fail;
3900 }
3901 if (obj1) {
3902 {
3903 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
3904 if (SWIG_arg_fail(2)) SWIG_fail;
3905 }
3906 }
3907 if (obj2) {
3908 {
3909 wxString* sptr = wxString_in_helper(obj2);
3910 if (sptr == NULL) SWIG_fail;
3911 arg3 = *sptr;
3912 delete sptr;
3913 }
3914 }
3915 {
3916 PyThreadState* __tstate = wxPyBeginAllowThreads();
3917 result = wxGetStockLabel(arg1,arg2,arg3);
3918
3919 wxPyEndAllowThreads(__tstate);
3920 if (PyErr_Occurred()) SWIG_fail;
3921 }
3922 {
3923 #if wxUSE_UNICODE
3924 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3925 #else
3926 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3927 #endif
3928 }
3929 return resultobj;
3930 fail:
3931 return NULL;
3932 }
3933
3934
3935 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3936 PyObject *resultobj = NULL;
3937 char *kwnames[] = {
3938 NULL
3939 };
3940
3941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3942 {
3943 if (!wxPyCheckForApp()) SWIG_fail;
3944 PyThreadState* __tstate = wxPyBeginAllowThreads();
3945 wxBell();
3946
3947 wxPyEndAllowThreads(__tstate);
3948 if (PyErr_Occurred()) SWIG_fail;
3949 }
3950 Py_INCREF(Py_None); resultobj = Py_None;
3951 return resultobj;
3952 fail:
3953 return NULL;
3954 }
3955
3956
3957 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3958 PyObject *resultobj = NULL;
3959 char *kwnames[] = {
3960 NULL
3961 };
3962
3963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3964 {
3965 if (!wxPyCheckForApp()) SWIG_fail;
3966 PyThreadState* __tstate = wxPyBeginAllowThreads();
3967 wxEndBusyCursor();
3968
3969 wxPyEndAllowThreads(__tstate);
3970 if (PyErr_Occurred()) SWIG_fail;
3971 }
3972 Py_INCREF(Py_None); resultobj = Py_None;
3973 return resultobj;
3974 fail:
3975 return NULL;
3976 }
3977
3978
3979 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3980 PyObject *resultobj = NULL;
3981 bool arg1 = (bool) true ;
3982 long result;
3983 PyObject * obj0 = 0 ;
3984 char *kwnames[] = {
3985 (char *) "resetTimer", NULL
3986 };
3987
3988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3989 if (obj0) {
3990 {
3991 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
3992 if (SWIG_arg_fail(1)) SWIG_fail;
3993 }
3994 }
3995 {
3996 PyThreadState* __tstate = wxPyBeginAllowThreads();
3997 result = (long)wxGetElapsedTime(arg1);
3998
3999 wxPyEndAllowThreads(__tstate);
4000 if (PyErr_Occurred()) SWIG_fail;
4001 }
4002 {
4003 resultobj = SWIG_From_long(static_cast<long >(result));
4004 }
4005 return resultobj;
4006 fail:
4007 return NULL;
4008 }
4009
4010
4011 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
4012 PyObject *resultobj = NULL;
4013 bool result;
4014 char *kwnames[] = {
4015 NULL
4016 };
4017
4018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
4019 {
4020 PyThreadState* __tstate = wxPyBeginAllowThreads();
4021 result = (bool)wxIsBusy();
4022
4023 wxPyEndAllowThreads(__tstate);
4024 if (PyErr_Occurred()) SWIG_fail;
4025 }
4026 {
4027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4028 }
4029 return resultobj;
4030 fail:
4031 return NULL;
4032 }
4033
4034
4035 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
4036 PyObject *resultobj = NULL;
4037 wxString result;
4038 char *kwnames[] = {
4039 NULL
4040 };
4041
4042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
4043 {
4044 PyThreadState* __tstate = wxPyBeginAllowThreads();
4045 result = wxNow();
4046
4047 wxPyEndAllowThreads(__tstate);
4048 if (PyErr_Occurred()) SWIG_fail;
4049 }
4050 {
4051 #if wxUSE_UNICODE
4052 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4053 #else
4054 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4055 #endif
4056 }
4057 return resultobj;
4058 fail:
4059 return NULL;
4060 }
4061
4062
4063 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
4064 PyObject *resultobj = NULL;
4065 wxString const &arg1_defvalue = wxPyEmptyString ;
4066 wxString *arg1 = (wxString *) &arg1_defvalue ;
4067 bool result;
4068 bool temp1 = false ;
4069 PyObject * obj0 = 0 ;
4070 char *kwnames[] = {
4071 (char *) "command", NULL
4072 };
4073
4074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
4075 if (obj0) {
4076 {
4077 arg1 = wxString_in_helper(obj0);
4078 if (arg1 == NULL) SWIG_fail;
4079 temp1 = true;
4080 }
4081 }
4082 {
4083 PyThreadState* __tstate = wxPyBeginAllowThreads();
4084 result = (bool)wxShell((wxString const &)*arg1);
4085
4086 wxPyEndAllowThreads(__tstate);
4087 if (PyErr_Occurred()) SWIG_fail;
4088 }
4089 {
4090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4091 }
4092 {
4093 if (temp1)
4094 delete arg1;
4095 }
4096 return resultobj;
4097 fail:
4098 {
4099 if (temp1)
4100 delete arg1;
4101 }
4102 return NULL;
4103 }
4104
4105
4106 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
4107 PyObject *resultobj = NULL;
4108 char *kwnames[] = {
4109 NULL
4110 };
4111
4112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
4113 {
4114 PyThreadState* __tstate = wxPyBeginAllowThreads();
4115 wxStartTimer();
4116
4117 wxPyEndAllowThreads(__tstate);
4118 if (PyErr_Occurred()) SWIG_fail;
4119 }
4120 Py_INCREF(Py_None); resultobj = Py_None;
4121 return resultobj;
4122 fail:
4123 return NULL;
4124 }
4125
4126
4127 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
4128 PyObject *resultobj = NULL;
4129 int *arg1 = (int *) 0 ;
4130 int *arg2 = (int *) 0 ;
4131 int result;
4132 int temp1 ;
4133 int res1 = 0 ;
4134 int temp2 ;
4135 int res2 = 0 ;
4136 char *kwnames[] = {
4137 NULL
4138 };
4139
4140 arg1 = &temp1; res1 = SWIG_NEWOBJ;
4141 arg2 = &temp2; res2 = SWIG_NEWOBJ;
4142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
4143 {
4144 PyThreadState* __tstate = wxPyBeginAllowThreads();
4145 result = (int)wxGetOsVersion(arg1,arg2);
4146
4147 wxPyEndAllowThreads(__tstate);
4148 if (PyErr_Occurred()) SWIG_fail;
4149 }
4150 {
4151 resultobj = SWIG_From_int(static_cast<int >(result));
4152 }
4153 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4154 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4155 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4156 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4157 return resultobj;
4158 fail:
4159 return NULL;
4160 }
4161
4162
4163 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4164 PyObject *resultobj = NULL;
4165 wxString result;
4166 char *kwnames[] = {
4167 NULL
4168 };
4169
4170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4171 {
4172 PyThreadState* __tstate = wxPyBeginAllowThreads();
4173 result = wxGetOsDescription();
4174
4175 wxPyEndAllowThreads(__tstate);
4176 if (PyErr_Occurred()) SWIG_fail;
4177 }
4178 {
4179 #if wxUSE_UNICODE
4180 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4181 #else
4182 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4183 #endif
4184 }
4185 return resultobj;
4186 fail:
4187 return NULL;
4188 }
4189
4190
4191 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4192 PyObject *resultobj = NULL;
4193 wxMemorySize result;
4194 char *kwnames[] = {
4195 NULL
4196 };
4197
4198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4199 {
4200 PyThreadState* __tstate = wxPyBeginAllowThreads();
4201 result = wxGetFreeMemory();
4202
4203 wxPyEndAllowThreads(__tstate);
4204 if (PyErr_Occurred()) SWIG_fail;
4205 }
4206 {
4207 wxMemorySize * resultptr;
4208 resultptr = new wxMemorySize(static_cast<wxMemorySize & >(result));
4209 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMemorySize, 1);
4210 }
4211 return resultobj;
4212 fail:
4213 return NULL;
4214 }
4215
4216
4217 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4218 PyObject *resultobj = NULL;
4219 wxShutdownFlags arg1 ;
4220 bool result;
4221 PyObject * obj0 = 0 ;
4222 char *kwnames[] = {
4223 (char *) "wFlags", NULL
4224 };
4225
4226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4227 {
4228 arg1 = static_cast<wxShutdownFlags >(SWIG_As_int(obj0));
4229 if (SWIG_arg_fail(1)) SWIG_fail;
4230 }
4231 {
4232 if (!wxPyCheckForApp()) SWIG_fail;
4233 PyThreadState* __tstate = wxPyBeginAllowThreads();
4234 result = (bool)wxShutdown(arg1);
4235
4236 wxPyEndAllowThreads(__tstate);
4237 if (PyErr_Occurred()) SWIG_fail;
4238 }
4239 {
4240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4241 }
4242 return resultobj;
4243 fail:
4244 return NULL;
4245 }
4246
4247
4248 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4249 PyObject *resultobj = NULL;
4250 int arg1 ;
4251 PyObject * obj0 = 0 ;
4252 char *kwnames[] = {
4253 (char *) "secs", NULL
4254 };
4255
4256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4257 {
4258 arg1 = static_cast<int >(SWIG_As_int(obj0));
4259 if (SWIG_arg_fail(1)) SWIG_fail;
4260 }
4261 {
4262 PyThreadState* __tstate = wxPyBeginAllowThreads();
4263 wxSleep(arg1);
4264
4265 wxPyEndAllowThreads(__tstate);
4266 if (PyErr_Occurred()) SWIG_fail;
4267 }
4268 Py_INCREF(Py_None); resultobj = Py_None;
4269 return resultobj;
4270 fail:
4271 return NULL;
4272 }
4273
4274
4275 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4276 PyObject *resultobj = NULL;
4277 unsigned long arg1 ;
4278 PyObject * obj0 = 0 ;
4279 char *kwnames[] = {
4280 (char *) "milliseconds", NULL
4281 };
4282
4283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4284 {
4285 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
4286 if (SWIG_arg_fail(1)) SWIG_fail;
4287 }
4288 {
4289 PyThreadState* __tstate = wxPyBeginAllowThreads();
4290 wxMilliSleep(arg1);
4291
4292 wxPyEndAllowThreads(__tstate);
4293 if (PyErr_Occurred()) SWIG_fail;
4294 }
4295 Py_INCREF(Py_None); resultobj = Py_None;
4296 return resultobj;
4297 fail:
4298 return NULL;
4299 }
4300
4301
4302 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4303 PyObject *resultobj = NULL;
4304 unsigned long arg1 ;
4305 PyObject * obj0 = 0 ;
4306 char *kwnames[] = {
4307 (char *) "microseconds", NULL
4308 };
4309
4310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4311 {
4312 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
4313 if (SWIG_arg_fail(1)) SWIG_fail;
4314 }
4315 {
4316 PyThreadState* __tstate = wxPyBeginAllowThreads();
4317 wxMicroSleep(arg1);
4318
4319 wxPyEndAllowThreads(__tstate);
4320 if (PyErr_Occurred()) SWIG_fail;
4321 }
4322 Py_INCREF(Py_None); resultobj = Py_None;
4323 return resultobj;
4324 fail:
4325 return NULL;
4326 }
4327
4328
4329 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4330 PyObject *resultobj = NULL;
4331 bool arg1 ;
4332 PyObject * obj0 = 0 ;
4333 char *kwnames[] = {
4334 (char *) "enable", NULL
4335 };
4336
4337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4338 {
4339 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
4340 if (SWIG_arg_fail(1)) SWIG_fail;
4341 }
4342 {
4343 PyThreadState* __tstate = wxPyBeginAllowThreads();
4344 wxEnableTopLevelWindows(arg1);
4345
4346 wxPyEndAllowThreads(__tstate);
4347 if (PyErr_Occurred()) SWIG_fail;
4348 }
4349 Py_INCREF(Py_None); resultobj = Py_None;
4350 return resultobj;
4351 fail:
4352 return NULL;
4353 }
4354
4355
4356 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4357 PyObject *resultobj = NULL;
4358 wxString *arg1 = 0 ;
4359 wxString result;
4360 bool temp1 = false ;
4361 PyObject * obj0 = 0 ;
4362 char *kwnames[] = {
4363 (char *) "in", NULL
4364 };
4365
4366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4367 {
4368 arg1 = wxString_in_helper(obj0);
4369 if (arg1 == NULL) SWIG_fail;
4370 temp1 = true;
4371 }
4372 {
4373 PyThreadState* __tstate = wxPyBeginAllowThreads();
4374 result = wxStripMenuCodes((wxString const &)*arg1);
4375
4376 wxPyEndAllowThreads(__tstate);
4377 if (PyErr_Occurred()) SWIG_fail;
4378 }
4379 {
4380 #if wxUSE_UNICODE
4381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4382 #else
4383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4384 #endif
4385 }
4386 {
4387 if (temp1)
4388 delete arg1;
4389 }
4390 return resultobj;
4391 fail:
4392 {
4393 if (temp1)
4394 delete arg1;
4395 }
4396 return NULL;
4397 }
4398
4399
4400 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4401 PyObject *resultobj = NULL;
4402 wxString result;
4403 char *kwnames[] = {
4404 NULL
4405 };
4406
4407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4408 {
4409 PyThreadState* __tstate = wxPyBeginAllowThreads();
4410 result = wxGetEmailAddress();
4411
4412 wxPyEndAllowThreads(__tstate);
4413 if (PyErr_Occurred()) SWIG_fail;
4414 }
4415 {
4416 #if wxUSE_UNICODE
4417 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4418 #else
4419 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4420 #endif
4421 }
4422 return resultobj;
4423 fail:
4424 return NULL;
4425 }
4426
4427
4428 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4429 PyObject *resultobj = NULL;
4430 wxString result;
4431 char *kwnames[] = {
4432 NULL
4433 };
4434
4435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4436 {
4437 PyThreadState* __tstate = wxPyBeginAllowThreads();
4438 result = wxGetHostName();
4439
4440 wxPyEndAllowThreads(__tstate);
4441 if (PyErr_Occurred()) SWIG_fail;
4442 }
4443 {
4444 #if wxUSE_UNICODE
4445 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4446 #else
4447 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4448 #endif
4449 }
4450 return resultobj;
4451 fail:
4452 return NULL;
4453 }
4454
4455
4456 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4457 PyObject *resultobj = NULL;
4458 wxString result;
4459 char *kwnames[] = {
4460 NULL
4461 };
4462
4463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4464 {
4465 PyThreadState* __tstate = wxPyBeginAllowThreads();
4466 result = wxGetFullHostName();
4467
4468 wxPyEndAllowThreads(__tstate);
4469 if (PyErr_Occurred()) SWIG_fail;
4470 }
4471 {
4472 #if wxUSE_UNICODE
4473 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4474 #else
4475 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4476 #endif
4477 }
4478 return resultobj;
4479 fail:
4480 return NULL;
4481 }
4482
4483
4484 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4485 PyObject *resultobj = NULL;
4486 wxString result;
4487 char *kwnames[] = {
4488 NULL
4489 };
4490
4491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4492 {
4493 PyThreadState* __tstate = wxPyBeginAllowThreads();
4494 result = wxGetUserId();
4495
4496 wxPyEndAllowThreads(__tstate);
4497 if (PyErr_Occurred()) SWIG_fail;
4498 }
4499 {
4500 #if wxUSE_UNICODE
4501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4502 #else
4503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4504 #endif
4505 }
4506 return resultobj;
4507 fail:
4508 return NULL;
4509 }
4510
4511
4512 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4513 PyObject *resultobj = NULL;
4514 wxString result;
4515 char *kwnames[] = {
4516 NULL
4517 };
4518
4519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4520 {
4521 PyThreadState* __tstate = wxPyBeginAllowThreads();
4522 result = wxGetUserName();
4523
4524 wxPyEndAllowThreads(__tstate);
4525 if (PyErr_Occurred()) SWIG_fail;
4526 }
4527 {
4528 #if wxUSE_UNICODE
4529 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4530 #else
4531 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4532 #endif
4533 }
4534 return resultobj;
4535 fail:
4536 return NULL;
4537 }
4538
4539
4540 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4541 PyObject *resultobj = NULL;
4542 wxString result;
4543 char *kwnames[] = {
4544 NULL
4545 };
4546
4547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4548 {
4549 PyThreadState* __tstate = wxPyBeginAllowThreads();
4550 result = wxGetHomeDir();
4551
4552 wxPyEndAllowThreads(__tstate);
4553 if (PyErr_Occurred()) SWIG_fail;
4554 }
4555 {
4556 #if wxUSE_UNICODE
4557 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4558 #else
4559 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4560 #endif
4561 }
4562 return resultobj;
4563 fail:
4564 return NULL;
4565 }
4566
4567
4568 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4569 PyObject *resultobj = NULL;
4570 wxString const &arg1_defvalue = wxPyEmptyString ;
4571 wxString *arg1 = (wxString *) &arg1_defvalue ;
4572 wxString result;
4573 bool temp1 = false ;
4574 PyObject * obj0 = 0 ;
4575 char *kwnames[] = {
4576 (char *) "user", NULL
4577 };
4578
4579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4580 if (obj0) {
4581 {
4582 arg1 = wxString_in_helper(obj0);
4583 if (arg1 == NULL) SWIG_fail;
4584 temp1 = true;
4585 }
4586 }
4587 {
4588 PyThreadState* __tstate = wxPyBeginAllowThreads();
4589 result = wxGetUserHome((wxString const &)*arg1);
4590
4591 wxPyEndAllowThreads(__tstate);
4592 if (PyErr_Occurred()) SWIG_fail;
4593 }
4594 {
4595 #if wxUSE_UNICODE
4596 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4597 #else
4598 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4599 #endif
4600 }
4601 {
4602 if (temp1)
4603 delete arg1;
4604 }
4605 return resultobj;
4606 fail:
4607 {
4608 if (temp1)
4609 delete arg1;
4610 }
4611 return NULL;
4612 }
4613
4614
4615 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4616 PyObject *resultobj = NULL;
4617 unsigned long result;
4618 char *kwnames[] = {
4619 NULL
4620 };
4621
4622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4623 {
4624 PyThreadState* __tstate = wxPyBeginAllowThreads();
4625 result = (unsigned long)wxGetProcessId();
4626
4627 wxPyEndAllowThreads(__tstate);
4628 if (PyErr_Occurred()) SWIG_fail;
4629 }
4630 {
4631 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
4632 }
4633 return resultobj;
4634 fail:
4635 return NULL;
4636 }
4637
4638
4639 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4640 PyObject *resultobj = NULL;
4641 char *kwnames[] = {
4642 NULL
4643 };
4644
4645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4646 {
4647 PyThreadState* __tstate = wxPyBeginAllowThreads();
4648 wxTrap();
4649
4650 wxPyEndAllowThreads(__tstate);
4651 if (PyErr_Occurred()) SWIG_fail;
4652 }
4653 Py_INCREF(Py_None); resultobj = Py_None;
4654 return resultobj;
4655 fail:
4656 return NULL;
4657 }
4658
4659
4660 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4661 PyObject *resultobj = NULL;
4662 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4663 wxString *arg1 = (wxString *) &arg1_defvalue ;
4664 wxString const &arg2_defvalue = wxPyEmptyString ;
4665 wxString *arg2 = (wxString *) &arg2_defvalue ;
4666 wxString const &arg3_defvalue = wxPyEmptyString ;
4667 wxString *arg3 = (wxString *) &arg3_defvalue ;
4668 wxString const &arg4_defvalue = wxPyEmptyString ;
4669 wxString *arg4 = (wxString *) &arg4_defvalue ;
4670 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4671 wxString *arg5 = (wxString *) &arg5_defvalue ;
4672 int arg6 = (int) 0 ;
4673 wxWindow *arg7 = (wxWindow *) NULL ;
4674 int arg8 = (int) -1 ;
4675 int arg9 = (int) -1 ;
4676 wxString result;
4677 bool temp1 = false ;
4678 bool temp2 = false ;
4679 bool temp3 = false ;
4680 bool temp4 = false ;
4681 bool temp5 = false ;
4682 PyObject * obj0 = 0 ;
4683 PyObject * obj1 = 0 ;
4684 PyObject * obj2 = 0 ;
4685 PyObject * obj3 = 0 ;
4686 PyObject * obj4 = 0 ;
4687 PyObject * obj5 = 0 ;
4688 PyObject * obj6 = 0 ;
4689 PyObject * obj7 = 0 ;
4690 PyObject * obj8 = 0 ;
4691 char *kwnames[] = {
4692 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4693 };
4694
4695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4696 if (obj0) {
4697 {
4698 arg1 = wxString_in_helper(obj0);
4699 if (arg1 == NULL) SWIG_fail;
4700 temp1 = true;
4701 }
4702 }
4703 if (obj1) {
4704 {
4705 arg2 = wxString_in_helper(obj1);
4706 if (arg2 == NULL) SWIG_fail;
4707 temp2 = true;
4708 }
4709 }
4710 if (obj2) {
4711 {
4712 arg3 = wxString_in_helper(obj2);
4713 if (arg3 == NULL) SWIG_fail;
4714 temp3 = true;
4715 }
4716 }
4717 if (obj3) {
4718 {
4719 arg4 = wxString_in_helper(obj3);
4720 if (arg4 == NULL) SWIG_fail;
4721 temp4 = true;
4722 }
4723 }
4724 if (obj4) {
4725 {
4726 arg5 = wxString_in_helper(obj4);
4727 if (arg5 == NULL) SWIG_fail;
4728 temp5 = true;
4729 }
4730 }
4731 if (obj5) {
4732 {
4733 arg6 = static_cast<int >(SWIG_As_int(obj5));
4734 if (SWIG_arg_fail(6)) SWIG_fail;
4735 }
4736 }
4737 if (obj6) {
4738 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4739 if (SWIG_arg_fail(7)) SWIG_fail;
4740 }
4741 if (obj7) {
4742 {
4743 arg8 = static_cast<int >(SWIG_As_int(obj7));
4744 if (SWIG_arg_fail(8)) SWIG_fail;
4745 }
4746 }
4747 if (obj8) {
4748 {
4749 arg9 = static_cast<int >(SWIG_As_int(obj8));
4750 if (SWIG_arg_fail(9)) SWIG_fail;
4751 }
4752 }
4753 {
4754 if (!wxPyCheckForApp()) SWIG_fail;
4755 PyThreadState* __tstate = wxPyBeginAllowThreads();
4756 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4757
4758 wxPyEndAllowThreads(__tstate);
4759 if (PyErr_Occurred()) SWIG_fail;
4760 }
4761 {
4762 #if wxUSE_UNICODE
4763 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4764 #else
4765 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4766 #endif
4767 }
4768 {
4769 if (temp1)
4770 delete arg1;
4771 }
4772 {
4773 if (temp2)
4774 delete arg2;
4775 }
4776 {
4777 if (temp3)
4778 delete arg3;
4779 }
4780 {
4781 if (temp4)
4782 delete arg4;
4783 }
4784 {
4785 if (temp5)
4786 delete arg5;
4787 }
4788 return resultobj;
4789 fail:
4790 {
4791 if (temp1)
4792 delete arg1;
4793 }
4794 {
4795 if (temp2)
4796 delete arg2;
4797 }
4798 {
4799 if (temp3)
4800 delete arg3;
4801 }
4802 {
4803 if (temp4)
4804 delete arg4;
4805 }
4806 {
4807 if (temp5)
4808 delete arg5;
4809 }
4810 return NULL;
4811 }
4812
4813
4814 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4815 PyObject *resultobj = NULL;
4816 wxString *arg1 = 0 ;
4817 wxString *arg2 = 0 ;
4818 wxString const &arg3_defvalue = wxPyEmptyString ;
4819 wxString *arg3 = (wxString *) &arg3_defvalue ;
4820 wxWindow *arg4 = (wxWindow *) NULL ;
4821 wxString result;
4822 bool temp1 = false ;
4823 bool temp2 = false ;
4824 bool temp3 = false ;
4825 PyObject * obj0 = 0 ;
4826 PyObject * obj1 = 0 ;
4827 PyObject * obj2 = 0 ;
4828 PyObject * obj3 = 0 ;
4829 char *kwnames[] = {
4830 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4831 };
4832
4833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4834 {
4835 arg1 = wxString_in_helper(obj0);
4836 if (arg1 == NULL) SWIG_fail;
4837 temp1 = true;
4838 }
4839 {
4840 arg2 = wxString_in_helper(obj1);
4841 if (arg2 == NULL) SWIG_fail;
4842 temp2 = true;
4843 }
4844 if (obj2) {
4845 {
4846 arg3 = wxString_in_helper(obj2);
4847 if (arg3 == NULL) SWIG_fail;
4848 temp3 = true;
4849 }
4850 }
4851 if (obj3) {
4852 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4853 if (SWIG_arg_fail(4)) SWIG_fail;
4854 }
4855 {
4856 if (!wxPyCheckForApp()) SWIG_fail;
4857 PyThreadState* __tstate = wxPyBeginAllowThreads();
4858 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4859
4860 wxPyEndAllowThreads(__tstate);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 {
4864 #if wxUSE_UNICODE
4865 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4866 #else
4867 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4868 #endif
4869 }
4870 {
4871 if (temp1)
4872 delete arg1;
4873 }
4874 {
4875 if (temp2)
4876 delete arg2;
4877 }
4878 {
4879 if (temp3)
4880 delete arg3;
4881 }
4882 return resultobj;
4883 fail:
4884 {
4885 if (temp1)
4886 delete arg1;
4887 }
4888 {
4889 if (temp2)
4890 delete arg2;
4891 }
4892 {
4893 if (temp3)
4894 delete arg3;
4895 }
4896 return NULL;
4897 }
4898
4899
4900 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4901 PyObject *resultobj = NULL;
4902 wxString *arg1 = 0 ;
4903 wxString *arg2 = 0 ;
4904 wxString const &arg3_defvalue = wxPyEmptyString ;
4905 wxString *arg3 = (wxString *) &arg3_defvalue ;
4906 wxWindow *arg4 = (wxWindow *) NULL ;
4907 wxString result;
4908 bool temp1 = false ;
4909 bool temp2 = false ;
4910 bool temp3 = false ;
4911 PyObject * obj0 = 0 ;
4912 PyObject * obj1 = 0 ;
4913 PyObject * obj2 = 0 ;
4914 PyObject * obj3 = 0 ;
4915 char *kwnames[] = {
4916 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4917 };
4918
4919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4920 {
4921 arg1 = wxString_in_helper(obj0);
4922 if (arg1 == NULL) SWIG_fail;
4923 temp1 = true;
4924 }
4925 {
4926 arg2 = wxString_in_helper(obj1);
4927 if (arg2 == NULL) SWIG_fail;
4928 temp2 = true;
4929 }
4930 if (obj2) {
4931 {
4932 arg3 = wxString_in_helper(obj2);
4933 if (arg3 == NULL) SWIG_fail;
4934 temp3 = true;
4935 }
4936 }
4937 if (obj3) {
4938 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4939 if (SWIG_arg_fail(4)) SWIG_fail;
4940 }
4941 {
4942 if (!wxPyCheckForApp()) SWIG_fail;
4943 PyThreadState* __tstate = wxPyBeginAllowThreads();
4944 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4945
4946 wxPyEndAllowThreads(__tstate);
4947 if (PyErr_Occurred()) SWIG_fail;
4948 }
4949 {
4950 #if wxUSE_UNICODE
4951 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4952 #else
4953 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4954 #endif
4955 }
4956 {
4957 if (temp1)
4958 delete arg1;
4959 }
4960 {
4961 if (temp2)
4962 delete arg2;
4963 }
4964 {
4965 if (temp3)
4966 delete arg3;
4967 }
4968 return resultobj;
4969 fail:
4970 {
4971 if (temp1)
4972 delete arg1;
4973 }
4974 {
4975 if (temp2)
4976 delete arg2;
4977 }
4978 {
4979 if (temp3)
4980 delete arg3;
4981 }
4982 return NULL;
4983 }
4984
4985
4986 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4987 PyObject *resultobj = NULL;
4988 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4989 wxString *arg1 = (wxString *) &arg1_defvalue ;
4990 wxString const &arg2_defvalue = wxPyEmptyString ;
4991 wxString *arg2 = (wxString *) &arg2_defvalue ;
4992 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4993 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4994 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4995 wxWindow *arg5 = (wxWindow *) NULL ;
4996 wxString result;
4997 bool temp1 = false ;
4998 bool temp2 = false ;
4999 wxPoint temp4 ;
5000 PyObject * obj0 = 0 ;
5001 PyObject * obj1 = 0 ;
5002 PyObject * obj2 = 0 ;
5003 PyObject * obj3 = 0 ;
5004 PyObject * obj4 = 0 ;
5005 char *kwnames[] = {
5006 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5007 };
5008
5009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5010 if (obj0) {
5011 {
5012 arg1 = wxString_in_helper(obj0);
5013 if (arg1 == NULL) SWIG_fail;
5014 temp1 = true;
5015 }
5016 }
5017 if (obj1) {
5018 {
5019 arg2 = wxString_in_helper(obj1);
5020 if (arg2 == NULL) SWIG_fail;
5021 temp2 = true;
5022 }
5023 }
5024 if (obj2) {
5025 {
5026 arg3 = static_cast<long >(SWIG_As_long(obj2));
5027 if (SWIG_arg_fail(3)) SWIG_fail;
5028 }
5029 }
5030 if (obj3) {
5031 {
5032 arg4 = &temp4;
5033 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5034 }
5035 }
5036 if (obj4) {
5037 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5038 if (SWIG_arg_fail(5)) SWIG_fail;
5039 }
5040 {
5041 if (!wxPyCheckForApp()) SWIG_fail;
5042 PyThreadState* __tstate = wxPyBeginAllowThreads();
5043 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5044
5045 wxPyEndAllowThreads(__tstate);
5046 if (PyErr_Occurred()) SWIG_fail;
5047 }
5048 {
5049 #if wxUSE_UNICODE
5050 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5051 #else
5052 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5053 #endif
5054 }
5055 {
5056 if (temp1)
5057 delete arg1;
5058 }
5059 {
5060 if (temp2)
5061 delete arg2;
5062 }
5063 return resultobj;
5064 fail:
5065 {
5066 if (temp1)
5067 delete arg1;
5068 }
5069 {
5070 if (temp2)
5071 delete arg2;
5072 }
5073 return NULL;
5074 }
5075
5076
5077 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5078 PyObject *resultobj = NULL;
5079 wxString *arg1 = 0 ;
5080 wxString const &arg2_defvalue = wxPyEmptyString ;
5081 wxString *arg2 = (wxString *) &arg2_defvalue ;
5082 wxString const &arg3_defvalue = wxPyEmptyString ;
5083 wxString *arg3 = (wxString *) &arg3_defvalue ;
5084 wxWindow *arg4 = (wxWindow *) NULL ;
5085 int arg5 = (int) -1 ;
5086 int arg6 = (int) -1 ;
5087 bool arg7 = (bool) true ;
5088 wxString result;
5089 bool temp1 = false ;
5090 bool temp2 = false ;
5091 bool temp3 = false ;
5092 PyObject * obj0 = 0 ;
5093 PyObject * obj1 = 0 ;
5094 PyObject * obj2 = 0 ;
5095 PyObject * obj3 = 0 ;
5096 PyObject * obj4 = 0 ;
5097 PyObject * obj5 = 0 ;
5098 PyObject * obj6 = 0 ;
5099 char *kwnames[] = {
5100 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5101 };
5102
5103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
5104 {
5105 arg1 = wxString_in_helper(obj0);
5106 if (arg1 == NULL) SWIG_fail;
5107 temp1 = true;
5108 }
5109 if (obj1) {
5110 {
5111 arg2 = wxString_in_helper(obj1);
5112 if (arg2 == NULL) SWIG_fail;
5113 temp2 = true;
5114 }
5115 }
5116 if (obj2) {
5117 {
5118 arg3 = wxString_in_helper(obj2);
5119 if (arg3 == NULL) SWIG_fail;
5120 temp3 = true;
5121 }
5122 }
5123 if (obj3) {
5124 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5125 if (SWIG_arg_fail(4)) SWIG_fail;
5126 }
5127 if (obj4) {
5128 {
5129 arg5 = static_cast<int >(SWIG_As_int(obj4));
5130 if (SWIG_arg_fail(5)) SWIG_fail;
5131 }
5132 }
5133 if (obj5) {
5134 {
5135 arg6 = static_cast<int >(SWIG_As_int(obj5));
5136 if (SWIG_arg_fail(6)) SWIG_fail;
5137 }
5138 }
5139 if (obj6) {
5140 {
5141 arg7 = static_cast<bool >(SWIG_As_bool(obj6));
5142 if (SWIG_arg_fail(7)) SWIG_fail;
5143 }
5144 }
5145 {
5146 if (!wxPyCheckForApp()) SWIG_fail;
5147 PyThreadState* __tstate = wxPyBeginAllowThreads();
5148 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
5149
5150 wxPyEndAllowThreads(__tstate);
5151 if (PyErr_Occurred()) SWIG_fail;
5152 }
5153 {
5154 #if wxUSE_UNICODE
5155 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5156 #else
5157 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5158 #endif
5159 }
5160 {
5161 if (temp1)
5162 delete arg1;
5163 }
5164 {
5165 if (temp2)
5166 delete arg2;
5167 }
5168 {
5169 if (temp3)
5170 delete arg3;
5171 }
5172 return resultobj;
5173 fail:
5174 {
5175 if (temp1)
5176 delete arg1;
5177 }
5178 {
5179 if (temp2)
5180 delete arg2;
5181 }
5182 {
5183 if (temp3)
5184 delete arg3;
5185 }
5186 return NULL;
5187 }
5188
5189
5190 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5191 PyObject *resultobj = NULL;
5192 wxString *arg1 = 0 ;
5193 wxString const &arg2_defvalue = wxPyEmptyString ;
5194 wxString *arg2 = (wxString *) &arg2_defvalue ;
5195 wxString const &arg3_defvalue = wxPyEmptyString ;
5196 wxString *arg3 = (wxString *) &arg3_defvalue ;
5197 wxWindow *arg4 = (wxWindow *) NULL ;
5198 wxString result;
5199 bool temp1 = false ;
5200 bool temp2 = false ;
5201 bool temp3 = false ;
5202 PyObject * obj0 = 0 ;
5203 PyObject * obj1 = 0 ;
5204 PyObject * obj2 = 0 ;
5205 PyObject * obj3 = 0 ;
5206 char *kwnames[] = {
5207 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5208 };
5209
5210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5211 {
5212 arg1 = wxString_in_helper(obj0);
5213 if (arg1 == NULL) SWIG_fail;
5214 temp1 = true;
5215 }
5216 if (obj1) {
5217 {
5218 arg2 = wxString_in_helper(obj1);
5219 if (arg2 == NULL) SWIG_fail;
5220 temp2 = true;
5221 }
5222 }
5223 if (obj2) {
5224 {
5225 arg3 = wxString_in_helper(obj2);
5226 if (arg3 == NULL) SWIG_fail;
5227 temp3 = true;
5228 }
5229 }
5230 if (obj3) {
5231 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5232 if (SWIG_arg_fail(4)) SWIG_fail;
5233 }
5234 {
5235 if (!wxPyCheckForApp()) SWIG_fail;
5236 PyThreadState* __tstate = wxPyBeginAllowThreads();
5237 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5238
5239 wxPyEndAllowThreads(__tstate);
5240 if (PyErr_Occurred()) SWIG_fail;
5241 }
5242 {
5243 #if wxUSE_UNICODE
5244 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5245 #else
5246 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5247 #endif
5248 }
5249 {
5250 if (temp1)
5251 delete arg1;
5252 }
5253 {
5254 if (temp2)
5255 delete arg2;
5256 }
5257 {
5258 if (temp3)
5259 delete arg3;
5260 }
5261 return resultobj;
5262 fail:
5263 {
5264 if (temp1)
5265 delete arg1;
5266 }
5267 {
5268 if (temp2)
5269 delete arg2;
5270 }
5271 {
5272 if (temp3)
5273 delete arg3;
5274 }
5275 return NULL;
5276 }
5277
5278
5279 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5280 PyObject *resultobj = NULL;
5281 wxString *arg1 = 0 ;
5282 wxString *arg2 = 0 ;
5283 int arg3 ;
5284 wxString *arg4 = (wxString *) 0 ;
5285 wxWindow *arg5 = (wxWindow *) NULL ;
5286 int arg6 = (int) -1 ;
5287 int arg7 = (int) -1 ;
5288 bool arg8 = (bool) true ;
5289 int arg9 = (int) 150 ;
5290 int arg10 = (int) 200 ;
5291 wxString result;
5292 bool temp1 = false ;
5293 bool temp2 = false ;
5294 PyObject * obj0 = 0 ;
5295 PyObject * obj1 = 0 ;
5296 PyObject * obj2 = 0 ;
5297 PyObject * obj3 = 0 ;
5298 PyObject * obj4 = 0 ;
5299 PyObject * obj5 = 0 ;
5300 PyObject * obj6 = 0 ;
5301 PyObject * obj7 = 0 ;
5302 PyObject * obj8 = 0 ;
5303 char *kwnames[] = {
5304 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5305 };
5306
5307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5308 {
5309 arg1 = wxString_in_helper(obj0);
5310 if (arg1 == NULL) SWIG_fail;
5311 temp1 = true;
5312 }
5313 {
5314 arg2 = wxString_in_helper(obj1);
5315 if (arg2 == NULL) SWIG_fail;
5316 temp2 = true;
5317 }
5318 {
5319 arg3 = PyList_Size(obj2);
5320 arg4 = wxString_LIST_helper(obj2);
5321 if (arg4 == NULL) SWIG_fail;
5322 }
5323 if (obj3) {
5324 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5325 if (SWIG_arg_fail(5)) SWIG_fail;
5326 }
5327 if (obj4) {
5328 {
5329 arg6 = static_cast<int >(SWIG_As_int(obj4));
5330 if (SWIG_arg_fail(6)) SWIG_fail;
5331 }
5332 }
5333 if (obj5) {
5334 {
5335 arg7 = static_cast<int >(SWIG_As_int(obj5));
5336 if (SWIG_arg_fail(7)) SWIG_fail;
5337 }
5338 }
5339 if (obj6) {
5340 {
5341 arg8 = static_cast<bool >(SWIG_As_bool(obj6));
5342 if (SWIG_arg_fail(8)) SWIG_fail;
5343 }
5344 }
5345 if (obj7) {
5346 {
5347 arg9 = static_cast<int >(SWIG_As_int(obj7));
5348 if (SWIG_arg_fail(9)) SWIG_fail;
5349 }
5350 }
5351 if (obj8) {
5352 {
5353 arg10 = static_cast<int >(SWIG_As_int(obj8));
5354 if (SWIG_arg_fail(10)) SWIG_fail;
5355 }
5356 }
5357 {
5358 if (!wxPyCheckForApp()) SWIG_fail;
5359 PyThreadState* __tstate = wxPyBeginAllowThreads();
5360 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5361
5362 wxPyEndAllowThreads(__tstate);
5363 if (PyErr_Occurred()) SWIG_fail;
5364 }
5365 {
5366 #if wxUSE_UNICODE
5367 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5368 #else
5369 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5370 #endif
5371 }
5372 {
5373 if (temp1)
5374 delete arg1;
5375 }
5376 {
5377 if (temp2)
5378 delete arg2;
5379 }
5380 {
5381 if (arg4) delete [] arg4;
5382 }
5383 return resultobj;
5384 fail:
5385 {
5386 if (temp1)
5387 delete arg1;
5388 }
5389 {
5390 if (temp2)
5391 delete arg2;
5392 }
5393 {
5394 if (arg4) delete [] arg4;
5395 }
5396 return NULL;
5397 }
5398
5399
5400 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5401 PyObject *resultobj = NULL;
5402 wxString *arg1 = 0 ;
5403 wxString *arg2 = 0 ;
5404 int arg3 ;
5405 wxString *arg4 = (wxString *) 0 ;
5406 wxWindow *arg5 = (wxWindow *) NULL ;
5407 int arg6 = (int) -1 ;
5408 int arg7 = (int) -1 ;
5409 bool arg8 = (bool) true ;
5410 int arg9 = (int) 150 ;
5411 int arg10 = (int) 200 ;
5412 int result;
5413 bool temp1 = false ;
5414 bool temp2 = false ;
5415 PyObject * obj0 = 0 ;
5416 PyObject * obj1 = 0 ;
5417 PyObject * obj2 = 0 ;
5418 PyObject * obj3 = 0 ;
5419 PyObject * obj4 = 0 ;
5420 PyObject * obj5 = 0 ;
5421 PyObject * obj6 = 0 ;
5422 PyObject * obj7 = 0 ;
5423 PyObject * obj8 = 0 ;
5424 char *kwnames[] = {
5425 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5426 };
5427
5428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5429 {
5430 arg1 = wxString_in_helper(obj0);
5431 if (arg1 == NULL) SWIG_fail;
5432 temp1 = true;
5433 }
5434 {
5435 arg2 = wxString_in_helper(obj1);
5436 if (arg2 == NULL) SWIG_fail;
5437 temp2 = true;
5438 }
5439 {
5440 arg3 = PyList_Size(obj2);
5441 arg4 = wxString_LIST_helper(obj2);
5442 if (arg4 == NULL) SWIG_fail;
5443 }
5444 if (obj3) {
5445 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5446 if (SWIG_arg_fail(5)) SWIG_fail;
5447 }
5448 if (obj4) {
5449 {
5450 arg6 = static_cast<int >(SWIG_As_int(obj4));
5451 if (SWIG_arg_fail(6)) SWIG_fail;
5452 }
5453 }
5454 if (obj5) {
5455 {
5456 arg7 = static_cast<int >(SWIG_As_int(obj5));
5457 if (SWIG_arg_fail(7)) SWIG_fail;
5458 }
5459 }
5460 if (obj6) {
5461 {
5462 arg8 = static_cast<bool >(SWIG_As_bool(obj6));
5463 if (SWIG_arg_fail(8)) SWIG_fail;
5464 }
5465 }
5466 if (obj7) {
5467 {
5468 arg9 = static_cast<int >(SWIG_As_int(obj7));
5469 if (SWIG_arg_fail(9)) SWIG_fail;
5470 }
5471 }
5472 if (obj8) {
5473 {
5474 arg10 = static_cast<int >(SWIG_As_int(obj8));
5475 if (SWIG_arg_fail(10)) SWIG_fail;
5476 }
5477 }
5478 {
5479 if (!wxPyCheckForApp()) SWIG_fail;
5480 PyThreadState* __tstate = wxPyBeginAllowThreads();
5481 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5482
5483 wxPyEndAllowThreads(__tstate);
5484 if (PyErr_Occurred()) SWIG_fail;
5485 }
5486 {
5487 resultobj = SWIG_From_int(static_cast<int >(result));
5488 }
5489 {
5490 if (temp1)
5491 delete arg1;
5492 }
5493 {
5494 if (temp2)
5495 delete arg2;
5496 }
5497 {
5498 if (arg4) delete [] arg4;
5499 }
5500 return resultobj;
5501 fail:
5502 {
5503 if (temp1)
5504 delete arg1;
5505 }
5506 {
5507 if (temp2)
5508 delete arg2;
5509 }
5510 {
5511 if (arg4) delete [] arg4;
5512 }
5513 return NULL;
5514 }
5515
5516
5517 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5518 PyObject *resultobj = NULL;
5519 wxString *arg1 = 0 ;
5520 wxString const &arg2_defvalue = wxPyEmptyString ;
5521 wxString *arg2 = (wxString *) &arg2_defvalue ;
5522 int arg3 = (int) wxOK|wxCENTRE ;
5523 wxWindow *arg4 = (wxWindow *) NULL ;
5524 int arg5 = (int) -1 ;
5525 int arg6 = (int) -1 ;
5526 int result;
5527 bool temp1 = false ;
5528 bool temp2 = false ;
5529 PyObject * obj0 = 0 ;
5530 PyObject * obj1 = 0 ;
5531 PyObject * obj2 = 0 ;
5532 PyObject * obj3 = 0 ;
5533 PyObject * obj4 = 0 ;
5534 PyObject * obj5 = 0 ;
5535 char *kwnames[] = {
5536 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5537 };
5538
5539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5540 {
5541 arg1 = wxString_in_helper(obj0);
5542 if (arg1 == NULL) SWIG_fail;
5543 temp1 = true;
5544 }
5545 if (obj1) {
5546 {
5547 arg2 = wxString_in_helper(obj1);
5548 if (arg2 == NULL) SWIG_fail;
5549 temp2 = true;
5550 }
5551 }
5552 if (obj2) {
5553 {
5554 arg3 = static_cast<int >(SWIG_As_int(obj2));
5555 if (SWIG_arg_fail(3)) SWIG_fail;
5556 }
5557 }
5558 if (obj3) {
5559 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5560 if (SWIG_arg_fail(4)) SWIG_fail;
5561 }
5562 if (obj4) {
5563 {
5564 arg5 = static_cast<int >(SWIG_As_int(obj4));
5565 if (SWIG_arg_fail(5)) SWIG_fail;
5566 }
5567 }
5568 if (obj5) {
5569 {
5570 arg6 = static_cast<int >(SWIG_As_int(obj5));
5571 if (SWIG_arg_fail(6)) SWIG_fail;
5572 }
5573 }
5574 {
5575 if (!wxPyCheckForApp()) SWIG_fail;
5576 PyThreadState* __tstate = wxPyBeginAllowThreads();
5577 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5578
5579 wxPyEndAllowThreads(__tstate);
5580 if (PyErr_Occurred()) SWIG_fail;
5581 }
5582 {
5583 resultobj = SWIG_From_int(static_cast<int >(result));
5584 }
5585 {
5586 if (temp1)
5587 delete arg1;
5588 }
5589 {
5590 if (temp2)
5591 delete arg2;
5592 }
5593 return resultobj;
5594 fail:
5595 {
5596 if (temp1)
5597 delete arg1;
5598 }
5599 {
5600 if (temp2)
5601 delete arg2;
5602 }
5603 return NULL;
5604 }
5605
5606
5607 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5608 PyObject *resultobj = NULL;
5609 bool result;
5610 char *kwnames[] = {
5611 NULL
5612 };
5613
5614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5615 {
5616 if (!wxPyCheckForApp()) SWIG_fail;
5617 PyThreadState* __tstate = wxPyBeginAllowThreads();
5618 result = (bool)wxColourDisplay();
5619
5620 wxPyEndAllowThreads(__tstate);
5621 if (PyErr_Occurred()) SWIG_fail;
5622 }
5623 {
5624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5625 }
5626 return resultobj;
5627 fail:
5628 return NULL;
5629 }
5630
5631
5632 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5633 PyObject *resultobj = NULL;
5634 int result;
5635 char *kwnames[] = {
5636 NULL
5637 };
5638
5639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5640 {
5641 if (!wxPyCheckForApp()) SWIG_fail;
5642 PyThreadState* __tstate = wxPyBeginAllowThreads();
5643 result = (int)wxDisplayDepth();
5644
5645 wxPyEndAllowThreads(__tstate);
5646 if (PyErr_Occurred()) SWIG_fail;
5647 }
5648 {
5649 resultobj = SWIG_From_int(static_cast<int >(result));
5650 }
5651 return resultobj;
5652 fail:
5653 return NULL;
5654 }
5655
5656
5657 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5658 PyObject *resultobj = NULL;
5659 int result;
5660 char *kwnames[] = {
5661 NULL
5662 };
5663
5664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5665 {
5666 if (!wxPyCheckForApp()) SWIG_fail;
5667 PyThreadState* __tstate = wxPyBeginAllowThreads();
5668 result = (int)wxGetDisplayDepth();
5669
5670 wxPyEndAllowThreads(__tstate);
5671 if (PyErr_Occurred()) SWIG_fail;
5672 }
5673 {
5674 resultobj = SWIG_From_int(static_cast<int >(result));
5675 }
5676 return resultobj;
5677 fail:
5678 return NULL;
5679 }
5680
5681
5682 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5683 PyObject *resultobj = NULL;
5684 int *arg1 = (int *) 0 ;
5685 int *arg2 = (int *) 0 ;
5686 int temp1 ;
5687 int res1 = 0 ;
5688 int temp2 ;
5689 int res2 = 0 ;
5690 char *kwnames[] = {
5691 NULL
5692 };
5693
5694 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5695 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5697 {
5698 if (!wxPyCheckForApp()) SWIG_fail;
5699 PyThreadState* __tstate = wxPyBeginAllowThreads();
5700 wxDisplaySize(arg1,arg2);
5701
5702 wxPyEndAllowThreads(__tstate);
5703 if (PyErr_Occurred()) SWIG_fail;
5704 }
5705 Py_INCREF(Py_None); resultobj = Py_None;
5706 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5707 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5708 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5709 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5710 return resultobj;
5711 fail:
5712 return NULL;
5713 }
5714
5715
5716 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5717 PyObject *resultobj = NULL;
5718 wxSize result;
5719 char *kwnames[] = {
5720 NULL
5721 };
5722
5723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5724 {
5725 if (!wxPyCheckForApp()) SWIG_fail;
5726 PyThreadState* __tstate = wxPyBeginAllowThreads();
5727 result = wxGetDisplaySize();
5728
5729 wxPyEndAllowThreads(__tstate);
5730 if (PyErr_Occurred()) SWIG_fail;
5731 }
5732 {
5733 wxSize * resultptr;
5734 resultptr = new wxSize(static_cast<wxSize & >(result));
5735 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5736 }
5737 return resultobj;
5738 fail:
5739 return NULL;
5740 }
5741
5742
5743 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5744 PyObject *resultobj = NULL;
5745 int *arg1 = (int *) 0 ;
5746 int *arg2 = (int *) 0 ;
5747 int temp1 ;
5748 int res1 = 0 ;
5749 int temp2 ;
5750 int res2 = 0 ;
5751 char *kwnames[] = {
5752 NULL
5753 };
5754
5755 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5756 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5758 {
5759 if (!wxPyCheckForApp()) SWIG_fail;
5760 PyThreadState* __tstate = wxPyBeginAllowThreads();
5761 wxDisplaySizeMM(arg1,arg2);
5762
5763 wxPyEndAllowThreads(__tstate);
5764 if (PyErr_Occurred()) SWIG_fail;
5765 }
5766 Py_INCREF(Py_None); resultobj = Py_None;
5767 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5768 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5769 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5770 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5771 return resultobj;
5772 fail:
5773 return NULL;
5774 }
5775
5776
5777 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5778 PyObject *resultobj = NULL;
5779 wxSize result;
5780 char *kwnames[] = {
5781 NULL
5782 };
5783
5784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5785 {
5786 if (!wxPyCheckForApp()) SWIG_fail;
5787 PyThreadState* __tstate = wxPyBeginAllowThreads();
5788 result = wxGetDisplaySizeMM();
5789
5790 wxPyEndAllowThreads(__tstate);
5791 if (PyErr_Occurred()) SWIG_fail;
5792 }
5793 {
5794 wxSize * resultptr;
5795 resultptr = new wxSize(static_cast<wxSize & >(result));
5796 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5797 }
5798 return resultobj;
5799 fail:
5800 return NULL;
5801 }
5802
5803
5804 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5805 PyObject *resultobj = NULL;
5806 int *arg1 = (int *) 0 ;
5807 int *arg2 = (int *) 0 ;
5808 int *arg3 = (int *) 0 ;
5809 int *arg4 = (int *) 0 ;
5810 int temp1 ;
5811 int res1 = 0 ;
5812 int temp2 ;
5813 int res2 = 0 ;
5814 int temp3 ;
5815 int res3 = 0 ;
5816 int temp4 ;
5817 int res4 = 0 ;
5818 char *kwnames[] = {
5819 NULL
5820 };
5821
5822 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5823 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5824 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5825 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5827 {
5828 if (!wxPyCheckForApp()) SWIG_fail;
5829 PyThreadState* __tstate = wxPyBeginAllowThreads();
5830 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5831
5832 wxPyEndAllowThreads(__tstate);
5833 if (PyErr_Occurred()) SWIG_fail;
5834 }
5835 Py_INCREF(Py_None); resultobj = Py_None;
5836 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5837 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5838 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5839 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5840 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5841 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5842 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5843 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5844 return resultobj;
5845 fail:
5846 return NULL;
5847 }
5848
5849
5850 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5851 PyObject *resultobj = NULL;
5852 wxRect result;
5853 char *kwnames[] = {
5854 NULL
5855 };
5856
5857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5858 {
5859 if (!wxPyCheckForApp()) SWIG_fail;
5860 PyThreadState* __tstate = wxPyBeginAllowThreads();
5861 result = wxGetClientDisplayRect();
5862
5863 wxPyEndAllowThreads(__tstate);
5864 if (PyErr_Occurred()) SWIG_fail;
5865 }
5866 {
5867 wxRect * resultptr;
5868 resultptr = new wxRect(static_cast<wxRect & >(result));
5869 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5870 }
5871 return resultobj;
5872 fail:
5873 return NULL;
5874 }
5875
5876
5877 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5878 PyObject *resultobj = NULL;
5879 wxCursor *arg1 = 0 ;
5880 PyObject * obj0 = 0 ;
5881 char *kwnames[] = {
5882 (char *) "cursor", NULL
5883 };
5884
5885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5886 {
5887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5888 if (SWIG_arg_fail(1)) SWIG_fail;
5889 if (arg1 == NULL) {
5890 SWIG_null_ref("wxCursor");
5891 }
5892 if (SWIG_arg_fail(1)) SWIG_fail;
5893 }
5894 {
5895 if (!wxPyCheckForApp()) SWIG_fail;
5896 PyThreadState* __tstate = wxPyBeginAllowThreads();
5897 wxSetCursor(*arg1);
5898
5899 wxPyEndAllowThreads(__tstate);
5900 if (PyErr_Occurred()) SWIG_fail;
5901 }
5902 Py_INCREF(Py_None); resultobj = Py_None;
5903 return resultobj;
5904 fail:
5905 return NULL;
5906 }
5907
5908
5909 static PyObject *_wrap_GetXDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5910 PyObject *resultobj = NULL;
5911 void *result;
5912 char *kwnames[] = {
5913 NULL
5914 };
5915
5916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetXDisplay",kwnames)) goto fail;
5917 {
5918 if (!wxPyCheckForApp()) SWIG_fail;
5919 PyThreadState* __tstate = wxPyBeginAllowThreads();
5920 result = (void *)wxGetXDisplay();
5921
5922 wxPyEndAllowThreads(__tstate);
5923 if (PyErr_Occurred()) SWIG_fail;
5924 }
5925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
5926 return resultobj;
5927 fail:
5928 return NULL;
5929 }
5930
5931
5932 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5933 PyObject *resultobj = NULL;
5934 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5935 PyObject * obj0 = 0 ;
5936 char *kwnames[] = {
5937 (char *) "cursor", NULL
5938 };
5939
5940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5941 if (obj0) {
5942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5943 if (SWIG_arg_fail(1)) SWIG_fail;
5944 }
5945 {
5946 if (!wxPyCheckForApp()) SWIG_fail;
5947 PyThreadState* __tstate = wxPyBeginAllowThreads();
5948 wxBeginBusyCursor(arg1);
5949
5950 wxPyEndAllowThreads(__tstate);
5951 if (PyErr_Occurred()) SWIG_fail;
5952 }
5953 Py_INCREF(Py_None); resultobj = Py_None;
5954 return resultobj;
5955 fail:
5956 return NULL;
5957 }
5958
5959
5960 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
5961 PyObject *resultobj = NULL;
5962 wxPoint result;
5963 char *kwnames[] = {
5964 NULL
5965 };
5966
5967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
5968 {
5969 if (!wxPyCheckForApp()) SWIG_fail;
5970 PyThreadState* __tstate = wxPyBeginAllowThreads();
5971 result = wxGetMousePosition();
5972
5973 wxPyEndAllowThreads(__tstate);
5974 if (PyErr_Occurred()) SWIG_fail;
5975 }
5976 {
5977 wxPoint * resultptr;
5978 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5979 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5980 }
5981 return resultobj;
5982 fail:
5983 return NULL;
5984 }
5985
5986
5987 static PyObject *_wrap_FindWindowAtPointer(PyObject *, PyObject *args, PyObject *kwargs) {
5988 PyObject *resultobj = NULL;
5989 wxWindow *result;
5990 char *kwnames[] = {
5991 NULL
5992 };
5993
5994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FindWindowAtPointer",kwnames)) goto fail;
5995 {
5996 if (!wxPyCheckForApp()) SWIG_fail;
5997 PyThreadState* __tstate = wxPyBeginAllowThreads();
5998 result = (wxWindow *)FindWindowAtPointer();
5999
6000 wxPyEndAllowThreads(__tstate);
6001 if (PyErr_Occurred()) SWIG_fail;
6002 }
6003 {
6004 resultobj = wxPyMake_wxObject(result, 0);
6005 }
6006 return resultobj;
6007 fail:
6008 return NULL;
6009 }
6010
6011
6012 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6013 PyObject *resultobj = NULL;
6014 wxWindow *result;
6015 char *kwnames[] = {
6016 NULL
6017 };
6018
6019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
6020 {
6021 if (!wxPyCheckForApp()) SWIG_fail;
6022 PyThreadState* __tstate = wxPyBeginAllowThreads();
6023 result = (wxWindow *)wxGetActiveWindow();
6024
6025 wxPyEndAllowThreads(__tstate);
6026 if (PyErr_Occurred()) SWIG_fail;
6027 }
6028 {
6029 resultobj = wxPyMake_wxObject(result, 0);
6030 }
6031 return resultobj;
6032 fail:
6033 return NULL;
6034 }
6035
6036
6037 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6038 PyObject *resultobj = NULL;
6039 wxPoint *arg1 = 0 ;
6040 wxWindow *result;
6041 wxPoint temp1 ;
6042 PyObject * obj0 = 0 ;
6043 char *kwnames[] = {
6044 (char *) "pt", NULL
6045 };
6046
6047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
6048 {
6049 arg1 = &temp1;
6050 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6051 }
6052 {
6053 if (!wxPyCheckForApp()) SWIG_fail;
6054 PyThreadState* __tstate = wxPyBeginAllowThreads();
6055 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6056
6057 wxPyEndAllowThreads(__tstate);
6058 if (PyErr_Occurred()) SWIG_fail;
6059 }
6060 {
6061 resultobj = wxPyMake_wxObject(result, 0);
6062 }
6063 return resultobj;
6064 fail:
6065 return NULL;
6066 }
6067
6068
6069 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6070 PyObject *resultobj = NULL;
6071 wxPoint *arg1 = 0 ;
6072 wxWindow *result;
6073 wxPoint temp1 ;
6074 PyObject * obj0 = 0 ;
6075 char *kwnames[] = {
6076 (char *) "pt", NULL
6077 };
6078
6079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
6080 {
6081 arg1 = &temp1;
6082 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6083 }
6084 {
6085 if (!wxPyCheckForApp()) SWIG_fail;
6086 PyThreadState* __tstate = wxPyBeginAllowThreads();
6087 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6088
6089 wxPyEndAllowThreads(__tstate);
6090 if (PyErr_Occurred()) SWIG_fail;
6091 }
6092 {
6093 resultobj = wxPyMake_wxObject(result, 0);
6094 }
6095 return resultobj;
6096 fail:
6097 return NULL;
6098 }
6099
6100
6101 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
6102 PyObject *resultobj = NULL;
6103 wxWindow *arg1 = (wxWindow *) 0 ;
6104 wxWindow *result;
6105 PyObject * obj0 = 0 ;
6106 char *kwnames[] = {
6107 (char *) "win", NULL
6108 };
6109
6110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
6111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6112 if (SWIG_arg_fail(1)) SWIG_fail;
6113 {
6114 if (!wxPyCheckForApp()) SWIG_fail;
6115 PyThreadState* __tstate = wxPyBeginAllowThreads();
6116 result = (wxWindow *)wxGetTopLevelParent(arg1);
6117
6118 wxPyEndAllowThreads(__tstate);
6119 if (PyErr_Occurred()) SWIG_fail;
6120 }
6121 {
6122 resultobj = wxPyMake_wxObject(result, 0);
6123 }
6124 return resultobj;
6125 fail:
6126 return NULL;
6127 }
6128
6129
6130 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6131 PyObject *resultobj = NULL;
6132 wxString *arg1 = 0 ;
6133 bool result;
6134 bool temp1 = false ;
6135 PyObject * obj0 = 0 ;
6136 char *kwnames[] = {
6137 (char *) "url", NULL
6138 };
6139
6140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6141 {
6142 arg1 = wxString_in_helper(obj0);
6143 if (arg1 == NULL) SWIG_fail;
6144 temp1 = true;
6145 }
6146 {
6147 PyThreadState* __tstate = wxPyBeginAllowThreads();
6148 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6149
6150 wxPyEndAllowThreads(__tstate);
6151 if (PyErr_Occurred()) SWIG_fail;
6152 }
6153 {
6154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6155 }
6156 {
6157 if (temp1)
6158 delete arg1;
6159 }
6160 return resultobj;
6161 fail:
6162 {
6163 if (temp1)
6164 delete arg1;
6165 }
6166 return NULL;
6167 }
6168
6169
6170 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6171 PyObject *resultobj = NULL;
6172 wxKeyCode arg1 ;
6173 bool result;
6174 PyObject * obj0 = 0 ;
6175 char *kwnames[] = {
6176 (char *) "key", NULL
6177 };
6178
6179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6180 {
6181 arg1 = static_cast<wxKeyCode >(SWIG_As_int(obj0));
6182 if (SWIG_arg_fail(1)) SWIG_fail;
6183 }
6184 {
6185 if (!wxPyCheckForApp()) SWIG_fail;
6186 PyThreadState* __tstate = wxPyBeginAllowThreads();
6187 result = (bool)wxGetKeyState(arg1);
6188
6189 wxPyEndAllowThreads(__tstate);
6190 if (PyErr_Occurred()) SWIG_fail;
6191 }
6192 {
6193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6194 }
6195 return resultobj;
6196 fail:
6197 return NULL;
6198 }
6199
6200
6201 static PyObject *_wrap_new_MouseState(PyObject *, PyObject *args, PyObject *kwargs) {
6202 PyObject *resultobj = NULL;
6203 wxMouseState *result;
6204 char *kwnames[] = {
6205 NULL
6206 };
6207
6208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MouseState",kwnames)) goto fail;
6209 {
6210 PyThreadState* __tstate = wxPyBeginAllowThreads();
6211 result = (wxMouseState *)new wxMouseState();
6212
6213 wxPyEndAllowThreads(__tstate);
6214 if (PyErr_Occurred()) SWIG_fail;
6215 }
6216 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseState, 1);
6217 return resultobj;
6218 fail:
6219 return NULL;
6220 }
6221
6222
6223 static PyObject *_wrap_delete_MouseState(PyObject *, PyObject *args, PyObject *kwargs) {
6224 PyObject *resultobj = NULL;
6225 wxMouseState *arg1 = (wxMouseState *) 0 ;
6226 PyObject * obj0 = 0 ;
6227 char *kwnames[] = {
6228 (char *) "self", NULL
6229 };
6230
6231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MouseState",kwnames,&obj0)) goto fail;
6232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6233 if (SWIG_arg_fail(1)) SWIG_fail;
6234 {
6235 PyThreadState* __tstate = wxPyBeginAllowThreads();
6236 delete arg1;
6237
6238 wxPyEndAllowThreads(__tstate);
6239 if (PyErr_Occurred()) SWIG_fail;
6240 }
6241 Py_INCREF(Py_None); resultobj = Py_None;
6242 return resultobj;
6243 fail:
6244 return NULL;
6245 }
6246
6247
6248 static PyObject *_wrap_MouseState_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
6249 PyObject *resultobj = NULL;
6250 wxMouseState *arg1 = (wxMouseState *) 0 ;
6251 int result;
6252 PyObject * obj0 = 0 ;
6253 char *kwnames[] = {
6254 (char *) "self", NULL
6255 };
6256
6257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_GetX",kwnames,&obj0)) goto fail;
6258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6259 if (SWIG_arg_fail(1)) SWIG_fail;
6260 {
6261 PyThreadState* __tstate = wxPyBeginAllowThreads();
6262 result = (int)(arg1)->GetX();
6263
6264 wxPyEndAllowThreads(__tstate);
6265 if (PyErr_Occurred()) SWIG_fail;
6266 }
6267 {
6268 resultobj = SWIG_From_int(static_cast<int >(result));
6269 }
6270 return resultobj;
6271 fail:
6272 return NULL;
6273 }
6274
6275
6276 static PyObject *_wrap_MouseState_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
6277 PyObject *resultobj = NULL;
6278 wxMouseState *arg1 = (wxMouseState *) 0 ;
6279 int result;
6280 PyObject * obj0 = 0 ;
6281 char *kwnames[] = {
6282 (char *) "self", NULL
6283 };
6284
6285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_GetY",kwnames,&obj0)) goto fail;
6286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6287 if (SWIG_arg_fail(1)) SWIG_fail;
6288 {
6289 PyThreadState* __tstate = wxPyBeginAllowThreads();
6290 result = (int)(arg1)->GetY();
6291
6292 wxPyEndAllowThreads(__tstate);
6293 if (PyErr_Occurred()) SWIG_fail;
6294 }
6295 {
6296 resultobj = SWIG_From_int(static_cast<int >(result));
6297 }
6298 return resultobj;
6299 fail:
6300 return NULL;
6301 }
6302
6303
6304 static PyObject *_wrap_MouseState_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
6305 PyObject *resultobj = NULL;
6306 wxMouseState *arg1 = (wxMouseState *) 0 ;
6307 bool result;
6308 PyObject * obj0 = 0 ;
6309 char *kwnames[] = {
6310 (char *) "self", NULL
6311 };
6312
6313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_LeftDown",kwnames,&obj0)) goto fail;
6314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6315 if (SWIG_arg_fail(1)) SWIG_fail;
6316 {
6317 PyThreadState* __tstate = wxPyBeginAllowThreads();
6318 result = (bool)(arg1)->LeftDown();
6319
6320 wxPyEndAllowThreads(__tstate);
6321 if (PyErr_Occurred()) SWIG_fail;
6322 }
6323 {
6324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6325 }
6326 return resultobj;
6327 fail:
6328 return NULL;
6329 }
6330
6331
6332 static PyObject *_wrap_MouseState_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
6333 PyObject *resultobj = NULL;
6334 wxMouseState *arg1 = (wxMouseState *) 0 ;
6335 bool result;
6336 PyObject * obj0 = 0 ;
6337 char *kwnames[] = {
6338 (char *) "self", NULL
6339 };
6340
6341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_MiddleDown",kwnames,&obj0)) goto fail;
6342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6343 if (SWIG_arg_fail(1)) SWIG_fail;
6344 {
6345 PyThreadState* __tstate = wxPyBeginAllowThreads();
6346 result = (bool)(arg1)->MiddleDown();
6347
6348 wxPyEndAllowThreads(__tstate);
6349 if (PyErr_Occurred()) SWIG_fail;
6350 }
6351 {
6352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6353 }
6354 return resultobj;
6355 fail:
6356 return NULL;
6357 }
6358
6359
6360 static PyObject *_wrap_MouseState_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
6361 PyObject *resultobj = NULL;
6362 wxMouseState *arg1 = (wxMouseState *) 0 ;
6363 bool result;
6364 PyObject * obj0 = 0 ;
6365 char *kwnames[] = {
6366 (char *) "self", NULL
6367 };
6368
6369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_RightDown",kwnames,&obj0)) goto fail;
6370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6371 if (SWIG_arg_fail(1)) SWIG_fail;
6372 {
6373 PyThreadState* __tstate = wxPyBeginAllowThreads();
6374 result = (bool)(arg1)->RightDown();
6375
6376 wxPyEndAllowThreads(__tstate);
6377 if (PyErr_Occurred()) SWIG_fail;
6378 }
6379 {
6380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6381 }
6382 return resultobj;
6383 fail:
6384 return NULL;
6385 }
6386
6387
6388 static PyObject *_wrap_MouseState_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
6389 PyObject *resultobj = NULL;
6390 wxMouseState *arg1 = (wxMouseState *) 0 ;
6391 bool result;
6392 PyObject * obj0 = 0 ;
6393 char *kwnames[] = {
6394 (char *) "self", NULL
6395 };
6396
6397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_ControlDown",kwnames,&obj0)) goto fail;
6398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6399 if (SWIG_arg_fail(1)) SWIG_fail;
6400 {
6401 PyThreadState* __tstate = wxPyBeginAllowThreads();
6402 result = (bool)(arg1)->ControlDown();
6403
6404 wxPyEndAllowThreads(__tstate);
6405 if (PyErr_Occurred()) SWIG_fail;
6406 }
6407 {
6408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6409 }
6410 return resultobj;
6411 fail:
6412 return NULL;
6413 }
6414
6415
6416 static PyObject *_wrap_MouseState_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
6417 PyObject *resultobj = NULL;
6418 wxMouseState *arg1 = (wxMouseState *) 0 ;
6419 bool result;
6420 PyObject * obj0 = 0 ;
6421 char *kwnames[] = {
6422 (char *) "self", NULL
6423 };
6424
6425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_ShiftDown",kwnames,&obj0)) goto fail;
6426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6427 if (SWIG_arg_fail(1)) SWIG_fail;
6428 {
6429 PyThreadState* __tstate = wxPyBeginAllowThreads();
6430 result = (bool)(arg1)->ShiftDown();
6431
6432 wxPyEndAllowThreads(__tstate);
6433 if (PyErr_Occurred()) SWIG_fail;
6434 }
6435 {
6436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6437 }
6438 return resultobj;
6439 fail:
6440 return NULL;
6441 }
6442
6443
6444 static PyObject *_wrap_MouseState_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
6445 PyObject *resultobj = NULL;
6446 wxMouseState *arg1 = (wxMouseState *) 0 ;
6447 bool result;
6448 PyObject * obj0 = 0 ;
6449 char *kwnames[] = {
6450 (char *) "self", NULL
6451 };
6452
6453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_AltDown",kwnames,&obj0)) goto fail;
6454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6455 if (SWIG_arg_fail(1)) SWIG_fail;
6456 {
6457 PyThreadState* __tstate = wxPyBeginAllowThreads();
6458 result = (bool)(arg1)->AltDown();
6459
6460 wxPyEndAllowThreads(__tstate);
6461 if (PyErr_Occurred()) SWIG_fail;
6462 }
6463 {
6464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6465 }
6466 return resultobj;
6467 fail:
6468 return NULL;
6469 }
6470
6471
6472 static PyObject *_wrap_MouseState_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
6473 PyObject *resultobj = NULL;
6474 wxMouseState *arg1 = (wxMouseState *) 0 ;
6475 bool result;
6476 PyObject * obj0 = 0 ;
6477 char *kwnames[] = {
6478 (char *) "self", NULL
6479 };
6480
6481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_MetaDown",kwnames,&obj0)) goto fail;
6482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6483 if (SWIG_arg_fail(1)) SWIG_fail;
6484 {
6485 PyThreadState* __tstate = wxPyBeginAllowThreads();
6486 result = (bool)(arg1)->MetaDown();
6487
6488 wxPyEndAllowThreads(__tstate);
6489 if (PyErr_Occurred()) SWIG_fail;
6490 }
6491 {
6492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6493 }
6494 return resultobj;
6495 fail:
6496 return NULL;
6497 }
6498
6499
6500 static PyObject *_wrap_MouseState_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
6501 PyObject *resultobj = NULL;
6502 wxMouseState *arg1 = (wxMouseState *) 0 ;
6503 bool result;
6504 PyObject * obj0 = 0 ;
6505 char *kwnames[] = {
6506 (char *) "self", NULL
6507 };
6508
6509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_CmdDown",kwnames,&obj0)) goto fail;
6510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6511 if (SWIG_arg_fail(1)) SWIG_fail;
6512 {
6513 PyThreadState* __tstate = wxPyBeginAllowThreads();
6514 result = (bool)(arg1)->CmdDown();
6515
6516 wxPyEndAllowThreads(__tstate);
6517 if (PyErr_Occurred()) SWIG_fail;
6518 }
6519 {
6520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6521 }
6522 return resultobj;
6523 fail:
6524 return NULL;
6525 }
6526
6527
6528 static PyObject *_wrap_MouseState_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
6529 PyObject *resultobj = NULL;
6530 wxMouseState *arg1 = (wxMouseState *) 0 ;
6531 int arg2 ;
6532 PyObject * obj0 = 0 ;
6533 PyObject * obj1 = 0 ;
6534 char *kwnames[] = {
6535 (char *) "self",(char *) "x", NULL
6536 };
6537
6538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) goto fail;
6539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6540 if (SWIG_arg_fail(1)) SWIG_fail;
6541 {
6542 arg2 = static_cast<int >(SWIG_As_int(obj1));
6543 if (SWIG_arg_fail(2)) SWIG_fail;
6544 }
6545 {
6546 PyThreadState* __tstate = wxPyBeginAllowThreads();
6547 (arg1)->SetX(arg2);
6548
6549 wxPyEndAllowThreads(__tstate);
6550 if (PyErr_Occurred()) SWIG_fail;
6551 }
6552 Py_INCREF(Py_None); resultobj = Py_None;
6553 return resultobj;
6554 fail:
6555 return NULL;
6556 }
6557
6558
6559 static PyObject *_wrap_MouseState_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
6560 PyObject *resultobj = NULL;
6561 wxMouseState *arg1 = (wxMouseState *) 0 ;
6562 int arg2 ;
6563 PyObject * obj0 = 0 ;
6564 PyObject * obj1 = 0 ;
6565 char *kwnames[] = {
6566 (char *) "self",(char *) "y", NULL
6567 };
6568
6569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) goto fail;
6570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6571 if (SWIG_arg_fail(1)) SWIG_fail;
6572 {
6573 arg2 = static_cast<int >(SWIG_As_int(obj1));
6574 if (SWIG_arg_fail(2)) SWIG_fail;
6575 }
6576 {
6577 PyThreadState* __tstate = wxPyBeginAllowThreads();
6578 (arg1)->SetY(arg2);
6579
6580 wxPyEndAllowThreads(__tstate);
6581 if (PyErr_Occurred()) SWIG_fail;
6582 }
6583 Py_INCREF(Py_None); resultobj = Py_None;
6584 return resultobj;
6585 fail:
6586 return NULL;
6587 }
6588
6589
6590 static PyObject *_wrap_MouseState_SetLeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
6591 PyObject *resultobj = NULL;
6592 wxMouseState *arg1 = (wxMouseState *) 0 ;
6593 bool arg2 ;
6594 PyObject * obj0 = 0 ;
6595 PyObject * obj1 = 0 ;
6596 char *kwnames[] = {
6597 (char *) "self",(char *) "down", NULL
6598 };
6599
6600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) goto fail;
6601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6602 if (SWIG_arg_fail(1)) SWIG_fail;
6603 {
6604 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6605 if (SWIG_arg_fail(2)) SWIG_fail;
6606 }
6607 {
6608 PyThreadState* __tstate = wxPyBeginAllowThreads();
6609 (arg1)->SetLeftDown(arg2);
6610
6611 wxPyEndAllowThreads(__tstate);
6612 if (PyErr_Occurred()) SWIG_fail;
6613 }
6614 Py_INCREF(Py_None); resultobj = Py_None;
6615 return resultobj;
6616 fail:
6617 return NULL;
6618 }
6619
6620
6621 static PyObject *_wrap_MouseState_SetMiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
6622 PyObject *resultobj = NULL;
6623 wxMouseState *arg1 = (wxMouseState *) 0 ;
6624 bool arg2 ;
6625 PyObject * obj0 = 0 ;
6626 PyObject * obj1 = 0 ;
6627 char *kwnames[] = {
6628 (char *) "self",(char *) "down", NULL
6629 };
6630
6631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) goto fail;
6632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6633 if (SWIG_arg_fail(1)) SWIG_fail;
6634 {
6635 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6636 if (SWIG_arg_fail(2)) SWIG_fail;
6637 }
6638 {
6639 PyThreadState* __tstate = wxPyBeginAllowThreads();
6640 (arg1)->SetMiddleDown(arg2);
6641
6642 wxPyEndAllowThreads(__tstate);
6643 if (PyErr_Occurred()) SWIG_fail;
6644 }
6645 Py_INCREF(Py_None); resultobj = Py_None;
6646 return resultobj;
6647 fail:
6648 return NULL;
6649 }
6650
6651
6652 static PyObject *_wrap_MouseState_SetRightDown(PyObject *, PyObject *args, PyObject *kwargs) {
6653 PyObject *resultobj = NULL;
6654 wxMouseState *arg1 = (wxMouseState *) 0 ;
6655 bool arg2 ;
6656 PyObject * obj0 = 0 ;
6657 PyObject * obj1 = 0 ;
6658 char *kwnames[] = {
6659 (char *) "self",(char *) "down", NULL
6660 };
6661
6662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) goto fail;
6663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6664 if (SWIG_arg_fail(1)) SWIG_fail;
6665 {
6666 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6667 if (SWIG_arg_fail(2)) SWIG_fail;
6668 }
6669 {
6670 PyThreadState* __tstate = wxPyBeginAllowThreads();
6671 (arg1)->SetRightDown(arg2);
6672
6673 wxPyEndAllowThreads(__tstate);
6674 if (PyErr_Occurred()) SWIG_fail;
6675 }
6676 Py_INCREF(Py_None); resultobj = Py_None;
6677 return resultobj;
6678 fail:
6679 return NULL;
6680 }
6681
6682
6683 static PyObject *_wrap_MouseState_SetControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
6684 PyObject *resultobj = NULL;
6685 wxMouseState *arg1 = (wxMouseState *) 0 ;
6686 bool arg2 ;
6687 PyObject * obj0 = 0 ;
6688 PyObject * obj1 = 0 ;
6689 char *kwnames[] = {
6690 (char *) "self",(char *) "down", NULL
6691 };
6692
6693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) goto fail;
6694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6695 if (SWIG_arg_fail(1)) SWIG_fail;
6696 {
6697 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6698 if (SWIG_arg_fail(2)) SWIG_fail;
6699 }
6700 {
6701 PyThreadState* __tstate = wxPyBeginAllowThreads();
6702 (arg1)->SetControlDown(arg2);
6703
6704 wxPyEndAllowThreads(__tstate);
6705 if (PyErr_Occurred()) SWIG_fail;
6706 }
6707 Py_INCREF(Py_None); resultobj = Py_None;
6708 return resultobj;
6709 fail:
6710 return NULL;
6711 }
6712
6713
6714 static PyObject *_wrap_MouseState_SetShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
6715 PyObject *resultobj = NULL;
6716 wxMouseState *arg1 = (wxMouseState *) 0 ;
6717 bool arg2 ;
6718 PyObject * obj0 = 0 ;
6719 PyObject * obj1 = 0 ;
6720 char *kwnames[] = {
6721 (char *) "self",(char *) "down", NULL
6722 };
6723
6724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) goto fail;
6725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6726 if (SWIG_arg_fail(1)) SWIG_fail;
6727 {
6728 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6729 if (SWIG_arg_fail(2)) SWIG_fail;
6730 }
6731 {
6732 PyThreadState* __tstate = wxPyBeginAllowThreads();
6733 (arg1)->SetShiftDown(arg2);
6734
6735 wxPyEndAllowThreads(__tstate);
6736 if (PyErr_Occurred()) SWIG_fail;
6737 }
6738 Py_INCREF(Py_None); resultobj = Py_None;
6739 return resultobj;
6740 fail:
6741 return NULL;
6742 }
6743
6744
6745 static PyObject *_wrap_MouseState_SetAltDown(PyObject *, PyObject *args, PyObject *kwargs) {
6746 PyObject *resultobj = NULL;
6747 wxMouseState *arg1 = (wxMouseState *) 0 ;
6748 bool arg2 ;
6749 PyObject * obj0 = 0 ;
6750 PyObject * obj1 = 0 ;
6751 char *kwnames[] = {
6752 (char *) "self",(char *) "down", NULL
6753 };
6754
6755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) goto fail;
6756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6757 if (SWIG_arg_fail(1)) SWIG_fail;
6758 {
6759 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6760 if (SWIG_arg_fail(2)) SWIG_fail;
6761 }
6762 {
6763 PyThreadState* __tstate = wxPyBeginAllowThreads();
6764 (arg1)->SetAltDown(arg2);
6765
6766 wxPyEndAllowThreads(__tstate);
6767 if (PyErr_Occurred()) SWIG_fail;
6768 }
6769 Py_INCREF(Py_None); resultobj = Py_None;
6770 return resultobj;
6771 fail:
6772 return NULL;
6773 }
6774
6775
6776 static PyObject *_wrap_MouseState_SetMetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
6777 PyObject *resultobj = NULL;
6778 wxMouseState *arg1 = (wxMouseState *) 0 ;
6779 bool arg2 ;
6780 PyObject * obj0 = 0 ;
6781 PyObject * obj1 = 0 ;
6782 char *kwnames[] = {
6783 (char *) "self",(char *) "down", NULL
6784 };
6785
6786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) goto fail;
6787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6788 if (SWIG_arg_fail(1)) SWIG_fail;
6789 {
6790 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6791 if (SWIG_arg_fail(2)) SWIG_fail;
6792 }
6793 {
6794 PyThreadState* __tstate = wxPyBeginAllowThreads();
6795 (arg1)->SetMetaDown(arg2);
6796
6797 wxPyEndAllowThreads(__tstate);
6798 if (PyErr_Occurred()) SWIG_fail;
6799 }
6800 Py_INCREF(Py_None); resultobj = Py_None;
6801 return resultobj;
6802 fail:
6803 return NULL;
6804 }
6805
6806
6807 static PyObject * MouseState_swigregister(PyObject *, PyObject *args) {
6808 PyObject *obj;
6809 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6810 SWIG_TypeClientData(SWIGTYPE_p_wxMouseState, obj);
6811 Py_INCREF(obj);
6812 return Py_BuildValue((char *)"");
6813 }
6814 static PyObject *_wrap_GetMouseState(PyObject *, PyObject *args, PyObject *kwargs) {
6815 PyObject *resultobj = NULL;
6816 wxMouseState result;
6817 char *kwnames[] = {
6818 NULL
6819 };
6820
6821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMouseState",kwnames)) goto fail;
6822 {
6823 PyThreadState* __tstate = wxPyBeginAllowThreads();
6824 result = wxGetMouseState();
6825
6826 wxPyEndAllowThreads(__tstate);
6827 if (PyErr_Occurred()) SWIG_fail;
6828 }
6829 {
6830 wxMouseState * resultptr;
6831 resultptr = new wxMouseState(static_cast<wxMouseState & >(result));
6832 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMouseState, 1);
6833 }
6834 return resultobj;
6835 fail:
6836 return NULL;
6837 }
6838
6839
6840 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6841 PyObject *resultobj = NULL;
6842 char *kwnames[] = {
6843 NULL
6844 };
6845
6846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6847 {
6848 if (!wxPyCheckForApp()) SWIG_fail;
6849 PyThreadState* __tstate = wxPyBeginAllowThreads();
6850 wxWakeUpMainThread();
6851
6852 wxPyEndAllowThreads(__tstate);
6853 if (PyErr_Occurred()) SWIG_fail;
6854 }
6855 Py_INCREF(Py_None); resultobj = Py_None;
6856 return resultobj;
6857 fail:
6858 return NULL;
6859 }
6860
6861
6862 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6863 PyObject *resultobj = NULL;
6864 char *kwnames[] = {
6865 NULL
6866 };
6867
6868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6869 {
6870 if (!wxPyCheckForApp()) SWIG_fail;
6871 PyThreadState* __tstate = wxPyBeginAllowThreads();
6872 wxMutexGuiEnter();
6873
6874 wxPyEndAllowThreads(__tstate);
6875 if (PyErr_Occurred()) SWIG_fail;
6876 }
6877 Py_INCREF(Py_None); resultobj = Py_None;
6878 return resultobj;
6879 fail:
6880 return NULL;
6881 }
6882
6883
6884 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6885 PyObject *resultobj = NULL;
6886 char *kwnames[] = {
6887 NULL
6888 };
6889
6890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6891 {
6892 if (!wxPyCheckForApp()) SWIG_fail;
6893 PyThreadState* __tstate = wxPyBeginAllowThreads();
6894 wxMutexGuiLeave();
6895
6896 wxPyEndAllowThreads(__tstate);
6897 if (PyErr_Occurred()) SWIG_fail;
6898 }
6899 Py_INCREF(Py_None); resultobj = Py_None;
6900 return resultobj;
6901 fail:
6902 return NULL;
6903 }
6904
6905
6906 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6907 PyObject *resultobj = NULL;
6908 wxMutexGuiLocker *result;
6909 char *kwnames[] = {
6910 NULL
6911 };
6912
6913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6914 {
6915 if (!wxPyCheckForApp()) SWIG_fail;
6916 PyThreadState* __tstate = wxPyBeginAllowThreads();
6917 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6918
6919 wxPyEndAllowThreads(__tstate);
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6923 return resultobj;
6924 fail:
6925 return NULL;
6926 }
6927
6928
6929 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6930 PyObject *resultobj = NULL;
6931 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6932 PyObject * obj0 = 0 ;
6933 char *kwnames[] = {
6934 (char *) "self", NULL
6935 };
6936
6937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6939 if (SWIG_arg_fail(1)) SWIG_fail;
6940 {
6941 PyThreadState* __tstate = wxPyBeginAllowThreads();
6942 delete arg1;
6943
6944 wxPyEndAllowThreads(__tstate);
6945 if (PyErr_Occurred()) SWIG_fail;
6946 }
6947 Py_INCREF(Py_None); resultobj = Py_None;
6948 return resultobj;
6949 fail:
6950 return NULL;
6951 }
6952
6953
6954 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6955 PyObject *obj;
6956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6957 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6958 Py_INCREF(obj);
6959 return Py_BuildValue((char *)"");
6960 }
6961 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6962 PyObject *resultobj = NULL;
6963 bool result;
6964 char *kwnames[] = {
6965 NULL
6966 };
6967
6968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6969 {
6970 PyThreadState* __tstate = wxPyBeginAllowThreads();
6971 result = (bool)wxThread_IsMain();
6972
6973 wxPyEndAllowThreads(__tstate);
6974 if (PyErr_Occurred()) SWIG_fail;
6975 }
6976 {
6977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6978 }
6979 return resultobj;
6980 fail:
6981 return NULL;
6982 }
6983
6984
6985 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6986 PyObject *resultobj = NULL;
6987 wxString *arg1 = 0 ;
6988 wxToolTip *result;
6989 bool temp1 = false ;
6990 PyObject * obj0 = 0 ;
6991 char *kwnames[] = {
6992 (char *) "tip", NULL
6993 };
6994
6995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6996 {
6997 arg1 = wxString_in_helper(obj0);
6998 if (arg1 == NULL) SWIG_fail;
6999 temp1 = true;
7000 }
7001 {
7002 if (!wxPyCheckForApp()) SWIG_fail;
7003 PyThreadState* __tstate = wxPyBeginAllowThreads();
7004 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7005
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxToolTip, 1);
7010 {
7011 if (temp1)
7012 delete arg1;
7013 }
7014 return resultobj;
7015 fail:
7016 {
7017 if (temp1)
7018 delete arg1;
7019 }
7020 return NULL;
7021 }
7022
7023
7024 static PyObject *_wrap_delete_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
7025 PyObject *resultobj = NULL;
7026 wxToolTip *arg1 = (wxToolTip *) 0 ;
7027 PyObject * obj0 = 0 ;
7028 char *kwnames[] = {
7029 (char *) "self", NULL
7030 };
7031
7032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ToolTip",kwnames,&obj0)) goto fail;
7033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
7034 if (SWIG_arg_fail(1)) SWIG_fail;
7035 {
7036 PyThreadState* __tstate = wxPyBeginAllowThreads();
7037 delete arg1;
7038
7039 wxPyEndAllowThreads(__tstate);
7040 if (PyErr_Occurred()) SWIG_fail;
7041 }
7042 Py_INCREF(Py_None); resultobj = Py_None;
7043 return resultobj;
7044 fail:
7045 return NULL;
7046 }
7047
7048
7049 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7050 PyObject *resultobj = NULL;
7051 wxToolTip *arg1 = (wxToolTip *) 0 ;
7052 wxString *arg2 = 0 ;
7053 bool temp2 = false ;
7054 PyObject * obj0 = 0 ;
7055 PyObject * obj1 = 0 ;
7056 char *kwnames[] = {
7057 (char *) "self",(char *) "tip", NULL
7058 };
7059
7060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
7061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
7062 if (SWIG_arg_fail(1)) SWIG_fail;
7063 {
7064 arg2 = wxString_in_helper(obj1);
7065 if (arg2 == NULL) SWIG_fail;
7066 temp2 = true;
7067 }
7068 {
7069 PyThreadState* __tstate = wxPyBeginAllowThreads();
7070 (arg1)->SetTip((wxString const &)*arg2);
7071
7072 wxPyEndAllowThreads(__tstate);
7073 if (PyErr_Occurred()) SWIG_fail;
7074 }
7075 Py_INCREF(Py_None); resultobj = Py_None;
7076 {
7077 if (temp2)
7078 delete arg2;
7079 }
7080 return resultobj;
7081 fail:
7082 {
7083 if (temp2)
7084 delete arg2;
7085 }
7086 return NULL;
7087 }
7088
7089
7090 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7091 PyObject *resultobj = NULL;
7092 wxToolTip *arg1 = (wxToolTip *) 0 ;
7093 wxString result;
7094 PyObject * obj0 = 0 ;
7095 char *kwnames[] = {
7096 (char *) "self", NULL
7097 };
7098
7099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
7100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
7101 if (SWIG_arg_fail(1)) SWIG_fail;
7102 {
7103 PyThreadState* __tstate = wxPyBeginAllowThreads();
7104 result = (arg1)->GetTip();
7105
7106 wxPyEndAllowThreads(__tstate);
7107 if (PyErr_Occurred()) SWIG_fail;
7108 }
7109 {
7110 #if wxUSE_UNICODE
7111 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7112 #else
7113 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7114 #endif
7115 }
7116 return resultobj;
7117 fail:
7118 return NULL;
7119 }
7120
7121
7122 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7123 PyObject *resultobj = NULL;
7124 wxToolTip *arg1 = (wxToolTip *) 0 ;
7125 wxWindow *result;
7126 PyObject * obj0 = 0 ;
7127 char *kwnames[] = {
7128 (char *) "self", NULL
7129 };
7130
7131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
7132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
7133 if (SWIG_arg_fail(1)) SWIG_fail;
7134 {
7135 PyThreadState* __tstate = wxPyBeginAllowThreads();
7136 result = (wxWindow *)(arg1)->GetWindow();
7137
7138 wxPyEndAllowThreads(__tstate);
7139 if (PyErr_Occurred()) SWIG_fail;
7140 }
7141 {
7142 resultobj = wxPyMake_wxObject(result, 0);
7143 }
7144 return resultobj;
7145 fail:
7146 return NULL;
7147 }
7148
7149
7150 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
7151 PyObject *resultobj = NULL;
7152 bool arg1 ;
7153 PyObject * obj0 = 0 ;
7154 char *kwnames[] = {
7155 (char *) "flag", NULL
7156 };
7157
7158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
7159 {
7160 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
7161 if (SWIG_arg_fail(1)) SWIG_fail;
7162 }
7163 {
7164 PyThreadState* __tstate = wxPyBeginAllowThreads();
7165 wxToolTip::Enable(arg1);
7166
7167 wxPyEndAllowThreads(__tstate);
7168 if (PyErr_Occurred()) SWIG_fail;
7169 }
7170 Py_INCREF(Py_None); resultobj = Py_None;
7171 return resultobj;
7172 fail:
7173 return NULL;
7174 }
7175
7176
7177 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
7178 PyObject *resultobj = NULL;
7179 long arg1 ;
7180 PyObject * obj0 = 0 ;
7181 char *kwnames[] = {
7182 (char *) "milliseconds", NULL
7183 };
7184
7185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
7186 {
7187 arg1 = static_cast<long >(SWIG_As_long(obj0));
7188 if (SWIG_arg_fail(1)) SWIG_fail;
7189 }
7190 {
7191 PyThreadState* __tstate = wxPyBeginAllowThreads();
7192 wxToolTip::SetDelay(arg1);
7193
7194 wxPyEndAllowThreads(__tstate);
7195 if (PyErr_Occurred()) SWIG_fail;
7196 }
7197 Py_INCREF(Py_None); resultobj = Py_None;
7198 return resultobj;
7199 fail:
7200 return NULL;
7201 }
7202
7203
7204 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
7205 PyObject *obj;
7206 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7207 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
7208 Py_INCREF(obj);
7209 return Py_BuildValue((char *)"");
7210 }
7211 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
7212 PyObject *resultobj = NULL;
7213 wxWindow *arg1 = (wxWindow *) 0 ;
7214 wxSize *arg2 = 0 ;
7215 wxCaret *result;
7216 wxSize temp2 ;
7217 PyObject * obj0 = 0 ;
7218 PyObject * obj1 = 0 ;
7219 char *kwnames[] = {
7220 (char *) "window",(char *) "size", NULL
7221 };
7222
7223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
7224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7225 if (SWIG_arg_fail(1)) SWIG_fail;
7226 {
7227 arg2 = &temp2;
7228 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
7229 }
7230 {
7231 if (!wxPyCheckForApp()) SWIG_fail;
7232 PyThreadState* __tstate = wxPyBeginAllowThreads();
7233 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
7234
7235 wxPyEndAllowThreads(__tstate);
7236 if (PyErr_Occurred()) SWIG_fail;
7237 }
7238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
7239 return resultobj;
7240 fail:
7241 return NULL;
7242 }
7243
7244
7245 static PyObject *_wrap_delete_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
7246 PyObject *resultobj = NULL;
7247 wxCaret *arg1 = (wxCaret *) 0 ;
7248 PyObject * obj0 = 0 ;
7249 char *kwnames[] = {
7250 (char *) "self", NULL
7251 };
7252
7253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Caret",kwnames,&obj0)) goto fail;
7254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7255 if (SWIG_arg_fail(1)) SWIG_fail;
7256 {
7257 PyThreadState* __tstate = wxPyBeginAllowThreads();
7258 delete arg1;
7259
7260 wxPyEndAllowThreads(__tstate);
7261 if (PyErr_Occurred()) SWIG_fail;
7262 }
7263 Py_INCREF(Py_None); resultobj = Py_None;
7264 return resultobj;
7265 fail:
7266 return NULL;
7267 }
7268
7269
7270 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
7271 PyObject *resultobj = NULL;
7272 wxCaret *arg1 = (wxCaret *) 0 ;
7273 PyObject * obj0 = 0 ;
7274 char *kwnames[] = {
7275 (char *) "self", NULL
7276 };
7277
7278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
7279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7280 if (SWIG_arg_fail(1)) SWIG_fail;
7281 {
7282 PyThreadState* __tstate = wxPyBeginAllowThreads();
7283 wxCaret_Destroy(arg1);
7284
7285 wxPyEndAllowThreads(__tstate);
7286 if (PyErr_Occurred()) SWIG_fail;
7287 }
7288 Py_INCREF(Py_None); resultobj = Py_None;
7289 return resultobj;
7290 fail:
7291 return NULL;
7292 }
7293
7294
7295 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
7296 PyObject *resultobj = NULL;
7297 wxCaret *arg1 = (wxCaret *) 0 ;
7298 bool result;
7299 PyObject * obj0 = 0 ;
7300 char *kwnames[] = {
7301 (char *) "self", NULL
7302 };
7303
7304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
7305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7306 if (SWIG_arg_fail(1)) SWIG_fail;
7307 {
7308 PyThreadState* __tstate = wxPyBeginAllowThreads();
7309 result = (bool)(arg1)->IsOk();
7310
7311 wxPyEndAllowThreads(__tstate);
7312 if (PyErr_Occurred()) SWIG_fail;
7313 }
7314 {
7315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7316 }
7317 return resultobj;
7318 fail:
7319 return NULL;
7320 }
7321
7322
7323 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
7324 PyObject *resultobj = NULL;
7325 wxCaret *arg1 = (wxCaret *) 0 ;
7326 bool result;
7327 PyObject * obj0 = 0 ;
7328 char *kwnames[] = {
7329 (char *) "self", NULL
7330 };
7331
7332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
7333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7334 if (SWIG_arg_fail(1)) SWIG_fail;
7335 {
7336 PyThreadState* __tstate = wxPyBeginAllowThreads();
7337 result = (bool)(arg1)->IsVisible();
7338
7339 wxPyEndAllowThreads(__tstate);
7340 if (PyErr_Occurred()) SWIG_fail;
7341 }
7342 {
7343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7344 }
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj = NULL;
7353 wxCaret *arg1 = (wxCaret *) 0 ;
7354 wxPoint result;
7355 PyObject * obj0 = 0 ;
7356 char *kwnames[] = {
7357 (char *) "self", NULL
7358 };
7359
7360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
7361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7362 if (SWIG_arg_fail(1)) SWIG_fail;
7363 {
7364 PyThreadState* __tstate = wxPyBeginAllowThreads();
7365 result = (arg1)->GetPosition();
7366
7367 wxPyEndAllowThreads(__tstate);
7368 if (PyErr_Occurred()) SWIG_fail;
7369 }
7370 {
7371 wxPoint * resultptr;
7372 resultptr = new wxPoint(static_cast<wxPoint & >(result));
7373 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
7374 }
7375 return resultobj;
7376 fail:
7377 return NULL;
7378 }
7379
7380
7381 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
7382 PyObject *resultobj = NULL;
7383 wxCaret *arg1 = (wxCaret *) 0 ;
7384 int *arg2 = (int *) 0 ;
7385 int *arg3 = (int *) 0 ;
7386 int temp2 ;
7387 int res2 = 0 ;
7388 int temp3 ;
7389 int res3 = 0 ;
7390 PyObject * obj0 = 0 ;
7391 char *kwnames[] = {
7392 (char *) "self", NULL
7393 };
7394
7395 arg2 = &temp2; res2 = SWIG_NEWOBJ;
7396 arg3 = &temp3; res3 = SWIG_NEWOBJ;
7397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
7398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7399 if (SWIG_arg_fail(1)) SWIG_fail;
7400 {
7401 PyThreadState* __tstate = wxPyBeginAllowThreads();
7402 (arg1)->GetPosition(arg2,arg3);
7403
7404 wxPyEndAllowThreads(__tstate);
7405 if (PyErr_Occurred()) SWIG_fail;
7406 }
7407 Py_INCREF(Py_None); resultobj = Py_None;
7408 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
7409 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
7410 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
7411 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
7412 return resultobj;
7413 fail:
7414 return NULL;
7415 }
7416
7417
7418 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
7419 PyObject *resultobj = NULL;
7420 wxCaret *arg1 = (wxCaret *) 0 ;
7421 wxSize result;
7422 PyObject * obj0 = 0 ;
7423 char *kwnames[] = {
7424 (char *) "self", NULL
7425 };
7426
7427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
7428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7429 if (SWIG_arg_fail(1)) SWIG_fail;
7430 {
7431 PyThreadState* __tstate = wxPyBeginAllowThreads();
7432 result = (arg1)->GetSize();
7433
7434 wxPyEndAllowThreads(__tstate);
7435 if (PyErr_Occurred()) SWIG_fail;
7436 }
7437 {
7438 wxSize * resultptr;
7439 resultptr = new wxSize(static_cast<wxSize & >(result));
7440 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
7441 }
7442 return resultobj;
7443 fail:
7444 return NULL;
7445 }
7446
7447
7448 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
7449 PyObject *resultobj = NULL;
7450 wxCaret *arg1 = (wxCaret *) 0 ;
7451 int *arg2 = (int *) 0 ;
7452 int *arg3 = (int *) 0 ;
7453 int temp2 ;
7454 int res2 = 0 ;
7455 int temp3 ;
7456 int res3 = 0 ;
7457 PyObject * obj0 = 0 ;
7458 char *kwnames[] = {
7459 (char *) "self", NULL
7460 };
7461
7462 arg2 = &temp2; res2 = SWIG_NEWOBJ;
7463 arg3 = &temp3; res3 = SWIG_NEWOBJ;
7464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
7465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7466 if (SWIG_arg_fail(1)) SWIG_fail;
7467 {
7468 PyThreadState* __tstate = wxPyBeginAllowThreads();
7469 (arg1)->GetSize(arg2,arg3);
7470
7471 wxPyEndAllowThreads(__tstate);
7472 if (PyErr_Occurred()) SWIG_fail;
7473 }
7474 Py_INCREF(Py_None); resultobj = Py_None;
7475 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
7476 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
7477 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
7478 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
7479 return resultobj;
7480 fail:
7481 return NULL;
7482 }
7483
7484
7485 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7486 PyObject *resultobj = NULL;
7487 wxCaret *arg1 = (wxCaret *) 0 ;
7488 wxWindow *result;
7489 PyObject * obj0 = 0 ;
7490 char *kwnames[] = {
7491 (char *) "self", NULL
7492 };
7493
7494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
7495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7496 if (SWIG_arg_fail(1)) SWIG_fail;
7497 {
7498 PyThreadState* __tstate = wxPyBeginAllowThreads();
7499 result = (wxWindow *)(arg1)->GetWindow();
7500
7501 wxPyEndAllowThreads(__tstate);
7502 if (PyErr_Occurred()) SWIG_fail;
7503 }
7504 {
7505 resultobj = wxPyMake_wxObject(result, 0);
7506 }
7507 return resultobj;
7508 fail:
7509 return NULL;
7510 }
7511
7512
7513 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
7514 PyObject *resultobj = NULL;
7515 wxCaret *arg1 = (wxCaret *) 0 ;
7516 int arg2 ;
7517 int arg3 ;
7518 PyObject * obj0 = 0 ;
7519 PyObject * obj1 = 0 ;
7520 PyObject * obj2 = 0 ;
7521 char *kwnames[] = {
7522 (char *) "self",(char *) "x",(char *) "y", NULL
7523 };
7524
7525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
7526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7527 if (SWIG_arg_fail(1)) SWIG_fail;
7528 {
7529 arg2 = static_cast<int >(SWIG_As_int(obj1));
7530 if (SWIG_arg_fail(2)) SWIG_fail;
7531 }
7532 {
7533 arg3 = static_cast<int >(SWIG_As_int(obj2));
7534 if (SWIG_arg_fail(3)) SWIG_fail;
7535 }
7536 {
7537 PyThreadState* __tstate = wxPyBeginAllowThreads();
7538 (arg1)->Move(arg2,arg3);
7539
7540 wxPyEndAllowThreads(__tstate);
7541 if (PyErr_Occurred()) SWIG_fail;
7542 }
7543 Py_INCREF(Py_None); resultobj = Py_None;
7544 return resultobj;
7545 fail:
7546 return NULL;
7547 }
7548
7549
7550 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
7551 PyObject *resultobj = NULL;
7552 wxCaret *arg1 = (wxCaret *) 0 ;
7553 wxPoint *arg2 = 0 ;
7554 wxPoint temp2 ;
7555 PyObject * obj0 = 0 ;
7556 PyObject * obj1 = 0 ;
7557 char *kwnames[] = {
7558 (char *) "self",(char *) "pt", NULL
7559 };
7560
7561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
7562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7563 if (SWIG_arg_fail(1)) SWIG_fail;
7564 {
7565 arg2 = &temp2;
7566 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7567 }
7568 {
7569 PyThreadState* __tstate = wxPyBeginAllowThreads();
7570 (arg1)->Move((wxPoint const &)*arg2);
7571
7572 wxPyEndAllowThreads(__tstate);
7573 if (PyErr_Occurred()) SWIG_fail;
7574 }
7575 Py_INCREF(Py_None); resultobj = Py_None;
7576 return resultobj;
7577 fail:
7578 return NULL;
7579 }
7580
7581
7582 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
7583 PyObject *resultobj = NULL;
7584 wxCaret *arg1 = (wxCaret *) 0 ;
7585 int arg2 ;
7586 int arg3 ;
7587 PyObject * obj0 = 0 ;
7588 PyObject * obj1 = 0 ;
7589 PyObject * obj2 = 0 ;
7590 char *kwnames[] = {
7591 (char *) "self",(char *) "width",(char *) "height", NULL
7592 };
7593
7594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
7595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7596 if (SWIG_arg_fail(1)) SWIG_fail;
7597 {
7598 arg2 = static_cast<int >(SWIG_As_int(obj1));
7599 if (SWIG_arg_fail(2)) SWIG_fail;
7600 }
7601 {
7602 arg3 = static_cast<int >(SWIG_As_int(obj2));
7603 if (SWIG_arg_fail(3)) SWIG_fail;
7604 }
7605 {
7606 PyThreadState* __tstate = wxPyBeginAllowThreads();
7607 (arg1)->SetSize(arg2,arg3);
7608
7609 wxPyEndAllowThreads(__tstate);
7610 if (PyErr_Occurred()) SWIG_fail;
7611 }
7612 Py_INCREF(Py_None); resultobj = Py_None;
7613 return resultobj;
7614 fail:
7615 return NULL;
7616 }
7617
7618
7619 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
7620 PyObject *resultobj = NULL;
7621 wxCaret *arg1 = (wxCaret *) 0 ;
7622 wxSize *arg2 = 0 ;
7623 wxSize temp2 ;
7624 PyObject * obj0 = 0 ;
7625 PyObject * obj1 = 0 ;
7626 char *kwnames[] = {
7627 (char *) "self",(char *) "size", NULL
7628 };
7629
7630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
7631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7632 if (SWIG_arg_fail(1)) SWIG_fail;
7633 {
7634 arg2 = &temp2;
7635 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
7636 }
7637 {
7638 PyThreadState* __tstate = wxPyBeginAllowThreads();
7639 (arg1)->SetSize((wxSize const &)*arg2);
7640
7641 wxPyEndAllowThreads(__tstate);
7642 if (PyErr_Occurred()) SWIG_fail;
7643 }
7644 Py_INCREF(Py_None); resultobj = Py_None;
7645 return resultobj;
7646 fail:
7647 return NULL;
7648 }
7649
7650
7651 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
7652 PyObject *resultobj = NULL;
7653 wxCaret *arg1 = (wxCaret *) 0 ;
7654 int arg2 = (int) true ;
7655 PyObject * obj0 = 0 ;
7656 PyObject * obj1 = 0 ;
7657 char *kwnames[] = {
7658 (char *) "self",(char *) "show", NULL
7659 };
7660
7661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
7662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7663 if (SWIG_arg_fail(1)) SWIG_fail;
7664 if (obj1) {
7665 {
7666 arg2 = static_cast<int >(SWIG_As_int(obj1));
7667 if (SWIG_arg_fail(2)) SWIG_fail;
7668 }
7669 }
7670 {
7671 PyThreadState* __tstate = wxPyBeginAllowThreads();
7672 (arg1)->Show(arg2);
7673
7674 wxPyEndAllowThreads(__tstate);
7675 if (PyErr_Occurred()) SWIG_fail;
7676 }
7677 Py_INCREF(Py_None); resultobj = Py_None;
7678 return resultobj;
7679 fail:
7680 return NULL;
7681 }
7682
7683
7684 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
7685 PyObject *resultobj = NULL;
7686 wxCaret *arg1 = (wxCaret *) 0 ;
7687 PyObject * obj0 = 0 ;
7688 char *kwnames[] = {
7689 (char *) "self", NULL
7690 };
7691
7692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
7693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7694 if (SWIG_arg_fail(1)) SWIG_fail;
7695 {
7696 PyThreadState* __tstate = wxPyBeginAllowThreads();
7697 (arg1)->Hide();
7698
7699 wxPyEndAllowThreads(__tstate);
7700 if (PyErr_Occurred()) SWIG_fail;
7701 }
7702 Py_INCREF(Py_None); resultobj = Py_None;
7703 return resultobj;
7704 fail:
7705 return NULL;
7706 }
7707
7708
7709 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
7710 PyObject *resultobj = NULL;
7711 int result;
7712 char *kwnames[] = {
7713 NULL
7714 };
7715
7716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
7717 {
7718 PyThreadState* __tstate = wxPyBeginAllowThreads();
7719 result = (int)wxCaret::GetBlinkTime();
7720
7721 wxPyEndAllowThreads(__tstate);
7722 if (PyErr_Occurred()) SWIG_fail;
7723 }
7724 {
7725 resultobj = SWIG_From_int(static_cast<int >(result));
7726 }
7727 return resultobj;
7728 fail:
7729 return NULL;
7730 }
7731
7732
7733 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
7734 PyObject *resultobj = NULL;
7735 int arg1 ;
7736 PyObject * obj0 = 0 ;
7737 char *kwnames[] = {
7738 (char *) "milliseconds", NULL
7739 };
7740
7741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
7742 {
7743 arg1 = static_cast<int >(SWIG_As_int(obj0));
7744 if (SWIG_arg_fail(1)) SWIG_fail;
7745 }
7746 {
7747 PyThreadState* __tstate = wxPyBeginAllowThreads();
7748 wxCaret::SetBlinkTime(arg1);
7749
7750 wxPyEndAllowThreads(__tstate);
7751 if (PyErr_Occurred()) SWIG_fail;
7752 }
7753 Py_INCREF(Py_None); resultobj = Py_None;
7754 return resultobj;
7755 fail:
7756 return NULL;
7757 }
7758
7759
7760 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
7761 PyObject *obj;
7762 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7763 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
7764 Py_INCREF(obj);
7765 return Py_BuildValue((char *)"");
7766 }
7767 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7768 PyObject *resultobj = NULL;
7769 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7770 wxBusyCursor *result;
7771 PyObject * obj0 = 0 ;
7772 char *kwnames[] = {
7773 (char *) "cursor", NULL
7774 };
7775
7776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
7777 if (obj0) {
7778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
7779 if (SWIG_arg_fail(1)) SWIG_fail;
7780 }
7781 {
7782 if (!wxPyCheckForApp()) SWIG_fail;
7783 PyThreadState* __tstate = wxPyBeginAllowThreads();
7784 result = (wxBusyCursor *)new wxBusyCursor(arg1);
7785
7786 wxPyEndAllowThreads(__tstate);
7787 if (PyErr_Occurred()) SWIG_fail;
7788 }
7789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
7790 return resultobj;
7791 fail:
7792 return NULL;
7793 }
7794
7795
7796 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7797 PyObject *resultobj = NULL;
7798 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
7799 PyObject * obj0 = 0 ;
7800 char *kwnames[] = {
7801 (char *) "self", NULL
7802 };
7803
7804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
7805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
7806 if (SWIG_arg_fail(1)) SWIG_fail;
7807 {
7808 PyThreadState* __tstate = wxPyBeginAllowThreads();
7809 delete arg1;
7810
7811 wxPyEndAllowThreads(__tstate);
7812 if (PyErr_Occurred()) SWIG_fail;
7813 }
7814 Py_INCREF(Py_None); resultobj = Py_None;
7815 return resultobj;
7816 fail:
7817 return NULL;
7818 }
7819
7820
7821 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7822 PyObject *obj;
7823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7824 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7825 Py_INCREF(obj);
7826 return Py_BuildValue((char *)"");
7827 }
7828 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7829 PyObject *resultobj = NULL;
7830 wxWindow *arg1 = (wxWindow *) NULL ;
7831 wxWindowDisabler *result;
7832 PyObject * obj0 = 0 ;
7833 char *kwnames[] = {
7834 (char *) "winToSkip", NULL
7835 };
7836
7837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7838 if (obj0) {
7839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7840 if (SWIG_arg_fail(1)) SWIG_fail;
7841 }
7842 {
7843 if (!wxPyCheckForApp()) SWIG_fail;
7844 PyThreadState* __tstate = wxPyBeginAllowThreads();
7845 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7846
7847 wxPyEndAllowThreads(__tstate);
7848 if (PyErr_Occurred()) SWIG_fail;
7849 }
7850 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7851 return resultobj;
7852 fail:
7853 return NULL;
7854 }
7855
7856
7857 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7858 PyObject *resultobj = NULL;
7859 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7860 PyObject * obj0 = 0 ;
7861 char *kwnames[] = {
7862 (char *) "self", NULL
7863 };
7864
7865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7867 if (SWIG_arg_fail(1)) SWIG_fail;
7868 {
7869 PyThreadState* __tstate = wxPyBeginAllowThreads();
7870 delete arg1;
7871
7872 wxPyEndAllowThreads(__tstate);
7873 if (PyErr_Occurred()) SWIG_fail;
7874 }
7875 Py_INCREF(Py_None); resultobj = Py_None;
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
7882 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7883 PyObject *obj;
7884 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7885 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7886 Py_INCREF(obj);
7887 return Py_BuildValue((char *)"");
7888 }
7889 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7890 PyObject *resultobj = NULL;
7891 wxString *arg1 = 0 ;
7892 wxBusyInfo *result;
7893 bool temp1 = false ;
7894 PyObject * obj0 = 0 ;
7895 char *kwnames[] = {
7896 (char *) "message", NULL
7897 };
7898
7899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7900 {
7901 arg1 = wxString_in_helper(obj0);
7902 if (arg1 == NULL) SWIG_fail;
7903 temp1 = true;
7904 }
7905 {
7906 if (!wxPyCheckForApp()) SWIG_fail;
7907 PyThreadState* __tstate = wxPyBeginAllowThreads();
7908 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7909
7910 wxPyEndAllowThreads(__tstate);
7911 if (PyErr_Occurred()) SWIG_fail;
7912 }
7913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7914 {
7915 if (temp1)
7916 delete arg1;
7917 }
7918 return resultobj;
7919 fail:
7920 {
7921 if (temp1)
7922 delete arg1;
7923 }
7924 return NULL;
7925 }
7926
7927
7928 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7929 PyObject *resultobj = NULL;
7930 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7931 PyObject * obj0 = 0 ;
7932 char *kwnames[] = {
7933 (char *) "self", NULL
7934 };
7935
7936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7938 if (SWIG_arg_fail(1)) SWIG_fail;
7939 {
7940 PyThreadState* __tstate = wxPyBeginAllowThreads();
7941 delete arg1;
7942
7943 wxPyEndAllowThreads(__tstate);
7944 if (PyErr_Occurred()) SWIG_fail;
7945 }
7946 Py_INCREF(Py_None); resultobj = Py_None;
7947 return resultobj;
7948 fail:
7949 return NULL;
7950 }
7951
7952
7953 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7954 PyObject *obj;
7955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7956 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7957 Py_INCREF(obj);
7958 return Py_BuildValue((char *)"");
7959 }
7960 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7961 PyObject *resultobj = NULL;
7962 wxStopWatch *result;
7963 char *kwnames[] = {
7964 NULL
7965 };
7966
7967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7968 {
7969 PyThreadState* __tstate = wxPyBeginAllowThreads();
7970 result = (wxStopWatch *)new wxStopWatch();
7971
7972 wxPyEndAllowThreads(__tstate);
7973 if (PyErr_Occurred()) SWIG_fail;
7974 }
7975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7976 return resultobj;
7977 fail:
7978 return NULL;
7979 }
7980
7981
7982 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7983 PyObject *resultobj = NULL;
7984 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7985 long arg2 = (long) 0 ;
7986 PyObject * obj0 = 0 ;
7987 PyObject * obj1 = 0 ;
7988 char *kwnames[] = {
7989 (char *) "self",(char *) "t0", NULL
7990 };
7991
7992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7994 if (SWIG_arg_fail(1)) SWIG_fail;
7995 if (obj1) {
7996 {
7997 arg2 = static_cast<long >(SWIG_As_long(obj1));
7998 if (SWIG_arg_fail(2)) SWIG_fail;
7999 }
8000 }
8001 {
8002 PyThreadState* __tstate = wxPyBeginAllowThreads();
8003 (arg1)->Start(arg2);
8004
8005 wxPyEndAllowThreads(__tstate);
8006 if (PyErr_Occurred()) SWIG_fail;
8007 }
8008 Py_INCREF(Py_None); resultobj = Py_None;
8009 return resultobj;
8010 fail:
8011 return NULL;
8012 }
8013
8014
8015 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
8016 PyObject *resultobj = NULL;
8017 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
8018 PyObject * obj0 = 0 ;
8019 char *kwnames[] = {
8020 (char *) "self", NULL
8021 };
8022
8023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
8024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
8025 if (SWIG_arg_fail(1)) SWIG_fail;
8026 {
8027 PyThreadState* __tstate = wxPyBeginAllowThreads();
8028 (arg1)->Pause();
8029
8030 wxPyEndAllowThreads(__tstate);
8031 if (PyErr_Occurred()) SWIG_fail;
8032 }
8033 Py_INCREF(Py_None); resultobj = Py_None;
8034 return resultobj;
8035 fail:
8036 return NULL;
8037 }
8038
8039
8040 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8041 PyObject *resultobj = NULL;
8042 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
8043 PyObject * obj0 = 0 ;
8044 char *kwnames[] = {
8045 (char *) "self", NULL
8046 };
8047
8048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
8049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
8050 if (SWIG_arg_fail(1)) SWIG_fail;
8051 {
8052 PyThreadState* __tstate = wxPyBeginAllowThreads();
8053 (arg1)->Resume();
8054
8055 wxPyEndAllowThreads(__tstate);
8056 if (PyErr_Occurred()) SWIG_fail;
8057 }
8058 Py_INCREF(Py_None); resultobj = Py_None;
8059 return resultobj;
8060 fail:
8061 return NULL;
8062 }
8063
8064
8065 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
8066 PyObject *resultobj = NULL;
8067 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
8068 long result;
8069 PyObject * obj0 = 0 ;
8070 char *kwnames[] = {
8071 (char *) "self", NULL
8072 };
8073
8074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
8075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
8076 if (SWIG_arg_fail(1)) SWIG_fail;
8077 {
8078 PyThreadState* __tstate = wxPyBeginAllowThreads();
8079 result = (long)((wxStopWatch const *)arg1)->Time();
8080
8081 wxPyEndAllowThreads(__tstate);
8082 if (PyErr_Occurred()) SWIG_fail;
8083 }
8084 {
8085 resultobj = SWIG_From_long(static_cast<long >(result));
8086 }
8087 return resultobj;
8088 fail:
8089 return NULL;
8090 }
8091
8092
8093 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
8094 PyObject *obj;
8095 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8096 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
8097 Py_INCREF(obj);
8098 return Py_BuildValue((char *)"");
8099 }
8100 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
8101 PyObject *resultobj = NULL;
8102 int arg1 = (int) 9 ;
8103 int arg2 = (int) wxID_FILE1 ;
8104 wxFileHistory *result;
8105 PyObject * obj0 = 0 ;
8106 PyObject * obj1 = 0 ;
8107 char *kwnames[] = {
8108 (char *) "maxFiles",(char *) "idBase", NULL
8109 };
8110
8111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
8112 if (obj0) {
8113 {
8114 arg1 = static_cast<int >(SWIG_As_int(obj0));
8115 if (SWIG_arg_fail(1)) SWIG_fail;
8116 }
8117 }
8118 if (obj1) {
8119 {
8120 arg2 = static_cast<int >(SWIG_As_int(obj1));
8121 if (SWIG_arg_fail(2)) SWIG_fail;
8122 }
8123 }
8124 {
8125 PyThreadState* __tstate = wxPyBeginAllowThreads();
8126 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
8127
8128 wxPyEndAllowThreads(__tstate);
8129 if (PyErr_Occurred()) SWIG_fail;
8130 }
8131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
8132 return resultobj;
8133 fail:
8134 return NULL;
8135 }
8136
8137
8138 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
8139 PyObject *resultobj = NULL;
8140 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8141 PyObject * obj0 = 0 ;
8142 char *kwnames[] = {
8143 (char *) "self", NULL
8144 };
8145
8146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
8147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8148 if (SWIG_arg_fail(1)) SWIG_fail;
8149 {
8150 PyThreadState* __tstate = wxPyBeginAllowThreads();
8151 delete arg1;
8152
8153 wxPyEndAllowThreads(__tstate);
8154 if (PyErr_Occurred()) SWIG_fail;
8155 }
8156 Py_INCREF(Py_None); resultobj = Py_None;
8157 return resultobj;
8158 fail:
8159 return NULL;
8160 }
8161
8162
8163 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
8164 PyObject *resultobj = NULL;
8165 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8166 wxString *arg2 = 0 ;
8167 bool temp2 = false ;
8168 PyObject * obj0 = 0 ;
8169 PyObject * obj1 = 0 ;
8170 char *kwnames[] = {
8171 (char *) "self",(char *) "file", NULL
8172 };
8173
8174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
8175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8176 if (SWIG_arg_fail(1)) SWIG_fail;
8177 {
8178 arg2 = wxString_in_helper(obj1);
8179 if (arg2 == NULL) SWIG_fail;
8180 temp2 = true;
8181 }
8182 {
8183 PyThreadState* __tstate = wxPyBeginAllowThreads();
8184 (arg1)->AddFileToHistory((wxString const &)*arg2);
8185
8186 wxPyEndAllowThreads(__tstate);
8187 if (PyErr_Occurred()) SWIG_fail;
8188 }
8189 Py_INCREF(Py_None); resultobj = Py_None;
8190 {
8191 if (temp2)
8192 delete arg2;
8193 }
8194 return resultobj;
8195 fail:
8196 {
8197 if (temp2)
8198 delete arg2;
8199 }
8200 return NULL;
8201 }
8202
8203
8204 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
8205 PyObject *resultobj = NULL;
8206 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8207 int arg2 ;
8208 PyObject * obj0 = 0 ;
8209 PyObject * obj1 = 0 ;
8210 char *kwnames[] = {
8211 (char *) "self",(char *) "i", NULL
8212 };
8213
8214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
8215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8216 if (SWIG_arg_fail(1)) SWIG_fail;
8217 {
8218 arg2 = static_cast<int >(SWIG_As_int(obj1));
8219 if (SWIG_arg_fail(2)) SWIG_fail;
8220 }
8221 {
8222 PyThreadState* __tstate = wxPyBeginAllowThreads();
8223 (arg1)->RemoveFileFromHistory(arg2);
8224
8225 wxPyEndAllowThreads(__tstate);
8226 if (PyErr_Occurred()) SWIG_fail;
8227 }
8228 Py_INCREF(Py_None); resultobj = Py_None;
8229 return resultobj;
8230 fail:
8231 return NULL;
8232 }
8233
8234
8235 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
8236 PyObject *resultobj = NULL;
8237 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8238 int result;
8239 PyObject * obj0 = 0 ;
8240 char *kwnames[] = {
8241 (char *) "self", NULL
8242 };
8243
8244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
8245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8246 if (SWIG_arg_fail(1)) SWIG_fail;
8247 {
8248 PyThreadState* __tstate = wxPyBeginAllowThreads();
8249 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
8250
8251 wxPyEndAllowThreads(__tstate);
8252 if (PyErr_Occurred()) SWIG_fail;
8253 }
8254 {
8255 resultobj = SWIG_From_int(static_cast<int >(result));
8256 }
8257 return resultobj;
8258 fail:
8259 return NULL;
8260 }
8261
8262
8263 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
8264 PyObject *resultobj = NULL;
8265 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8266 wxMenu *arg2 = (wxMenu *) 0 ;
8267 PyObject * obj0 = 0 ;
8268 PyObject * obj1 = 0 ;
8269 char *kwnames[] = {
8270 (char *) "self",(char *) "menu", NULL
8271 };
8272
8273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
8274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8275 if (SWIG_arg_fail(1)) SWIG_fail;
8276 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
8277 if (SWIG_arg_fail(2)) SWIG_fail;
8278 {
8279 PyThreadState* __tstate = wxPyBeginAllowThreads();
8280 (arg1)->UseMenu(arg2);
8281
8282 wxPyEndAllowThreads(__tstate);
8283 if (PyErr_Occurred()) SWIG_fail;
8284 }
8285 Py_INCREF(Py_None); resultobj = Py_None;
8286 return resultobj;
8287 fail:
8288 return NULL;
8289 }
8290
8291
8292 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
8293 PyObject *resultobj = NULL;
8294 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8295 wxMenu *arg2 = (wxMenu *) 0 ;
8296 PyObject * obj0 = 0 ;
8297 PyObject * obj1 = 0 ;
8298 char *kwnames[] = {
8299 (char *) "self",(char *) "menu", NULL
8300 };
8301
8302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
8303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8304 if (SWIG_arg_fail(1)) SWIG_fail;
8305 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
8306 if (SWIG_arg_fail(2)) SWIG_fail;
8307 {
8308 PyThreadState* __tstate = wxPyBeginAllowThreads();
8309 (arg1)->RemoveMenu(arg2);
8310
8311 wxPyEndAllowThreads(__tstate);
8312 if (PyErr_Occurred()) SWIG_fail;
8313 }
8314 Py_INCREF(Py_None); resultobj = Py_None;
8315 return resultobj;
8316 fail:
8317 return NULL;
8318 }
8319
8320
8321 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
8322 PyObject *resultobj = NULL;
8323 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8324 wxConfigBase *arg2 = 0 ;
8325 PyObject * obj0 = 0 ;
8326 PyObject * obj1 = 0 ;
8327 char *kwnames[] = {
8328 (char *) "self",(char *) "config", NULL
8329 };
8330
8331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
8332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8333 if (SWIG_arg_fail(1)) SWIG_fail;
8334 {
8335 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8336 if (SWIG_arg_fail(2)) SWIG_fail;
8337 if (arg2 == NULL) {
8338 SWIG_null_ref("wxConfigBase");
8339 }
8340 if (SWIG_arg_fail(2)) SWIG_fail;
8341 }
8342 {
8343 PyThreadState* __tstate = wxPyBeginAllowThreads();
8344 (arg1)->Load(*arg2);
8345
8346 wxPyEndAllowThreads(__tstate);
8347 if (PyErr_Occurred()) SWIG_fail;
8348 }
8349 Py_INCREF(Py_None); resultobj = Py_None;
8350 return resultobj;
8351 fail:
8352 return NULL;
8353 }
8354
8355
8356 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
8357 PyObject *resultobj = NULL;
8358 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8359 wxConfigBase *arg2 = 0 ;
8360 PyObject * obj0 = 0 ;
8361 PyObject * obj1 = 0 ;
8362 char *kwnames[] = {
8363 (char *) "self",(char *) "config", NULL
8364 };
8365
8366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
8367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8368 if (SWIG_arg_fail(1)) SWIG_fail;
8369 {
8370 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8371 if (SWIG_arg_fail(2)) SWIG_fail;
8372 if (arg2 == NULL) {
8373 SWIG_null_ref("wxConfigBase");
8374 }
8375 if (SWIG_arg_fail(2)) SWIG_fail;
8376 }
8377 {
8378 PyThreadState* __tstate = wxPyBeginAllowThreads();
8379 (arg1)->Save(*arg2);
8380
8381 wxPyEndAllowThreads(__tstate);
8382 if (PyErr_Occurred()) SWIG_fail;
8383 }
8384 Py_INCREF(Py_None); resultobj = Py_None;
8385 return resultobj;
8386 fail:
8387 return NULL;
8388 }
8389
8390
8391 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
8392 PyObject *resultobj = NULL;
8393 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8394 PyObject * obj0 = 0 ;
8395 char *kwnames[] = {
8396 (char *) "self", NULL
8397 };
8398
8399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
8400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8401 if (SWIG_arg_fail(1)) SWIG_fail;
8402 {
8403 PyThreadState* __tstate = wxPyBeginAllowThreads();
8404 (arg1)->AddFilesToMenu();
8405
8406 wxPyEndAllowThreads(__tstate);
8407 if (PyErr_Occurred()) SWIG_fail;
8408 }
8409 Py_INCREF(Py_None); resultobj = Py_None;
8410 return resultobj;
8411 fail:
8412 return NULL;
8413 }
8414
8415
8416 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
8417 PyObject *resultobj = NULL;
8418 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8419 wxMenu *arg2 = (wxMenu *) 0 ;
8420 PyObject * obj0 = 0 ;
8421 PyObject * obj1 = 0 ;
8422 char *kwnames[] = {
8423 (char *) "self",(char *) "menu", NULL
8424 };
8425
8426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
8427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8428 if (SWIG_arg_fail(1)) SWIG_fail;
8429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
8430 if (SWIG_arg_fail(2)) SWIG_fail;
8431 {
8432 PyThreadState* __tstate = wxPyBeginAllowThreads();
8433 (arg1)->AddFilesToMenu(arg2);
8434
8435 wxPyEndAllowThreads(__tstate);
8436 if (PyErr_Occurred()) SWIG_fail;
8437 }
8438 Py_INCREF(Py_None); resultobj = Py_None;
8439 return resultobj;
8440 fail:
8441 return NULL;
8442 }
8443
8444
8445 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
8446 PyObject *resultobj = NULL;
8447 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8448 int arg2 ;
8449 wxString result;
8450 PyObject * obj0 = 0 ;
8451 PyObject * obj1 = 0 ;
8452 char *kwnames[] = {
8453 (char *) "self",(char *) "i", NULL
8454 };
8455
8456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
8457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8458 if (SWIG_arg_fail(1)) SWIG_fail;
8459 {
8460 arg2 = static_cast<int >(SWIG_As_int(obj1));
8461 if (SWIG_arg_fail(2)) SWIG_fail;
8462 }
8463 {
8464 PyThreadState* __tstate = wxPyBeginAllowThreads();
8465 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
8466
8467 wxPyEndAllowThreads(__tstate);
8468 if (PyErr_Occurred()) SWIG_fail;
8469 }
8470 {
8471 #if wxUSE_UNICODE
8472 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8473 #else
8474 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8475 #endif
8476 }
8477 return resultobj;
8478 fail:
8479 return NULL;
8480 }
8481
8482
8483 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
8484 PyObject *resultobj = NULL;
8485 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8486 int result;
8487 PyObject * obj0 = 0 ;
8488 char *kwnames[] = {
8489 (char *) "self", NULL
8490 };
8491
8492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
8493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8494 if (SWIG_arg_fail(1)) SWIG_fail;
8495 {
8496 PyThreadState* __tstate = wxPyBeginAllowThreads();
8497 result = (int)((wxFileHistory const *)arg1)->GetCount();
8498
8499 wxPyEndAllowThreads(__tstate);
8500 if (PyErr_Occurred()) SWIG_fail;
8501 }
8502 {
8503 resultobj = SWIG_From_int(static_cast<int >(result));
8504 }
8505 return resultobj;
8506 fail:
8507 return NULL;
8508 }
8509
8510
8511 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
8512 PyObject *obj;
8513 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8514 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
8515 Py_INCREF(obj);
8516 return Py_BuildValue((char *)"");
8517 }
8518 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
8519 PyObject *resultobj = NULL;
8520 wxString *arg1 = 0 ;
8521 wxString const &arg2_defvalue = wxPyEmptyString ;
8522 wxString *arg2 = (wxString *) &arg2_defvalue ;
8523 wxSingleInstanceChecker *result;
8524 bool temp1 = false ;
8525 bool temp2 = false ;
8526 PyObject * obj0 = 0 ;
8527 PyObject * obj1 = 0 ;
8528 char *kwnames[] = {
8529 (char *) "name",(char *) "path", NULL
8530 };
8531
8532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
8533 {
8534 arg1 = wxString_in_helper(obj0);
8535 if (arg1 == NULL) SWIG_fail;
8536 temp1 = true;
8537 }
8538 if (obj1) {
8539 {
8540 arg2 = wxString_in_helper(obj1);
8541 if (arg2 == NULL) SWIG_fail;
8542 temp2 = true;
8543 }
8544 }
8545 {
8546 PyThreadState* __tstate = wxPyBeginAllowThreads();
8547 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
8548
8549 wxPyEndAllowThreads(__tstate);
8550 if (PyErr_Occurred()) SWIG_fail;
8551 }
8552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
8553 {
8554 if (temp1)
8555 delete arg1;
8556 }
8557 {
8558 if (temp2)
8559 delete arg2;
8560 }
8561 return resultobj;
8562 fail:
8563 {
8564 if (temp1)
8565 delete arg1;
8566 }
8567 {
8568 if (temp2)
8569 delete arg2;
8570 }
8571 return NULL;
8572 }
8573
8574
8575 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
8576 PyObject *resultobj = NULL;
8577 wxSingleInstanceChecker *result;
8578 char *kwnames[] = {
8579 NULL
8580 };
8581
8582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
8583 {
8584 PyThreadState* __tstate = wxPyBeginAllowThreads();
8585 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
8586
8587 wxPyEndAllowThreads(__tstate);
8588 if (PyErr_Occurred()) SWIG_fail;
8589 }
8590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
8591 return resultobj;
8592 fail:
8593 return NULL;
8594 }
8595
8596
8597 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
8598 PyObject *resultobj = NULL;
8599 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
8600 PyObject * obj0 = 0 ;
8601 char *kwnames[] = {
8602 (char *) "self", NULL
8603 };
8604
8605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
8606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
8607 if (SWIG_arg_fail(1)) SWIG_fail;
8608 {
8609 PyThreadState* __tstate = wxPyBeginAllowThreads();
8610 delete arg1;
8611
8612 wxPyEndAllowThreads(__tstate);
8613 if (PyErr_Occurred()) SWIG_fail;
8614 }
8615 Py_INCREF(Py_None); resultobj = Py_None;
8616 return resultobj;
8617 fail:
8618 return NULL;
8619 }
8620
8621
8622 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
8623 PyObject *resultobj = NULL;
8624 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
8625 wxString *arg2 = 0 ;
8626 wxString const &arg3_defvalue = wxPyEmptyString ;
8627 wxString *arg3 = (wxString *) &arg3_defvalue ;
8628 bool result;
8629 bool temp2 = false ;
8630 bool temp3 = false ;
8631 PyObject * obj0 = 0 ;
8632 PyObject * obj1 = 0 ;
8633 PyObject * obj2 = 0 ;
8634 char *kwnames[] = {
8635 (char *) "self",(char *) "name",(char *) "path", NULL
8636 };
8637
8638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
8639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
8640 if (SWIG_arg_fail(1)) SWIG_fail;
8641 {
8642 arg2 = wxString_in_helper(obj1);
8643 if (arg2 == NULL) SWIG_fail;
8644 temp2 = true;
8645 }
8646 if (obj2) {
8647 {
8648 arg3 = wxString_in_helper(obj2);
8649 if (arg3 == NULL) SWIG_fail;
8650 temp3 = true;
8651 }
8652 }
8653 {
8654 PyThreadState* __tstate = wxPyBeginAllowThreads();
8655 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
8656
8657 wxPyEndAllowThreads(__tstate);
8658 if (PyErr_Occurred()) SWIG_fail;
8659 }
8660 {
8661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8662 }
8663 {
8664 if (temp2)
8665 delete arg2;
8666 }
8667 {
8668 if (temp3)
8669 delete arg3;
8670 }
8671 return resultobj;
8672 fail:
8673 {
8674 if (temp2)
8675 delete arg2;
8676 }
8677 {
8678 if (temp3)
8679 delete arg3;
8680 }
8681 return NULL;
8682 }
8683
8684
8685 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8686 PyObject *resultobj = NULL;
8687 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
8688 bool result;
8689 PyObject * obj0 = 0 ;
8690 char *kwnames[] = {
8691 (char *) "self", NULL
8692 };
8693
8694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
8695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
8696 if (SWIG_arg_fail(1)) SWIG_fail;
8697 {
8698 PyThreadState* __tstate = wxPyBeginAllowThreads();
8699 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
8700
8701 wxPyEndAllowThreads(__tstate);
8702 if (PyErr_Occurred()) SWIG_fail;
8703 }
8704 {
8705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8706 }
8707 return resultobj;
8708 fail:
8709 return NULL;
8710 }
8711
8712
8713 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
8714 PyObject *obj;
8715 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8716 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
8717 Py_INCREF(obj);
8718 return Py_BuildValue((char *)"");
8719 }
8720 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
8721 PyObject *resultobj = NULL;
8722 wxWindow *arg1 = (wxWindow *) 0 ;
8723 wxDC *arg2 = 0 ;
8724 bool result;
8725 PyObject * obj0 = 0 ;
8726 PyObject * obj1 = 0 ;
8727 char *kwnames[] = {
8728 (char *) "window",(char *) "dc", NULL
8729 };
8730
8731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
8732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8733 if (SWIG_arg_fail(1)) SWIG_fail;
8734 {
8735 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
8736 if (SWIG_arg_fail(2)) SWIG_fail;
8737 if (arg2 == NULL) {
8738 SWIG_null_ref("wxDC");
8739 }
8740 if (SWIG_arg_fail(2)) SWIG_fail;
8741 }
8742 {
8743 PyThreadState* __tstate = wxPyBeginAllowThreads();
8744 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
8745
8746 wxPyEndAllowThreads(__tstate);
8747 if (PyErr_Occurred()) SWIG_fail;
8748 }
8749 {
8750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8751 }
8752 return resultobj;
8753 fail:
8754 return NULL;
8755 }
8756
8757
8758 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8759 PyObject *resultobj = NULL;
8760 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8761 PyObject * obj0 = 0 ;
8762 char *kwnames[] = {
8763 (char *) "self", NULL
8764 };
8765
8766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
8767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8768 if (SWIG_arg_fail(1)) SWIG_fail;
8769 {
8770 PyThreadState* __tstate = wxPyBeginAllowThreads();
8771 delete arg1;
8772
8773 wxPyEndAllowThreads(__tstate);
8774 if (PyErr_Occurred()) SWIG_fail;
8775 }
8776 Py_INCREF(Py_None); resultobj = Py_None;
8777 return resultobj;
8778 fail:
8779 return NULL;
8780 }
8781
8782
8783 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
8784 PyObject *resultobj = NULL;
8785 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8786 wxString result;
8787 PyObject * obj0 = 0 ;
8788 char *kwnames[] = {
8789 (char *) "self", NULL
8790 };
8791
8792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
8793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8794 if (SWIG_arg_fail(1)) SWIG_fail;
8795 {
8796 PyThreadState* __tstate = wxPyBeginAllowThreads();
8797 result = (arg1)->GetTip();
8798
8799 wxPyEndAllowThreads(__tstate);
8800 if (PyErr_Occurred()) SWIG_fail;
8801 }
8802 {
8803 #if wxUSE_UNICODE
8804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8805 #else
8806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8807 #endif
8808 }
8809 return resultobj;
8810 fail:
8811 return NULL;
8812 }
8813
8814
8815 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8816 PyObject *resultobj = NULL;
8817 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8818 size_t result;
8819 PyObject * obj0 = 0 ;
8820 char *kwnames[] = {
8821 (char *) "self", NULL
8822 };
8823
8824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8826 if (SWIG_arg_fail(1)) SWIG_fail;
8827 {
8828 PyThreadState* __tstate = wxPyBeginAllowThreads();
8829 result = (size_t)(arg1)->GetCurrentTip();
8830
8831 wxPyEndAllowThreads(__tstate);
8832 if (PyErr_Occurred()) SWIG_fail;
8833 }
8834 {
8835 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
8836 }
8837 return resultobj;
8838 fail:
8839 return NULL;
8840 }
8841
8842
8843 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8844 PyObject *resultobj = NULL;
8845 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8846 wxString *arg2 = 0 ;
8847 wxString result;
8848 bool temp2 = false ;
8849 PyObject * obj0 = 0 ;
8850 PyObject * obj1 = 0 ;
8851 char *kwnames[] = {
8852 (char *) "self",(char *) "tip", NULL
8853 };
8854
8855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8857 if (SWIG_arg_fail(1)) SWIG_fail;
8858 {
8859 arg2 = wxString_in_helper(obj1);
8860 if (arg2 == NULL) SWIG_fail;
8861 temp2 = true;
8862 }
8863 {
8864 PyThreadState* __tstate = wxPyBeginAllowThreads();
8865 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8866
8867 wxPyEndAllowThreads(__tstate);
8868 if (PyErr_Occurred()) SWIG_fail;
8869 }
8870 {
8871 #if wxUSE_UNICODE
8872 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8873 #else
8874 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8875 #endif
8876 }
8877 {
8878 if (temp2)
8879 delete arg2;
8880 }
8881 return resultobj;
8882 fail:
8883 {
8884 if (temp2)
8885 delete arg2;
8886 }
8887 return NULL;
8888 }
8889
8890
8891 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8892 PyObject *obj;
8893 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8894 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8895 Py_INCREF(obj);
8896 return Py_BuildValue((char *)"");
8897 }
8898 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8899 PyObject *resultobj = NULL;
8900 size_t arg1 ;
8901 wxPyTipProvider *result;
8902 PyObject * obj0 = 0 ;
8903 char *kwnames[] = {
8904 (char *) "currentTip", NULL
8905 };
8906
8907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8908 {
8909 arg1 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj0));
8910 if (SWIG_arg_fail(1)) SWIG_fail;
8911 }
8912 {
8913 PyThreadState* __tstate = wxPyBeginAllowThreads();
8914 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8915
8916 wxPyEndAllowThreads(__tstate);
8917 if (PyErr_Occurred()) SWIG_fail;
8918 }
8919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8920 return resultobj;
8921 fail:
8922 return NULL;
8923 }
8924
8925
8926 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8927 PyObject *resultobj = NULL;
8928 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8929 PyObject *arg2 = (PyObject *) 0 ;
8930 PyObject *arg3 = (PyObject *) 0 ;
8931 PyObject * obj0 = 0 ;
8932 PyObject * obj1 = 0 ;
8933 PyObject * obj2 = 0 ;
8934 char *kwnames[] = {
8935 (char *) "self",(char *) "self",(char *) "_class", NULL
8936 };
8937
8938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8940 if (SWIG_arg_fail(1)) SWIG_fail;
8941 arg2 = obj1;
8942 arg3 = obj2;
8943 {
8944 PyThreadState* __tstate = wxPyBeginAllowThreads();
8945 (arg1)->_setCallbackInfo(arg2,arg3);
8946
8947 wxPyEndAllowThreads(__tstate);
8948 if (PyErr_Occurred()) SWIG_fail;
8949 }
8950 Py_INCREF(Py_None); resultobj = Py_None;
8951 return resultobj;
8952 fail:
8953 return NULL;
8954 }
8955
8956
8957 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8958 PyObject *obj;
8959 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8960 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8961 Py_INCREF(obj);
8962 return Py_BuildValue((char *)"");
8963 }
8964 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8965 PyObject *resultobj = NULL;
8966 wxWindow *arg1 = (wxWindow *) 0 ;
8967 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8968 bool arg3 = (bool) true ;
8969 bool result;
8970 PyObject * obj0 = 0 ;
8971 PyObject * obj1 = 0 ;
8972 PyObject * obj2 = 0 ;
8973 char *kwnames[] = {
8974 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8975 };
8976
8977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8979 if (SWIG_arg_fail(1)) SWIG_fail;
8980 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8981 if (SWIG_arg_fail(2)) SWIG_fail;
8982 if (obj2) {
8983 {
8984 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
8985 if (SWIG_arg_fail(3)) SWIG_fail;
8986 }
8987 }
8988 {
8989 if (!wxPyCheckForApp()) SWIG_fail;
8990 PyThreadState* __tstate = wxPyBeginAllowThreads();
8991 result = (bool)wxShowTip(arg1,arg2,arg3);
8992
8993 wxPyEndAllowThreads(__tstate);
8994 if (PyErr_Occurred()) SWIG_fail;
8995 }
8996 {
8997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8998 }
8999 return resultobj;
9000 fail:
9001 return NULL;
9002 }
9003
9004
9005 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
9006 PyObject *resultobj = NULL;
9007 wxString *arg1 = 0 ;
9008 size_t arg2 ;
9009 wxTipProvider *result;
9010 bool temp1 = false ;
9011 PyObject * obj0 = 0 ;
9012 PyObject * obj1 = 0 ;
9013 char *kwnames[] = {
9014 (char *) "filename",(char *) "currentTip", NULL
9015 };
9016
9017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
9018 {
9019 arg1 = wxString_in_helper(obj0);
9020 if (arg1 == NULL) SWIG_fail;
9021 temp1 = true;
9022 }
9023 {
9024 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
9025 if (SWIG_arg_fail(2)) SWIG_fail;
9026 }
9027 {
9028 if (!wxPyCheckForApp()) SWIG_fail;
9029 PyThreadState* __tstate = wxPyBeginAllowThreads();
9030 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
9031
9032 wxPyEndAllowThreads(__tstate);
9033 if (PyErr_Occurred()) SWIG_fail;
9034 }
9035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
9036 {
9037 if (temp1)
9038 delete arg1;
9039 }
9040 return resultobj;
9041 fail:
9042 {
9043 if (temp1)
9044 delete arg1;
9045 }
9046 return NULL;
9047 }
9048
9049
9050 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
9051 PyObject *resultobj = NULL;
9052 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
9053 int arg2 = (int) -1 ;
9054 wxPyTimer *result;
9055 PyObject * obj0 = 0 ;
9056 PyObject * obj1 = 0 ;
9057 char *kwnames[] = {
9058 (char *) "owner",(char *) "id", NULL
9059 };
9060
9061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
9062 if (obj0) {
9063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
9064 if (SWIG_arg_fail(1)) SWIG_fail;
9065 }
9066 if (obj1) {
9067 {
9068 arg2 = static_cast<int >(SWIG_As_int(obj1));
9069 if (SWIG_arg_fail(2)) SWIG_fail;
9070 }
9071 }
9072 {
9073 if (!wxPyCheckForApp()) SWIG_fail;
9074 PyThreadState* __tstate = wxPyBeginAllowThreads();
9075 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
9076
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
9081 return resultobj;
9082 fail:
9083 return NULL;
9084 }
9085
9086
9087 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
9088 PyObject *resultobj = NULL;
9089 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9090 PyObject * obj0 = 0 ;
9091 char *kwnames[] = {
9092 (char *) "self", NULL
9093 };
9094
9095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
9096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9097 if (SWIG_arg_fail(1)) SWIG_fail;
9098 {
9099 PyThreadState* __tstate = wxPyBeginAllowThreads();
9100 delete arg1;
9101
9102 wxPyEndAllowThreads(__tstate);
9103 if (PyErr_Occurred()) SWIG_fail;
9104 }
9105 Py_INCREF(Py_None); resultobj = Py_None;
9106 return resultobj;
9107 fail:
9108 return NULL;
9109 }
9110
9111
9112 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9113 PyObject *resultobj = NULL;
9114 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9115 PyObject *arg2 = (PyObject *) 0 ;
9116 PyObject *arg3 = (PyObject *) 0 ;
9117 int arg4 = (int) 1 ;
9118 PyObject * obj0 = 0 ;
9119 PyObject * obj1 = 0 ;
9120 PyObject * obj2 = 0 ;
9121 PyObject * obj3 = 0 ;
9122 char *kwnames[] = {
9123 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
9124 };
9125
9126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9128 if (SWIG_arg_fail(1)) SWIG_fail;
9129 arg2 = obj1;
9130 arg3 = obj2;
9131 if (obj3) {
9132 {
9133 arg4 = static_cast<int >(SWIG_As_int(obj3));
9134 if (SWIG_arg_fail(4)) SWIG_fail;
9135 }
9136 }
9137 {
9138 PyThreadState* __tstate = wxPyBeginAllowThreads();
9139 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
9140
9141 wxPyEndAllowThreads(__tstate);
9142 if (PyErr_Occurred()) SWIG_fail;
9143 }
9144 Py_INCREF(Py_None); resultobj = Py_None;
9145 return resultobj;
9146 fail:
9147 return NULL;
9148 }
9149
9150
9151 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
9152 PyObject *resultobj = NULL;
9153 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9154 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
9155 int arg3 = (int) -1 ;
9156 PyObject * obj0 = 0 ;
9157 PyObject * obj1 = 0 ;
9158 PyObject * obj2 = 0 ;
9159 char *kwnames[] = {
9160 (char *) "self",(char *) "owner",(char *) "id", NULL
9161 };
9162
9163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
9164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9165 if (SWIG_arg_fail(1)) SWIG_fail;
9166 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
9167 if (SWIG_arg_fail(2)) SWIG_fail;
9168 if (obj2) {
9169 {
9170 arg3 = static_cast<int >(SWIG_As_int(obj2));
9171 if (SWIG_arg_fail(3)) SWIG_fail;
9172 }
9173 }
9174 {
9175 PyThreadState* __tstate = wxPyBeginAllowThreads();
9176 (arg1)->SetOwner(arg2,arg3);
9177
9178 wxPyEndAllowThreads(__tstate);
9179 if (PyErr_Occurred()) SWIG_fail;
9180 }
9181 Py_INCREF(Py_None); resultobj = Py_None;
9182 return resultobj;
9183 fail:
9184 return NULL;
9185 }
9186
9187
9188 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
9189 PyObject *resultobj = NULL;
9190 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9191 wxEvtHandler *result;
9192 PyObject * obj0 = 0 ;
9193 char *kwnames[] = {
9194 (char *) "self", NULL
9195 };
9196
9197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
9198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9199 if (SWIG_arg_fail(1)) SWIG_fail;
9200 {
9201 PyThreadState* __tstate = wxPyBeginAllowThreads();
9202 result = (wxEvtHandler *)(arg1)->GetOwner();
9203
9204 wxPyEndAllowThreads(__tstate);
9205 if (PyErr_Occurred()) SWIG_fail;
9206 }
9207 {
9208 resultobj = wxPyMake_wxObject(result, 0);
9209 }
9210 return resultobj;
9211 fail:
9212 return NULL;
9213 }
9214
9215
9216 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
9217 PyObject *resultobj = NULL;
9218 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9219 int arg2 = (int) -1 ;
9220 bool arg3 = (bool) false ;
9221 bool result;
9222 PyObject * obj0 = 0 ;
9223 PyObject * obj1 = 0 ;
9224 PyObject * obj2 = 0 ;
9225 char *kwnames[] = {
9226 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
9227 };
9228
9229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
9230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9231 if (SWIG_arg_fail(1)) SWIG_fail;
9232 if (obj1) {
9233 {
9234 arg2 = static_cast<int >(SWIG_As_int(obj1));
9235 if (SWIG_arg_fail(2)) SWIG_fail;
9236 }
9237 }
9238 if (obj2) {
9239 {
9240 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
9241 if (SWIG_arg_fail(3)) SWIG_fail;
9242 }
9243 }
9244 {
9245 PyThreadState* __tstate = wxPyBeginAllowThreads();
9246 result = (bool)(arg1)->Start(arg2,arg3);
9247
9248 wxPyEndAllowThreads(__tstate);
9249 if (PyErr_Occurred()) SWIG_fail;
9250 }
9251 {
9252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9253 }
9254 return resultobj;
9255 fail:
9256 return NULL;
9257 }
9258
9259
9260 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
9261 PyObject *resultobj = NULL;
9262 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9263 PyObject * obj0 = 0 ;
9264 char *kwnames[] = {
9265 (char *) "self", NULL
9266 };
9267
9268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
9269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9270 if (SWIG_arg_fail(1)) SWIG_fail;
9271 {
9272 PyThreadState* __tstate = wxPyBeginAllowThreads();
9273 (arg1)->Stop();
9274
9275 wxPyEndAllowThreads(__tstate);
9276 if (PyErr_Occurred()) SWIG_fail;
9277 }
9278 Py_INCREF(Py_None); resultobj = Py_None;
9279 return resultobj;
9280 fail:
9281 return NULL;
9282 }
9283
9284
9285 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
9286 PyObject *resultobj = NULL;
9287 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9288 bool result;
9289 PyObject * obj0 = 0 ;
9290 char *kwnames[] = {
9291 (char *) "self", NULL
9292 };
9293
9294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
9295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9296 if (SWIG_arg_fail(1)) SWIG_fail;
9297 {
9298 PyThreadState* __tstate = wxPyBeginAllowThreads();
9299 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
9300
9301 wxPyEndAllowThreads(__tstate);
9302 if (PyErr_Occurred()) SWIG_fail;
9303 }
9304 {
9305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9306 }
9307 return resultobj;
9308 fail:
9309 return NULL;
9310 }
9311
9312
9313 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
9314 PyObject *resultobj = NULL;
9315 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9316 int result;
9317 PyObject * obj0 = 0 ;
9318 char *kwnames[] = {
9319 (char *) "self", NULL
9320 };
9321
9322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
9323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9324 if (SWIG_arg_fail(1)) SWIG_fail;
9325 {
9326 PyThreadState* __tstate = wxPyBeginAllowThreads();
9327 result = (int)((wxPyTimer const *)arg1)->GetInterval();
9328
9329 wxPyEndAllowThreads(__tstate);
9330 if (PyErr_Occurred()) SWIG_fail;
9331 }
9332 {
9333 resultobj = SWIG_From_int(static_cast<int >(result));
9334 }
9335 return resultobj;
9336 fail:
9337 return NULL;
9338 }
9339
9340
9341 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
9342 PyObject *resultobj = NULL;
9343 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9344 bool result;
9345 PyObject * obj0 = 0 ;
9346 char *kwnames[] = {
9347 (char *) "self", NULL
9348 };
9349
9350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
9351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9352 if (SWIG_arg_fail(1)) SWIG_fail;
9353 {
9354 PyThreadState* __tstate = wxPyBeginAllowThreads();
9355 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
9356
9357 wxPyEndAllowThreads(__tstate);
9358 if (PyErr_Occurred()) SWIG_fail;
9359 }
9360 {
9361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9362 }
9363 return resultobj;
9364 fail:
9365 return NULL;
9366 }
9367
9368
9369 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
9370 PyObject *resultobj = NULL;
9371 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9372 int result;
9373 PyObject * obj0 = 0 ;
9374 char *kwnames[] = {
9375 (char *) "self", NULL
9376 };
9377
9378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
9379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9380 if (SWIG_arg_fail(1)) SWIG_fail;
9381 {
9382 PyThreadState* __tstate = wxPyBeginAllowThreads();
9383 result = (int)((wxPyTimer const *)arg1)->GetId();
9384
9385 wxPyEndAllowThreads(__tstate);
9386 if (PyErr_Occurred()) SWIG_fail;
9387 }
9388 {
9389 resultobj = SWIG_From_int(static_cast<int >(result));
9390 }
9391 return resultobj;
9392 fail:
9393 return NULL;
9394 }
9395
9396
9397 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
9398 PyObject *obj;
9399 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9400 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
9401 Py_INCREF(obj);
9402 return Py_BuildValue((char *)"");
9403 }
9404 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
9405 PyObject *resultobj = NULL;
9406 int arg1 = (int) 0 ;
9407 int arg2 = (int) 0 ;
9408 wxTimerEvent *result;
9409 PyObject * obj0 = 0 ;
9410 PyObject * obj1 = 0 ;
9411 char *kwnames[] = {
9412 (char *) "timerid",(char *) "interval", NULL
9413 };
9414
9415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
9416 if (obj0) {
9417 {
9418 arg1 = static_cast<int >(SWIG_As_int(obj0));
9419 if (SWIG_arg_fail(1)) SWIG_fail;
9420 }
9421 }
9422 if (obj1) {
9423 {
9424 arg2 = static_cast<int >(SWIG_As_int(obj1));
9425 if (SWIG_arg_fail(2)) SWIG_fail;
9426 }
9427 }
9428 {
9429 PyThreadState* __tstate = wxPyBeginAllowThreads();
9430 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
9431
9432 wxPyEndAllowThreads(__tstate);
9433 if (PyErr_Occurred()) SWIG_fail;
9434 }
9435 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
9436 return resultobj;
9437 fail:
9438 return NULL;
9439 }
9440
9441
9442 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
9443 PyObject *resultobj = NULL;
9444 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
9445 int result;
9446 PyObject * obj0 = 0 ;
9447 char *kwnames[] = {
9448 (char *) "self", NULL
9449 };
9450
9451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
9452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
9453 if (SWIG_arg_fail(1)) SWIG_fail;
9454 {
9455 PyThreadState* __tstate = wxPyBeginAllowThreads();
9456 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
9457
9458 wxPyEndAllowThreads(__tstate);
9459 if (PyErr_Occurred()) SWIG_fail;
9460 }
9461 {
9462 resultobj = SWIG_From_int(static_cast<int >(result));
9463 }
9464 return resultobj;
9465 fail:
9466 return NULL;
9467 }
9468
9469
9470 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
9471 PyObject *obj;
9472 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9473 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
9474 Py_INCREF(obj);
9475 return Py_BuildValue((char *)"");
9476 }
9477 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
9478 PyObject *resultobj = NULL;
9479 wxTimer *arg1 = 0 ;
9480 wxTimerRunner *result;
9481 PyObject * obj0 = 0 ;
9482
9483 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
9484 {
9485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
9486 if (SWIG_arg_fail(1)) SWIG_fail;
9487 if (arg1 == NULL) {
9488 SWIG_null_ref("wxTimer");
9489 }
9490 if (SWIG_arg_fail(1)) SWIG_fail;
9491 }
9492 {
9493 if (!wxPyCheckForApp()) SWIG_fail;
9494 PyThreadState* __tstate = wxPyBeginAllowThreads();
9495 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
9496
9497 wxPyEndAllowThreads(__tstate);
9498 if (PyErr_Occurred()) SWIG_fail;
9499 }
9500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
9501 return resultobj;
9502 fail:
9503 return NULL;
9504 }
9505
9506
9507 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
9508 PyObject *resultobj = NULL;
9509 wxTimer *arg1 = 0 ;
9510 int arg2 ;
9511 bool arg3 = (bool) false ;
9512 wxTimerRunner *result;
9513 PyObject * obj0 = 0 ;
9514 PyObject * obj1 = 0 ;
9515 PyObject * obj2 = 0 ;
9516
9517 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
9518 {
9519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
9520 if (SWIG_arg_fail(1)) SWIG_fail;
9521 if (arg1 == NULL) {
9522 SWIG_null_ref("wxTimer");
9523 }
9524 if (SWIG_arg_fail(1)) SWIG_fail;
9525 }
9526 {
9527 arg2 = static_cast<int >(SWIG_As_int(obj1));
9528 if (SWIG_arg_fail(2)) SWIG_fail;
9529 }
9530 if (obj2) {
9531 {
9532 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
9533 if (SWIG_arg_fail(3)) SWIG_fail;
9534 }
9535 }
9536 {
9537 if (!wxPyCheckForApp()) SWIG_fail;
9538 PyThreadState* __tstate = wxPyBeginAllowThreads();
9539 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
9540
9541 wxPyEndAllowThreads(__tstate);
9542 if (PyErr_Occurred()) SWIG_fail;
9543 }
9544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
9545 return resultobj;
9546 fail:
9547 return NULL;
9548 }
9549
9550
9551 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
9552 int argc;
9553 PyObject *argv[4];
9554 int ii;
9555
9556 argc = PyObject_Length(args);
9557 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
9558 argv[ii] = PyTuple_GetItem(args,ii);
9559 }
9560 if (argc == 1) {
9561 int _v;
9562 {
9563 void *ptr = 0;
9564 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
9565 _v = 0;
9566 PyErr_Clear();
9567 } else {
9568 _v = (ptr != 0);
9569 }
9570 }
9571 if (_v) {
9572 return _wrap_new_TimerRunner__SWIG_0(self,args);
9573 }
9574 }
9575 if ((argc >= 2) && (argc <= 3)) {
9576 int _v;
9577 {
9578 void *ptr = 0;
9579 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
9580 _v = 0;
9581 PyErr_Clear();
9582 } else {
9583 _v = (ptr != 0);
9584 }
9585 }
9586 if (_v) {
9587 _v = SWIG_Check_int(argv[1]);
9588 if (_v) {
9589 if (argc <= 2) {
9590 return _wrap_new_TimerRunner__SWIG_1(self,args);
9591 }
9592 _v = SWIG_Check_bool(argv[2]);
9593 if (_v) {
9594 return _wrap_new_TimerRunner__SWIG_1(self,args);
9595 }
9596 }
9597 }
9598 }
9599
9600 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
9601 return NULL;
9602 }
9603
9604
9605 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
9606 PyObject *resultobj = NULL;
9607 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
9608 PyObject * obj0 = 0 ;
9609 char *kwnames[] = {
9610 (char *) "self", NULL
9611 };
9612
9613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
9614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
9615 if (SWIG_arg_fail(1)) SWIG_fail;
9616 {
9617 PyThreadState* __tstate = wxPyBeginAllowThreads();
9618 delete arg1;
9619
9620 wxPyEndAllowThreads(__tstate);
9621 if (PyErr_Occurred()) SWIG_fail;
9622 }
9623 Py_INCREF(Py_None); resultobj = Py_None;
9624 return resultobj;
9625 fail:
9626 return NULL;
9627 }
9628
9629
9630 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
9631 PyObject *resultobj = NULL;
9632 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
9633 int arg2 ;
9634 bool arg3 = (bool) false ;
9635 PyObject * obj0 = 0 ;
9636 PyObject * obj1 = 0 ;
9637 PyObject * obj2 = 0 ;
9638 char *kwnames[] = {
9639 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
9640 };
9641
9642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
9643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
9644 if (SWIG_arg_fail(1)) SWIG_fail;
9645 {
9646 arg2 = static_cast<int >(SWIG_As_int(obj1));
9647 if (SWIG_arg_fail(2)) SWIG_fail;
9648 }
9649 if (obj2) {
9650 {
9651 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
9652 if (SWIG_arg_fail(3)) SWIG_fail;
9653 }
9654 }
9655 {
9656 PyThreadState* __tstate = wxPyBeginAllowThreads();
9657 (arg1)->Start(arg2,arg3);
9658
9659 wxPyEndAllowThreads(__tstate);
9660 if (PyErr_Occurred()) SWIG_fail;
9661 }
9662 Py_INCREF(Py_None); resultobj = Py_None;
9663 return resultobj;
9664 fail:
9665 return NULL;
9666 }
9667
9668
9669 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
9670 PyObject *obj;
9671 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9672 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
9673 Py_INCREF(obj);
9674 return Py_BuildValue((char *)"");
9675 }
9676 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
9677 PyObject *resultobj = NULL;
9678 wxLog *result;
9679 char *kwnames[] = {
9680 NULL
9681 };
9682
9683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
9684 {
9685 PyThreadState* __tstate = wxPyBeginAllowThreads();
9686 result = (wxLog *)new wxLog();
9687
9688 wxPyEndAllowThreads(__tstate);
9689 if (PyErr_Occurred()) SWIG_fail;
9690 }
9691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
9692 return resultobj;
9693 fail:
9694 return NULL;
9695 }
9696
9697
9698 static PyObject *_wrap_delete_Log(PyObject *, PyObject *args, PyObject *kwargs) {
9699 PyObject *resultobj = NULL;
9700 wxLog *arg1 = (wxLog *) 0 ;
9701 PyObject * obj0 = 0 ;
9702 char *kwnames[] = {
9703 (char *) "self", NULL
9704 };
9705
9706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Log",kwnames,&obj0)) goto fail;
9707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9708 if (SWIG_arg_fail(1)) SWIG_fail;
9709 {
9710 PyThreadState* __tstate = wxPyBeginAllowThreads();
9711 delete arg1;
9712
9713 wxPyEndAllowThreads(__tstate);
9714 if (PyErr_Occurred()) SWIG_fail;
9715 }
9716 Py_INCREF(Py_None); resultobj = Py_None;
9717 return resultobj;
9718 fail:
9719 return NULL;
9720 }
9721
9722
9723 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
9724 PyObject *resultobj = NULL;
9725 bool result;
9726 char *kwnames[] = {
9727 NULL
9728 };
9729
9730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
9731 {
9732 PyThreadState* __tstate = wxPyBeginAllowThreads();
9733 result = (bool)wxLog::IsEnabled();
9734
9735 wxPyEndAllowThreads(__tstate);
9736 if (PyErr_Occurred()) SWIG_fail;
9737 }
9738 {
9739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9740 }
9741 return resultobj;
9742 fail:
9743 return NULL;
9744 }
9745
9746
9747 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
9748 PyObject *resultobj = NULL;
9749 bool arg1 = (bool) true ;
9750 bool result;
9751 PyObject * obj0 = 0 ;
9752 char *kwnames[] = {
9753 (char *) "doIt", NULL
9754 };
9755
9756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
9757 if (obj0) {
9758 {
9759 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
9760 if (SWIG_arg_fail(1)) SWIG_fail;
9761 }
9762 }
9763 {
9764 PyThreadState* __tstate = wxPyBeginAllowThreads();
9765 result = (bool)wxLog::EnableLogging(arg1);
9766
9767 wxPyEndAllowThreads(__tstate);
9768 if (PyErr_Occurred()) SWIG_fail;
9769 }
9770 {
9771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9772 }
9773 return resultobj;
9774 fail:
9775 return NULL;
9776 }
9777
9778
9779 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
9780 PyObject *resultobj = NULL;
9781 wxLogLevel arg1 ;
9782 wxChar *arg2 = (wxChar *) 0 ;
9783 time_t arg3 ;
9784 PyObject * obj0 = 0 ;
9785 PyObject * obj1 = 0 ;
9786 PyObject * obj2 = 0 ;
9787 char *kwnames[] = {
9788 (char *) "level",(char *) "szString",(char *) "t", NULL
9789 };
9790
9791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
9792 {
9793 arg1 = static_cast<wxLogLevel >(SWIG_As_unsigned_SS_long(obj0));
9794 if (SWIG_arg_fail(1)) SWIG_fail;
9795 }
9796 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9797 if (SWIG_arg_fail(2)) SWIG_fail;
9798 {
9799 arg3 = static_cast<time_t >(SWIG_As_unsigned_SS_int(obj2));
9800 if (SWIG_arg_fail(3)) SWIG_fail;
9801 }
9802 {
9803 PyThreadState* __tstate = wxPyBeginAllowThreads();
9804 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
9805
9806 wxPyEndAllowThreads(__tstate);
9807 if (PyErr_Occurred()) SWIG_fail;
9808 }
9809 Py_INCREF(Py_None); resultobj = Py_None;
9810 return resultobj;
9811 fail:
9812 return NULL;
9813 }
9814
9815
9816 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
9817 PyObject *resultobj = NULL;
9818 wxLog *arg1 = (wxLog *) 0 ;
9819 PyObject * obj0 = 0 ;
9820 char *kwnames[] = {
9821 (char *) "self", NULL
9822 };
9823
9824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
9825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9826 if (SWIG_arg_fail(1)) SWIG_fail;
9827 {
9828 PyThreadState* __tstate = wxPyBeginAllowThreads();
9829 (arg1)->Flush();
9830
9831 wxPyEndAllowThreads(__tstate);
9832 if (PyErr_Occurred()) SWIG_fail;
9833 }
9834 Py_INCREF(Py_None); resultobj = Py_None;
9835 return resultobj;
9836 fail:
9837 return NULL;
9838 }
9839
9840
9841 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9842 PyObject *resultobj = NULL;
9843 char *kwnames[] = {
9844 NULL
9845 };
9846
9847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9848 {
9849 PyThreadState* __tstate = wxPyBeginAllowThreads();
9850 wxLog::FlushActive();
9851
9852 wxPyEndAllowThreads(__tstate);
9853 if (PyErr_Occurred()) SWIG_fail;
9854 }
9855 Py_INCREF(Py_None); resultobj = Py_None;
9856 return resultobj;
9857 fail:
9858 return NULL;
9859 }
9860
9861
9862 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9863 PyObject *resultobj = NULL;
9864 wxLog *result;
9865 char *kwnames[] = {
9866 NULL
9867 };
9868
9869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9870 {
9871 PyThreadState* __tstate = wxPyBeginAllowThreads();
9872 result = (wxLog *)wxLog::GetActiveTarget();
9873
9874 wxPyEndAllowThreads(__tstate);
9875 if (PyErr_Occurred()) SWIG_fail;
9876 }
9877 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9878 return resultobj;
9879 fail:
9880 return NULL;
9881 }
9882
9883
9884 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9885 PyObject *resultobj = NULL;
9886 wxLog *arg1 = (wxLog *) 0 ;
9887 wxLog *result;
9888 PyObject * obj0 = 0 ;
9889 char *kwnames[] = {
9890 (char *) "pLogger", NULL
9891 };
9892
9893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
9895 if (SWIG_arg_fail(1)) SWIG_fail;
9896 {
9897 PyThreadState* __tstate = wxPyBeginAllowThreads();
9898 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9899
9900 wxPyEndAllowThreads(__tstate);
9901 if (PyErr_Occurred()) SWIG_fail;
9902 }
9903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
9904 return resultobj;
9905 fail:
9906 return NULL;
9907 }
9908
9909
9910 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9911 PyObject *resultobj = NULL;
9912 char *kwnames[] = {
9913 NULL
9914 };
9915
9916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9917 {
9918 PyThreadState* __tstate = wxPyBeginAllowThreads();
9919 wxLog::Suspend();
9920
9921 wxPyEndAllowThreads(__tstate);
9922 if (PyErr_Occurred()) SWIG_fail;
9923 }
9924 Py_INCREF(Py_None); resultobj = Py_None;
9925 return resultobj;
9926 fail:
9927 return NULL;
9928 }
9929
9930
9931 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9932 PyObject *resultobj = NULL;
9933 char *kwnames[] = {
9934 NULL
9935 };
9936
9937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9938 {
9939 PyThreadState* __tstate = wxPyBeginAllowThreads();
9940 wxLog::Resume();
9941
9942 wxPyEndAllowThreads(__tstate);
9943 if (PyErr_Occurred()) SWIG_fail;
9944 }
9945 Py_INCREF(Py_None); resultobj = Py_None;
9946 return resultobj;
9947 fail:
9948 return NULL;
9949 }
9950
9951
9952 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9953 PyObject *resultobj = NULL;
9954 bool arg1 = (bool) true ;
9955 PyObject * obj0 = 0 ;
9956 char *kwnames[] = {
9957 (char *) "bVerbose", NULL
9958 };
9959
9960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9961 if (obj0) {
9962 {
9963 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
9964 if (SWIG_arg_fail(1)) SWIG_fail;
9965 }
9966 }
9967 {
9968 PyThreadState* __tstate = wxPyBeginAllowThreads();
9969 wxLog::SetVerbose(arg1);
9970
9971 wxPyEndAllowThreads(__tstate);
9972 if (PyErr_Occurred()) SWIG_fail;
9973 }
9974 Py_INCREF(Py_None); resultobj = Py_None;
9975 return resultobj;
9976 fail:
9977 return NULL;
9978 }
9979
9980
9981 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9982 PyObject *resultobj = NULL;
9983 wxLogLevel arg1 ;
9984 PyObject * obj0 = 0 ;
9985 char *kwnames[] = {
9986 (char *) "logLevel", NULL
9987 };
9988
9989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9990 {
9991 arg1 = static_cast<wxLogLevel >(SWIG_As_unsigned_SS_long(obj0));
9992 if (SWIG_arg_fail(1)) SWIG_fail;
9993 }
9994 {
9995 PyThreadState* __tstate = wxPyBeginAllowThreads();
9996 wxLog::SetLogLevel(arg1);
9997
9998 wxPyEndAllowThreads(__tstate);
9999 if (PyErr_Occurred()) SWIG_fail;
10000 }
10001 Py_INCREF(Py_None); resultobj = Py_None;
10002 return resultobj;
10003 fail:
10004 return NULL;
10005 }
10006
10007
10008 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
10009 PyObject *resultobj = NULL;
10010 char *kwnames[] = {
10011 NULL
10012 };
10013
10014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
10015 {
10016 PyThreadState* __tstate = wxPyBeginAllowThreads();
10017 wxLog::DontCreateOnDemand();
10018
10019 wxPyEndAllowThreads(__tstate);
10020 if (PyErr_Occurred()) SWIG_fail;
10021 }
10022 Py_INCREF(Py_None); resultobj = Py_None;
10023 return resultobj;
10024 fail:
10025 return NULL;
10026 }
10027
10028
10029 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10030 PyObject *resultobj = NULL;
10031 wxTraceMask arg1 ;
10032 PyObject * obj0 = 0 ;
10033 char *kwnames[] = {
10034 (char *) "ulMask", NULL
10035 };
10036
10037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
10038 {
10039 arg1 = static_cast<wxTraceMask >(SWIG_As_unsigned_SS_long(obj0));
10040 if (SWIG_arg_fail(1)) SWIG_fail;
10041 }
10042 {
10043 PyThreadState* __tstate = wxPyBeginAllowThreads();
10044 wxLog::SetTraceMask(arg1);
10045
10046 wxPyEndAllowThreads(__tstate);
10047 if (PyErr_Occurred()) SWIG_fail;
10048 }
10049 Py_INCREF(Py_None); resultobj = Py_None;
10050 return resultobj;
10051 fail:
10052 return NULL;
10053 }
10054
10055
10056 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10057 PyObject *resultobj = NULL;
10058 wxString *arg1 = 0 ;
10059 bool temp1 = false ;
10060 PyObject * obj0 = 0 ;
10061 char *kwnames[] = {
10062 (char *) "str", NULL
10063 };
10064
10065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
10066 {
10067 arg1 = wxString_in_helper(obj0);
10068 if (arg1 == NULL) SWIG_fail;
10069 temp1 = true;
10070 }
10071 {
10072 PyThreadState* __tstate = wxPyBeginAllowThreads();
10073 wxLog::AddTraceMask((wxString const &)*arg1);
10074
10075 wxPyEndAllowThreads(__tstate);
10076 if (PyErr_Occurred()) SWIG_fail;
10077 }
10078 Py_INCREF(Py_None); resultobj = Py_None;
10079 {
10080 if (temp1)
10081 delete arg1;
10082 }
10083 return resultobj;
10084 fail:
10085 {
10086 if (temp1)
10087 delete arg1;
10088 }
10089 return NULL;
10090 }
10091
10092
10093 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10094 PyObject *resultobj = NULL;
10095 wxString *arg1 = 0 ;
10096 bool temp1 = false ;
10097 PyObject * obj0 = 0 ;
10098 char *kwnames[] = {
10099 (char *) "str", NULL
10100 };
10101
10102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
10103 {
10104 arg1 = wxString_in_helper(obj0);
10105 if (arg1 == NULL) SWIG_fail;
10106 temp1 = true;
10107 }
10108 {
10109 PyThreadState* __tstate = wxPyBeginAllowThreads();
10110 wxLog::RemoveTraceMask((wxString const &)*arg1);
10111
10112 wxPyEndAllowThreads(__tstate);
10113 if (PyErr_Occurred()) SWIG_fail;
10114 }
10115 Py_INCREF(Py_None); resultobj = Py_None;
10116 {
10117 if (temp1)
10118 delete arg1;
10119 }
10120 return resultobj;
10121 fail:
10122 {
10123 if (temp1)
10124 delete arg1;
10125 }
10126 return NULL;
10127 }
10128
10129
10130 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
10131 PyObject *resultobj = NULL;
10132 char *kwnames[] = {
10133 NULL
10134 };
10135
10136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
10137 {
10138 PyThreadState* __tstate = wxPyBeginAllowThreads();
10139 wxLog::ClearTraceMasks();
10140
10141 wxPyEndAllowThreads(__tstate);
10142 if (PyErr_Occurred()) SWIG_fail;
10143 }
10144 Py_INCREF(Py_None); resultobj = Py_None;
10145 return resultobj;
10146 fail:
10147 return NULL;
10148 }
10149
10150
10151 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
10152 PyObject *resultobj = NULL;
10153 wxArrayString *result;
10154 char *kwnames[] = {
10155 NULL
10156 };
10157
10158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
10159 {
10160 PyThreadState* __tstate = wxPyBeginAllowThreads();
10161 {
10162 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
10163 result = (wxArrayString *) &_result_ref;
10164 }
10165
10166 wxPyEndAllowThreads(__tstate);
10167 if (PyErr_Occurred()) SWIG_fail;
10168 }
10169 {
10170 resultobj = wxArrayString2PyList_helper(*result);
10171 }
10172 return resultobj;
10173 fail:
10174 return NULL;
10175 }
10176
10177
10178 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
10179 PyObject *resultobj = NULL;
10180 wxChar *arg1 = (wxChar *) 0 ;
10181 PyObject * obj0 = 0 ;
10182 char *kwnames[] = {
10183 (char *) "ts", NULL
10184 };
10185
10186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
10187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
10188 if (SWIG_arg_fail(1)) SWIG_fail;
10189 {
10190 PyThreadState* __tstate = wxPyBeginAllowThreads();
10191 wxLog::SetTimestamp((wxChar const *)arg1);
10192
10193 wxPyEndAllowThreads(__tstate);
10194 if (PyErr_Occurred()) SWIG_fail;
10195 }
10196 Py_INCREF(Py_None); resultobj = Py_None;
10197 return resultobj;
10198 fail:
10199 return NULL;
10200 }
10201
10202
10203 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10204 PyObject *resultobj = NULL;
10205 bool result;
10206 char *kwnames[] = {
10207 NULL
10208 };
10209
10210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
10211 {
10212 PyThreadState* __tstate = wxPyBeginAllowThreads();
10213 result = (bool)wxLog::GetVerbose();
10214
10215 wxPyEndAllowThreads(__tstate);
10216 if (PyErr_Occurred()) SWIG_fail;
10217 }
10218 {
10219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10220 }
10221 return resultobj;
10222 fail:
10223 return NULL;
10224 }
10225
10226
10227 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10228 PyObject *resultobj = NULL;
10229 wxTraceMask result;
10230 char *kwnames[] = {
10231 NULL
10232 };
10233
10234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
10235 {
10236 PyThreadState* __tstate = wxPyBeginAllowThreads();
10237 result = (wxTraceMask)wxLog::GetTraceMask();
10238
10239 wxPyEndAllowThreads(__tstate);
10240 if (PyErr_Occurred()) SWIG_fail;
10241 }
10242 {
10243 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10244 }
10245 return resultobj;
10246 fail:
10247 return NULL;
10248 }
10249
10250
10251 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10252 PyObject *resultobj = NULL;
10253 wxChar *arg1 = (wxChar *) 0 ;
10254 bool result;
10255 PyObject * obj0 = 0 ;
10256 char *kwnames[] = {
10257 (char *) "mask", NULL
10258 };
10259
10260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
10261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
10262 if (SWIG_arg_fail(1)) SWIG_fail;
10263 {
10264 PyThreadState* __tstate = wxPyBeginAllowThreads();
10265 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
10266
10267 wxPyEndAllowThreads(__tstate);
10268 if (PyErr_Occurred()) SWIG_fail;
10269 }
10270 {
10271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10272 }
10273 return resultobj;
10274 fail:
10275 return NULL;
10276 }
10277
10278
10279 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
10280 PyObject *resultobj = NULL;
10281 wxLogLevel result;
10282 char *kwnames[] = {
10283 NULL
10284 };
10285
10286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
10287 {
10288 PyThreadState* __tstate = wxPyBeginAllowThreads();
10289 result = (wxLogLevel)wxLog::GetLogLevel();
10290
10291 wxPyEndAllowThreads(__tstate);
10292 if (PyErr_Occurred()) SWIG_fail;
10293 }
10294 {
10295 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10296 }
10297 return resultobj;
10298 fail:
10299 return NULL;
10300 }
10301
10302
10303 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
10304 PyObject *resultobj = NULL;
10305 wxChar *result;
10306 char *kwnames[] = {
10307 NULL
10308 };
10309
10310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
10311 {
10312 PyThreadState* __tstate = wxPyBeginAllowThreads();
10313 result = (wxChar *)wxLog::GetTimestamp();
10314
10315 wxPyEndAllowThreads(__tstate);
10316 if (PyErr_Occurred()) SWIG_fail;
10317 }
10318 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
10319 return resultobj;
10320 fail:
10321 return NULL;
10322 }
10323
10324
10325 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
10326 PyObject *resultobj = NULL;
10327 wxString result;
10328 char *kwnames[] = {
10329 NULL
10330 };
10331
10332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
10333 {
10334 PyThreadState* __tstate = wxPyBeginAllowThreads();
10335 result = wxLog_TimeStamp();
10336
10337 wxPyEndAllowThreads(__tstate);
10338 if (PyErr_Occurred()) SWIG_fail;
10339 }
10340 {
10341 #if wxUSE_UNICODE
10342 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10343 #else
10344 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10345 #endif
10346 }
10347 return resultobj;
10348 fail:
10349 return NULL;
10350 }
10351
10352
10353 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10354 PyObject *resultobj = NULL;
10355 wxLog *arg1 = (wxLog *) 0 ;
10356 PyObject * obj0 = 0 ;
10357 char *kwnames[] = {
10358 (char *) "self", NULL
10359 };
10360
10361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
10362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
10363 if (SWIG_arg_fail(1)) SWIG_fail;
10364 {
10365 PyThreadState* __tstate = wxPyBeginAllowThreads();
10366 wxLog_Destroy(arg1);
10367
10368 wxPyEndAllowThreads(__tstate);
10369 if (PyErr_Occurred()) SWIG_fail;
10370 }
10371 Py_INCREF(Py_None); resultobj = Py_None;
10372 return resultobj;
10373 fail:
10374 return NULL;
10375 }
10376
10377
10378 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
10379 PyObject *obj;
10380 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10381 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
10382 Py_INCREF(obj);
10383 return Py_BuildValue((char *)"");
10384 }
10385 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
10386 PyObject *resultobj = NULL;
10387 wxLogStderr *result;
10388 char *kwnames[] = {
10389 NULL
10390 };
10391
10392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
10393 {
10394 PyThreadState* __tstate = wxPyBeginAllowThreads();
10395 result = (wxLogStderr *)new wxLogStderr();
10396
10397 wxPyEndAllowThreads(__tstate);
10398 if (PyErr_Occurred()) SWIG_fail;
10399 }
10400 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
10401 return resultobj;
10402 fail:
10403 return NULL;
10404 }
10405
10406
10407 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
10408 PyObject *obj;
10409 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10410 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
10411 Py_INCREF(obj);
10412 return Py_BuildValue((char *)"");
10413 }
10414 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
10415 PyObject *resultobj = NULL;
10416 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10417 wxLogTextCtrl *result;
10418 PyObject * obj0 = 0 ;
10419 char *kwnames[] = {
10420 (char *) "pTextCtrl", NULL
10421 };
10422
10423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
10424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10425 if (SWIG_arg_fail(1)) SWIG_fail;
10426 {
10427 PyThreadState* __tstate = wxPyBeginAllowThreads();
10428 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
10429
10430 wxPyEndAllowThreads(__tstate);
10431 if (PyErr_Occurred()) SWIG_fail;
10432 }
10433 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
10434 return resultobj;
10435 fail:
10436 return NULL;
10437 }
10438
10439
10440 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
10441 PyObject *obj;
10442 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10443 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
10444 Py_INCREF(obj);
10445 return Py_BuildValue((char *)"");
10446 }
10447 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
10448 PyObject *resultobj = NULL;
10449 wxLogGui *result;
10450 char *kwnames[] = {
10451 NULL
10452 };
10453
10454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
10455 {
10456 PyThreadState* __tstate = wxPyBeginAllowThreads();
10457 result = (wxLogGui *)new wxLogGui();
10458
10459 wxPyEndAllowThreads(__tstate);
10460 if (PyErr_Occurred()) SWIG_fail;
10461 }
10462 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
10463 return resultobj;
10464 fail:
10465 return NULL;
10466 }
10467
10468
10469 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
10470 PyObject *obj;
10471 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10472 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
10473 Py_INCREF(obj);
10474 return Py_BuildValue((char *)"");
10475 }
10476 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10477 PyObject *resultobj = NULL;
10478 wxFrame *arg1 = (wxFrame *) 0 ;
10479 wxString *arg2 = 0 ;
10480 bool arg3 = (bool) true ;
10481 bool arg4 = (bool) true ;
10482 wxLogWindow *result;
10483 bool temp2 = false ;
10484 PyObject * obj0 = 0 ;
10485 PyObject * obj1 = 0 ;
10486 PyObject * obj2 = 0 ;
10487 PyObject * obj3 = 0 ;
10488 char *kwnames[] = {
10489 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
10490 };
10491
10492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10494 if (SWIG_arg_fail(1)) SWIG_fail;
10495 {
10496 arg2 = wxString_in_helper(obj1);
10497 if (arg2 == NULL) SWIG_fail;
10498 temp2 = true;
10499 }
10500 if (obj2) {
10501 {
10502 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
10503 if (SWIG_arg_fail(3)) SWIG_fail;
10504 }
10505 }
10506 if (obj3) {
10507 {
10508 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
10509 if (SWIG_arg_fail(4)) SWIG_fail;
10510 }
10511 }
10512 {
10513 PyThreadState* __tstate = wxPyBeginAllowThreads();
10514 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
10515
10516 wxPyEndAllowThreads(__tstate);
10517 if (PyErr_Occurred()) SWIG_fail;
10518 }
10519 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
10520 {
10521 if (temp2)
10522 delete arg2;
10523 }
10524 return resultobj;
10525 fail:
10526 {
10527 if (temp2)
10528 delete arg2;
10529 }
10530 return NULL;
10531 }
10532
10533
10534 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
10535 PyObject *resultobj = NULL;
10536 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10537 bool arg2 = (bool) true ;
10538 PyObject * obj0 = 0 ;
10539 PyObject * obj1 = 0 ;
10540 char *kwnames[] = {
10541 (char *) "self",(char *) "bShow", NULL
10542 };
10543
10544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
10545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10546 if (SWIG_arg_fail(1)) SWIG_fail;
10547 if (obj1) {
10548 {
10549 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
10550 if (SWIG_arg_fail(2)) SWIG_fail;
10551 }
10552 }
10553 {
10554 PyThreadState* __tstate = wxPyBeginAllowThreads();
10555 (arg1)->Show(arg2);
10556
10557 wxPyEndAllowThreads(__tstate);
10558 if (PyErr_Occurred()) SWIG_fail;
10559 }
10560 Py_INCREF(Py_None); resultobj = Py_None;
10561 return resultobj;
10562 fail:
10563 return NULL;
10564 }
10565
10566
10567 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10568 PyObject *resultobj = NULL;
10569 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10570 wxFrame *result;
10571 PyObject * obj0 = 0 ;
10572 char *kwnames[] = {
10573 (char *) "self", NULL
10574 };
10575
10576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
10577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10578 if (SWIG_arg_fail(1)) SWIG_fail;
10579 {
10580 PyThreadState* __tstate = wxPyBeginAllowThreads();
10581 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
10582
10583 wxPyEndAllowThreads(__tstate);
10584 if (PyErr_Occurred()) SWIG_fail;
10585 }
10586 {
10587 resultobj = wxPyMake_wxObject(result, (bool)0);
10588 }
10589 return resultobj;
10590 fail:
10591 return NULL;
10592 }
10593
10594
10595 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10596 PyObject *resultobj = NULL;
10597 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10598 wxLog *result;
10599 PyObject * obj0 = 0 ;
10600 char *kwnames[] = {
10601 (char *) "self", NULL
10602 };
10603
10604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
10605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10606 if (SWIG_arg_fail(1)) SWIG_fail;
10607 {
10608 PyThreadState* __tstate = wxPyBeginAllowThreads();
10609 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
10610
10611 wxPyEndAllowThreads(__tstate);
10612 if (PyErr_Occurred()) SWIG_fail;
10613 }
10614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10615 return resultobj;
10616 fail:
10617 return NULL;
10618 }
10619
10620
10621 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
10622 PyObject *resultobj = NULL;
10623 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10624 bool result;
10625 PyObject * obj0 = 0 ;
10626 char *kwnames[] = {
10627 (char *) "self", NULL
10628 };
10629
10630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
10631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10632 if (SWIG_arg_fail(1)) SWIG_fail;
10633 {
10634 PyThreadState* __tstate = wxPyBeginAllowThreads();
10635 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
10636
10637 wxPyEndAllowThreads(__tstate);
10638 if (PyErr_Occurred()) SWIG_fail;
10639 }
10640 {
10641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10642 }
10643 return resultobj;
10644 fail:
10645 return NULL;
10646 }
10647
10648
10649 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
10650 PyObject *resultobj = NULL;
10651 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10652 bool arg2 ;
10653 PyObject * obj0 = 0 ;
10654 PyObject * obj1 = 0 ;
10655 char *kwnames[] = {
10656 (char *) "self",(char *) "bDoPass", NULL
10657 };
10658
10659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
10660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10661 if (SWIG_arg_fail(1)) SWIG_fail;
10662 {
10663 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
10664 if (SWIG_arg_fail(2)) SWIG_fail;
10665 }
10666 {
10667 PyThreadState* __tstate = wxPyBeginAllowThreads();
10668 (arg1)->PassMessages(arg2);
10669
10670 wxPyEndAllowThreads(__tstate);
10671 if (PyErr_Occurred()) SWIG_fail;
10672 }
10673 Py_INCREF(Py_None); resultobj = Py_None;
10674 return resultobj;
10675 fail:
10676 return NULL;
10677 }
10678
10679
10680 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
10681 PyObject *obj;
10682 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10683 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
10684 Py_INCREF(obj);
10685 return Py_BuildValue((char *)"");
10686 }
10687 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
10688 PyObject *resultobj = NULL;
10689 wxLog *arg1 = (wxLog *) 0 ;
10690 wxLogChain *result;
10691 PyObject * obj0 = 0 ;
10692 char *kwnames[] = {
10693 (char *) "logger", NULL
10694 };
10695
10696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
10697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
10698 if (SWIG_arg_fail(1)) SWIG_fail;
10699 {
10700 PyThreadState* __tstate = wxPyBeginAllowThreads();
10701 result = (wxLogChain *)new wxLogChain(arg1);
10702
10703 wxPyEndAllowThreads(__tstate);
10704 if (PyErr_Occurred()) SWIG_fail;
10705 }
10706 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
10707 return resultobj;
10708 fail:
10709 return NULL;
10710 }
10711
10712
10713 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
10714 PyObject *resultobj = NULL;
10715 wxLogChain *arg1 = (wxLogChain *) 0 ;
10716 wxLog *arg2 = (wxLog *) 0 ;
10717 PyObject * obj0 = 0 ;
10718 PyObject * obj1 = 0 ;
10719 char *kwnames[] = {
10720 (char *) "self",(char *) "logger", NULL
10721 };
10722
10723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
10724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10725 if (SWIG_arg_fail(1)) SWIG_fail;
10726 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
10727 if (SWIG_arg_fail(2)) SWIG_fail;
10728 {
10729 PyThreadState* __tstate = wxPyBeginAllowThreads();
10730 (arg1)->SetLog(arg2);
10731
10732 wxPyEndAllowThreads(__tstate);
10733 if (PyErr_Occurred()) SWIG_fail;
10734 }
10735 Py_INCREF(Py_None); resultobj = Py_None;
10736 return resultobj;
10737 fail:
10738 return NULL;
10739 }
10740
10741
10742 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
10743 PyObject *resultobj = NULL;
10744 wxLogChain *arg1 = (wxLogChain *) 0 ;
10745 bool arg2 ;
10746 PyObject * obj0 = 0 ;
10747 PyObject * obj1 = 0 ;
10748 char *kwnames[] = {
10749 (char *) "self",(char *) "bDoPass", NULL
10750 };
10751
10752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
10753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10754 if (SWIG_arg_fail(1)) SWIG_fail;
10755 {
10756 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
10757 if (SWIG_arg_fail(2)) SWIG_fail;
10758 }
10759 {
10760 PyThreadState* __tstate = wxPyBeginAllowThreads();
10761 (arg1)->PassMessages(arg2);
10762
10763 wxPyEndAllowThreads(__tstate);
10764 if (PyErr_Occurred()) SWIG_fail;
10765 }
10766 Py_INCREF(Py_None); resultobj = Py_None;
10767 return resultobj;
10768 fail:
10769 return NULL;
10770 }
10771
10772
10773 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
10774 PyObject *resultobj = NULL;
10775 wxLogChain *arg1 = (wxLogChain *) 0 ;
10776 bool result;
10777 PyObject * obj0 = 0 ;
10778 char *kwnames[] = {
10779 (char *) "self", NULL
10780 };
10781
10782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
10783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10784 if (SWIG_arg_fail(1)) SWIG_fail;
10785 {
10786 PyThreadState* __tstate = wxPyBeginAllowThreads();
10787 result = (bool)(arg1)->IsPassingMessages();
10788
10789 wxPyEndAllowThreads(__tstate);
10790 if (PyErr_Occurred()) SWIG_fail;
10791 }
10792 {
10793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10794 }
10795 return resultobj;
10796 fail:
10797 return NULL;
10798 }
10799
10800
10801 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10802 PyObject *resultobj = NULL;
10803 wxLogChain *arg1 = (wxLogChain *) 0 ;
10804 wxLog *result;
10805 PyObject * obj0 = 0 ;
10806 char *kwnames[] = {
10807 (char *) "self", NULL
10808 };
10809
10810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
10811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10812 if (SWIG_arg_fail(1)) SWIG_fail;
10813 {
10814 PyThreadState* __tstate = wxPyBeginAllowThreads();
10815 result = (wxLog *)(arg1)->GetOldLog();
10816
10817 wxPyEndAllowThreads(__tstate);
10818 if (PyErr_Occurred()) SWIG_fail;
10819 }
10820 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10821 return resultobj;
10822 fail:
10823 return NULL;
10824 }
10825
10826
10827 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
10828 PyObject *obj;
10829 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10830 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
10831 Py_INCREF(obj);
10832 return Py_BuildValue((char *)"");
10833 }
10834 static PyObject *_wrap_new_LogBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
10835 PyObject *resultobj = NULL;
10836 wxLogBuffer *result;
10837 char *kwnames[] = {
10838 NULL
10839 };
10840
10841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogBuffer",kwnames)) goto fail;
10842 {
10843 PyThreadState* __tstate = wxPyBeginAllowThreads();
10844 result = (wxLogBuffer *)new wxLogBuffer();
10845
10846 wxPyEndAllowThreads(__tstate);
10847 if (PyErr_Occurred()) SWIG_fail;
10848 }
10849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogBuffer, 1);
10850 return resultobj;
10851 fail:
10852 return NULL;
10853 }
10854
10855
10856 static PyObject *_wrap_LogBuffer_GetBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
10857 PyObject *resultobj = NULL;
10858 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
10859 wxString *result;
10860 PyObject * obj0 = 0 ;
10861 char *kwnames[] = {
10862 (char *) "self", NULL
10863 };
10864
10865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogBuffer_GetBuffer",kwnames,&obj0)) goto fail;
10866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_EXCEPTION | 0);
10867 if (SWIG_arg_fail(1)) SWIG_fail;
10868 {
10869 PyThreadState* __tstate = wxPyBeginAllowThreads();
10870 {
10871 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
10872 result = (wxString *) &_result_ref;
10873 }
10874
10875 wxPyEndAllowThreads(__tstate);
10876 if (PyErr_Occurred()) SWIG_fail;
10877 }
10878 {
10879 #if wxUSE_UNICODE
10880 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10881 #else
10882 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10883 #endif
10884 }
10885 return resultobj;
10886 fail:
10887 return NULL;
10888 }
10889
10890
10891 static PyObject *_wrap_LogBuffer_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
10892 PyObject *resultobj = NULL;
10893 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
10894 PyObject * obj0 = 0 ;
10895 char *kwnames[] = {
10896 (char *) "self", NULL
10897 };
10898
10899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogBuffer_Flush",kwnames,&obj0)) goto fail;
10900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_EXCEPTION | 0);
10901 if (SWIG_arg_fail(1)) SWIG_fail;
10902 {
10903 PyThreadState* __tstate = wxPyBeginAllowThreads();
10904 (arg1)->Flush();
10905
10906 wxPyEndAllowThreads(__tstate);
10907 if (PyErr_Occurred()) SWIG_fail;
10908 }
10909 Py_INCREF(Py_None); resultobj = Py_None;
10910 return resultobj;
10911 fail:
10912 return NULL;
10913 }
10914
10915
10916 static PyObject * LogBuffer_swigregister(PyObject *, PyObject *args) {
10917 PyObject *obj;
10918 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10919 SWIG_TypeClientData(SWIGTYPE_p_wxLogBuffer, obj);
10920 Py_INCREF(obj);
10921 return Py_BuildValue((char *)"");
10922 }
10923 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10924 PyObject *resultobj = NULL;
10925 unsigned long result;
10926 char *kwnames[] = {
10927 NULL
10928 };
10929
10930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10931 {
10932 PyThreadState* __tstate = wxPyBeginAllowThreads();
10933 result = (unsigned long)wxSysErrorCode();
10934
10935 wxPyEndAllowThreads(__tstate);
10936 if (PyErr_Occurred()) SWIG_fail;
10937 }
10938 {
10939 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10940 }
10941 return resultobj;
10942 fail:
10943 return NULL;
10944 }
10945
10946
10947 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10948 PyObject *resultobj = NULL;
10949 unsigned long arg1 = (unsigned long) 0 ;
10950 wxString result;
10951 PyObject * obj0 = 0 ;
10952 char *kwnames[] = {
10953 (char *) "nErrCode", NULL
10954 };
10955
10956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10957 if (obj0) {
10958 {
10959 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
10960 if (SWIG_arg_fail(1)) SWIG_fail;
10961 }
10962 }
10963 {
10964 PyThreadState* __tstate = wxPyBeginAllowThreads();
10965 result = wxSysErrorMsg(arg1);
10966
10967 wxPyEndAllowThreads(__tstate);
10968 if (PyErr_Occurred()) SWIG_fail;
10969 }
10970 {
10971 #if wxUSE_UNICODE
10972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10973 #else
10974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10975 #endif
10976 }
10977 return resultobj;
10978 fail:
10979 return NULL;
10980 }
10981
10982
10983 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10984 PyObject *resultobj = NULL;
10985 wxString *arg1 = 0 ;
10986 bool temp1 = false ;
10987 PyObject * obj0 = 0 ;
10988 char *kwnames[] = {
10989 (char *) "msg", NULL
10990 };
10991
10992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10993 {
10994 arg1 = wxString_in_helper(obj0);
10995 if (arg1 == NULL) SWIG_fail;
10996 temp1 = true;
10997 }
10998 {
10999 PyThreadState* __tstate = wxPyBeginAllowThreads();
11000 wxPyLogFatalError((wxString const &)*arg1);
11001
11002 wxPyEndAllowThreads(__tstate);
11003 if (PyErr_Occurred()) SWIG_fail;
11004 }
11005 Py_INCREF(Py_None); resultobj = Py_None;
11006 {
11007 if (temp1)
11008 delete arg1;
11009 }
11010 return resultobj;
11011 fail:
11012 {
11013 if (temp1)
11014 delete arg1;
11015 }
11016 return NULL;
11017 }
11018
11019
11020 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
11021 PyObject *resultobj = NULL;
11022 wxString *arg1 = 0 ;
11023 bool temp1 = false ;
11024 PyObject * obj0 = 0 ;
11025 char *kwnames[] = {
11026 (char *) "msg", NULL
11027 };
11028
11029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
11030 {
11031 arg1 = wxString_in_helper(obj0);
11032 if (arg1 == NULL) SWIG_fail;
11033 temp1 = true;
11034 }
11035 {
11036 PyThreadState* __tstate = wxPyBeginAllowThreads();
11037 wxPyLogError((wxString const &)*arg1);
11038
11039 wxPyEndAllowThreads(__tstate);
11040 if (PyErr_Occurred()) SWIG_fail;
11041 }
11042 Py_INCREF(Py_None); resultobj = Py_None;
11043 {
11044 if (temp1)
11045 delete arg1;
11046 }
11047 return resultobj;
11048 fail:
11049 {
11050 if (temp1)
11051 delete arg1;
11052 }
11053 return NULL;
11054 }
11055
11056
11057 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
11058 PyObject *resultobj = NULL;
11059 wxString *arg1 = 0 ;
11060 bool temp1 = false ;
11061 PyObject * obj0 = 0 ;
11062 char *kwnames[] = {
11063 (char *) "msg", NULL
11064 };
11065
11066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
11067 {
11068 arg1 = wxString_in_helper(obj0);
11069 if (arg1 == NULL) SWIG_fail;
11070 temp1 = true;
11071 }
11072 {
11073 PyThreadState* __tstate = wxPyBeginAllowThreads();
11074 wxPyLogWarning((wxString const &)*arg1);
11075
11076 wxPyEndAllowThreads(__tstate);
11077 if (PyErr_Occurred()) SWIG_fail;
11078 }
11079 Py_INCREF(Py_None); resultobj = Py_None;
11080 {
11081 if (temp1)
11082 delete arg1;
11083 }
11084 return resultobj;
11085 fail:
11086 {
11087 if (temp1)
11088 delete arg1;
11089 }
11090 return NULL;
11091 }
11092
11093
11094 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
11095 PyObject *resultobj = NULL;
11096 wxString *arg1 = 0 ;
11097 bool temp1 = false ;
11098 PyObject * obj0 = 0 ;
11099 char *kwnames[] = {
11100 (char *) "msg", NULL
11101 };
11102
11103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
11104 {
11105 arg1 = wxString_in_helper(obj0);
11106 if (arg1 == NULL) SWIG_fail;
11107 temp1 = true;
11108 }
11109 {
11110 PyThreadState* __tstate = wxPyBeginAllowThreads();
11111 wxPyLogMessage((wxString const &)*arg1);
11112
11113 wxPyEndAllowThreads(__tstate);
11114 if (PyErr_Occurred()) SWIG_fail;
11115 }
11116 Py_INCREF(Py_None); resultobj = Py_None;
11117 {
11118 if (temp1)
11119 delete arg1;
11120 }
11121 return resultobj;
11122 fail:
11123 {
11124 if (temp1)
11125 delete arg1;
11126 }
11127 return NULL;
11128 }
11129
11130
11131 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11132 PyObject *resultobj = NULL;
11133 wxString *arg1 = 0 ;
11134 bool temp1 = false ;
11135 PyObject * obj0 = 0 ;
11136 char *kwnames[] = {
11137 (char *) "msg", NULL
11138 };
11139
11140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
11141 {
11142 arg1 = wxString_in_helper(obj0);
11143 if (arg1 == NULL) SWIG_fail;
11144 temp1 = true;
11145 }
11146 {
11147 PyThreadState* __tstate = wxPyBeginAllowThreads();
11148 wxPyLogInfo((wxString const &)*arg1);
11149
11150 wxPyEndAllowThreads(__tstate);
11151 if (PyErr_Occurred()) SWIG_fail;
11152 }
11153 Py_INCREF(Py_None); resultobj = Py_None;
11154 {
11155 if (temp1)
11156 delete arg1;
11157 }
11158 return resultobj;
11159 fail:
11160 {
11161 if (temp1)
11162 delete arg1;
11163 }
11164 return NULL;
11165 }
11166
11167
11168 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
11169 PyObject *resultobj = NULL;
11170 wxString *arg1 = 0 ;
11171 bool temp1 = false ;
11172 PyObject * obj0 = 0 ;
11173 char *kwnames[] = {
11174 (char *) "msg", NULL
11175 };
11176
11177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
11178 {
11179 arg1 = wxString_in_helper(obj0);
11180 if (arg1 == NULL) SWIG_fail;
11181 temp1 = true;
11182 }
11183 {
11184 PyThreadState* __tstate = wxPyBeginAllowThreads();
11185 wxPyLogDebug((wxString const &)*arg1);
11186
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 Py_INCREF(Py_None); resultobj = Py_None;
11191 {
11192 if (temp1)
11193 delete arg1;
11194 }
11195 return resultobj;
11196 fail:
11197 {
11198 if (temp1)
11199 delete arg1;
11200 }
11201 return NULL;
11202 }
11203
11204
11205 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
11206 PyObject *resultobj = NULL;
11207 wxString *arg1 = 0 ;
11208 bool temp1 = false ;
11209 PyObject * obj0 = 0 ;
11210 char *kwnames[] = {
11211 (char *) "msg", NULL
11212 };
11213
11214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
11215 {
11216 arg1 = wxString_in_helper(obj0);
11217 if (arg1 == NULL) SWIG_fail;
11218 temp1 = true;
11219 }
11220 {
11221 PyThreadState* __tstate = wxPyBeginAllowThreads();
11222 wxPyLogVerbose((wxString const &)*arg1);
11223
11224 wxPyEndAllowThreads(__tstate);
11225 if (PyErr_Occurred()) SWIG_fail;
11226 }
11227 Py_INCREF(Py_None); resultobj = Py_None;
11228 {
11229 if (temp1)
11230 delete arg1;
11231 }
11232 return resultobj;
11233 fail:
11234 {
11235 if (temp1)
11236 delete arg1;
11237 }
11238 return NULL;
11239 }
11240
11241
11242 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
11243 PyObject *resultobj = NULL;
11244 wxString *arg1 = 0 ;
11245 bool temp1 = false ;
11246 PyObject * obj0 = 0 ;
11247 char *kwnames[] = {
11248 (char *) "msg", NULL
11249 };
11250
11251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
11252 {
11253 arg1 = wxString_in_helper(obj0);
11254 if (arg1 == NULL) SWIG_fail;
11255 temp1 = true;
11256 }
11257 {
11258 PyThreadState* __tstate = wxPyBeginAllowThreads();
11259 wxPyLogStatus((wxString const &)*arg1);
11260
11261 wxPyEndAllowThreads(__tstate);
11262 if (PyErr_Occurred()) SWIG_fail;
11263 }
11264 Py_INCREF(Py_None); resultobj = Py_None;
11265 {
11266 if (temp1)
11267 delete arg1;
11268 }
11269 return resultobj;
11270 fail:
11271 {
11272 if (temp1)
11273 delete arg1;
11274 }
11275 return NULL;
11276 }
11277
11278
11279 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
11280 PyObject *resultobj = NULL;
11281 wxFrame *arg1 = (wxFrame *) 0 ;
11282 wxString *arg2 = 0 ;
11283 bool temp2 = false ;
11284 PyObject * obj0 = 0 ;
11285 PyObject * obj1 = 0 ;
11286 char *kwnames[] = {
11287 (char *) "pFrame",(char *) "msg", NULL
11288 };
11289
11290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
11291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
11292 if (SWIG_arg_fail(1)) SWIG_fail;
11293 {
11294 arg2 = wxString_in_helper(obj1);
11295 if (arg2 == NULL) SWIG_fail;
11296 temp2 = true;
11297 }
11298 {
11299 PyThreadState* __tstate = wxPyBeginAllowThreads();
11300 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
11301
11302 wxPyEndAllowThreads(__tstate);
11303 if (PyErr_Occurred()) SWIG_fail;
11304 }
11305 Py_INCREF(Py_None); resultobj = Py_None;
11306 {
11307 if (temp2)
11308 delete arg2;
11309 }
11310 return resultobj;
11311 fail:
11312 {
11313 if (temp2)
11314 delete arg2;
11315 }
11316 return NULL;
11317 }
11318
11319
11320 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
11321 PyObject *resultobj = NULL;
11322 wxString *arg1 = 0 ;
11323 bool temp1 = false ;
11324 PyObject * obj0 = 0 ;
11325 char *kwnames[] = {
11326 (char *) "msg", NULL
11327 };
11328
11329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
11330 {
11331 arg1 = wxString_in_helper(obj0);
11332 if (arg1 == NULL) SWIG_fail;
11333 temp1 = true;
11334 }
11335 {
11336 PyThreadState* __tstate = wxPyBeginAllowThreads();
11337 wxPyLogSysError((wxString const &)*arg1);
11338
11339 wxPyEndAllowThreads(__tstate);
11340 if (PyErr_Occurred()) SWIG_fail;
11341 }
11342 Py_INCREF(Py_None); resultobj = Py_None;
11343 {
11344 if (temp1)
11345 delete arg1;
11346 }
11347 return resultobj;
11348 fail:
11349 {
11350 if (temp1)
11351 delete arg1;
11352 }
11353 return NULL;
11354 }
11355
11356
11357 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
11358 PyObject *resultobj = NULL;
11359 unsigned long arg1 ;
11360 wxString *arg2 = 0 ;
11361 bool temp2 = false ;
11362 PyObject * obj0 = 0 ;
11363 PyObject * obj1 = 0 ;
11364 char *kwnames[] = {
11365 (char *) "level",(char *) "msg", NULL
11366 };
11367
11368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
11369 {
11370 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
11371 if (SWIG_arg_fail(1)) SWIG_fail;
11372 }
11373 {
11374 arg2 = wxString_in_helper(obj1);
11375 if (arg2 == NULL) SWIG_fail;
11376 temp2 = true;
11377 }
11378 {
11379 PyThreadState* __tstate = wxPyBeginAllowThreads();
11380 wxPyLogGeneric(arg1,(wxString const &)*arg2);
11381
11382 wxPyEndAllowThreads(__tstate);
11383 if (PyErr_Occurred()) SWIG_fail;
11384 }
11385 Py_INCREF(Py_None); resultobj = Py_None;
11386 {
11387 if (temp2)
11388 delete arg2;
11389 }
11390 return resultobj;
11391 fail:
11392 {
11393 if (temp2)
11394 delete arg2;
11395 }
11396 return NULL;
11397 }
11398
11399
11400 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
11401 PyObject *resultobj = NULL;
11402 unsigned long arg1 ;
11403 wxString *arg2 = 0 ;
11404 bool temp2 = false ;
11405 PyObject * obj0 = 0 ;
11406 PyObject * obj1 = 0 ;
11407
11408 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
11409 {
11410 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
11411 if (SWIG_arg_fail(1)) SWIG_fail;
11412 }
11413 {
11414 arg2 = wxString_in_helper(obj1);
11415 if (arg2 == NULL) SWIG_fail;
11416 temp2 = true;
11417 }
11418 {
11419 PyThreadState* __tstate = wxPyBeginAllowThreads();
11420 wxPyLogTrace(arg1,(wxString const &)*arg2);
11421
11422 wxPyEndAllowThreads(__tstate);
11423 if (PyErr_Occurred()) SWIG_fail;
11424 }
11425 Py_INCREF(Py_None); resultobj = Py_None;
11426 {
11427 if (temp2)
11428 delete arg2;
11429 }
11430 return resultobj;
11431 fail:
11432 {
11433 if (temp2)
11434 delete arg2;
11435 }
11436 return NULL;
11437 }
11438
11439
11440 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
11441 PyObject *resultobj = NULL;
11442 wxString *arg1 = 0 ;
11443 wxString *arg2 = 0 ;
11444 bool temp1 = false ;
11445 bool temp2 = false ;
11446 PyObject * obj0 = 0 ;
11447 PyObject * obj1 = 0 ;
11448
11449 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
11450 {
11451 arg1 = wxString_in_helper(obj0);
11452 if (arg1 == NULL) SWIG_fail;
11453 temp1 = true;
11454 }
11455 {
11456 arg2 = wxString_in_helper(obj1);
11457 if (arg2 == NULL) SWIG_fail;
11458 temp2 = true;
11459 }
11460 {
11461 PyThreadState* __tstate = wxPyBeginAllowThreads();
11462 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
11463
11464 wxPyEndAllowThreads(__tstate);
11465 if (PyErr_Occurred()) SWIG_fail;
11466 }
11467 Py_INCREF(Py_None); resultobj = Py_None;
11468 {
11469 if (temp1)
11470 delete arg1;
11471 }
11472 {
11473 if (temp2)
11474 delete arg2;
11475 }
11476 return resultobj;
11477 fail:
11478 {
11479 if (temp1)
11480 delete arg1;
11481 }
11482 {
11483 if (temp2)
11484 delete arg2;
11485 }
11486 return NULL;
11487 }
11488
11489
11490 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
11491 int argc;
11492 PyObject *argv[3];
11493 int ii;
11494
11495 argc = PyObject_Length(args);
11496 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
11497 argv[ii] = PyTuple_GetItem(args,ii);
11498 }
11499 if (argc == 2) {
11500 int _v;
11501 {
11502 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11503 }
11504 if (_v) {
11505 {
11506 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11507 }
11508 if (_v) {
11509 return _wrap_LogTrace__SWIG_1(self,args);
11510 }
11511 }
11512 }
11513 if (argc == 2) {
11514 int _v;
11515 _v = SWIG_Check_unsigned_SS_long(argv[0]);
11516 if (_v) {
11517 {
11518 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11519 }
11520 if (_v) {
11521 return _wrap_LogTrace__SWIG_0(self,args);
11522 }
11523 }
11524 }
11525
11526 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
11527 return NULL;
11528 }
11529
11530
11531 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
11532 PyObject *resultobj = NULL;
11533 wxString *arg1 = 0 ;
11534 wxString *arg2 = 0 ;
11535 bool temp1 = false ;
11536 bool temp2 = false ;
11537 PyObject * obj0 = 0 ;
11538 PyObject * obj1 = 0 ;
11539 char *kwnames[] = {
11540 (char *) "title",(char *) "text", NULL
11541 };
11542
11543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
11544 {
11545 arg1 = wxString_in_helper(obj0);
11546 if (arg1 == NULL) SWIG_fail;
11547 temp1 = true;
11548 }
11549 {
11550 arg2 = wxString_in_helper(obj1);
11551 if (arg2 == NULL) SWIG_fail;
11552 temp2 = true;
11553 }
11554 {
11555 PyThreadState* __tstate = wxPyBeginAllowThreads();
11556 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
11557
11558 wxPyEndAllowThreads(__tstate);
11559 if (PyErr_Occurred()) SWIG_fail;
11560 }
11561 Py_INCREF(Py_None); resultobj = Py_None;
11562 {
11563 if (temp1)
11564 delete arg1;
11565 }
11566 {
11567 if (temp2)
11568 delete arg2;
11569 }
11570 return resultobj;
11571 fail:
11572 {
11573 if (temp1)
11574 delete arg1;
11575 }
11576 {
11577 if (temp2)
11578 delete arg2;
11579 }
11580 return NULL;
11581 }
11582
11583
11584 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
11585 PyObject *resultobj = NULL;
11586 wxLogNull *result;
11587 char *kwnames[] = {
11588 NULL
11589 };
11590
11591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
11592 {
11593 PyThreadState* __tstate = wxPyBeginAllowThreads();
11594 result = (wxLogNull *)new wxLogNull();
11595
11596 wxPyEndAllowThreads(__tstate);
11597 if (PyErr_Occurred()) SWIG_fail;
11598 }
11599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
11600 return resultobj;
11601 fail:
11602 return NULL;
11603 }
11604
11605
11606 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
11607 PyObject *resultobj = NULL;
11608 wxLogNull *arg1 = (wxLogNull *) 0 ;
11609 PyObject * obj0 = 0 ;
11610 char *kwnames[] = {
11611 (char *) "self", NULL
11612 };
11613
11614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
11615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
11616 if (SWIG_arg_fail(1)) SWIG_fail;
11617 {
11618 PyThreadState* __tstate = wxPyBeginAllowThreads();
11619 delete arg1;
11620
11621 wxPyEndAllowThreads(__tstate);
11622 if (PyErr_Occurred()) SWIG_fail;
11623 }
11624 Py_INCREF(Py_None); resultobj = Py_None;
11625 return resultobj;
11626 fail:
11627 return NULL;
11628 }
11629
11630
11631 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
11632 PyObject *obj;
11633 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11634 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
11635 Py_INCREF(obj);
11636 return Py_BuildValue((char *)"");
11637 }
11638 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
11639 PyObject *resultobj = NULL;
11640 wxPyLog *result;
11641 char *kwnames[] = {
11642 NULL
11643 };
11644
11645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
11646 {
11647 PyThreadState* __tstate = wxPyBeginAllowThreads();
11648 result = (wxPyLog *)new wxPyLog();
11649
11650 wxPyEndAllowThreads(__tstate);
11651 if (PyErr_Occurred()) SWIG_fail;
11652 }
11653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
11654 return resultobj;
11655 fail:
11656 return NULL;
11657 }
11658
11659
11660 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11661 PyObject *resultobj = NULL;
11662 wxPyLog *arg1 = (wxPyLog *) 0 ;
11663 PyObject *arg2 = (PyObject *) 0 ;
11664 PyObject *arg3 = (PyObject *) 0 ;
11665 PyObject * obj0 = 0 ;
11666 PyObject * obj1 = 0 ;
11667 PyObject * obj2 = 0 ;
11668 char *kwnames[] = {
11669 (char *) "self",(char *) "self",(char *) "_class", NULL
11670 };
11671
11672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
11674 if (SWIG_arg_fail(1)) SWIG_fail;
11675 arg2 = obj1;
11676 arg3 = obj2;
11677 {
11678 PyThreadState* __tstate = wxPyBeginAllowThreads();
11679 (arg1)->_setCallbackInfo(arg2,arg3);
11680
11681 wxPyEndAllowThreads(__tstate);
11682 if (PyErr_Occurred()) SWIG_fail;
11683 }
11684 Py_INCREF(Py_None); resultobj = Py_None;
11685 return resultobj;
11686 fail:
11687 return NULL;
11688 }
11689
11690
11691 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
11692 PyObject *obj;
11693 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11694 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
11695 Py_INCREF(obj);
11696 return Py_BuildValue((char *)"");
11697 }
11698 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11699 PyObject *resultobj = NULL;
11700 int arg1 ;
11701 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11702 int arg3 = (int) wxKILL_NOCHILDREN ;
11703 wxKillError result;
11704 PyObject * obj0 = 0 ;
11705 PyObject * obj1 = 0 ;
11706 PyObject * obj2 = 0 ;
11707 char *kwnames[] = {
11708 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11709 };
11710
11711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11712 {
11713 arg1 = static_cast<int >(SWIG_As_int(obj0));
11714 if (SWIG_arg_fail(1)) SWIG_fail;
11715 }
11716 if (obj1) {
11717 {
11718 arg2 = static_cast<wxSignal >(SWIG_As_int(obj1));
11719 if (SWIG_arg_fail(2)) SWIG_fail;
11720 }
11721 }
11722 if (obj2) {
11723 {
11724 arg3 = static_cast<int >(SWIG_As_int(obj2));
11725 if (SWIG_arg_fail(3)) SWIG_fail;
11726 }
11727 }
11728 {
11729 PyThreadState* __tstate = wxPyBeginAllowThreads();
11730 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
11731
11732 wxPyEndAllowThreads(__tstate);
11733 if (PyErr_Occurred()) SWIG_fail;
11734 }
11735 resultobj = SWIG_From_int((result));
11736 return resultobj;
11737 fail:
11738 return NULL;
11739 }
11740
11741
11742 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
11743 PyObject *resultobj = NULL;
11744 int arg1 ;
11745 bool result;
11746 PyObject * obj0 = 0 ;
11747 char *kwnames[] = {
11748 (char *) "pid", NULL
11749 };
11750
11751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
11752 {
11753 arg1 = static_cast<int >(SWIG_As_int(obj0));
11754 if (SWIG_arg_fail(1)) SWIG_fail;
11755 }
11756 {
11757 PyThreadState* __tstate = wxPyBeginAllowThreads();
11758 result = (bool)wxPyProcess::Exists(arg1);
11759
11760 wxPyEndAllowThreads(__tstate);
11761 if (PyErr_Occurred()) SWIG_fail;
11762 }
11763 {
11764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11765 }
11766 return resultobj;
11767 fail:
11768 return NULL;
11769 }
11770
11771
11772 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
11773 PyObject *resultobj = NULL;
11774 wxString *arg1 = 0 ;
11775 int arg2 = (int) wxEXEC_ASYNC ;
11776 wxPyProcess *result;
11777 bool temp1 = false ;
11778 PyObject * obj0 = 0 ;
11779 PyObject * obj1 = 0 ;
11780 char *kwnames[] = {
11781 (char *) "cmd",(char *) "flags", NULL
11782 };
11783
11784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
11785 {
11786 arg1 = wxString_in_helper(obj0);
11787 if (arg1 == NULL) SWIG_fail;
11788 temp1 = true;
11789 }
11790 if (obj1) {
11791 {
11792 arg2 = static_cast<int >(SWIG_As_int(obj1));
11793 if (SWIG_arg_fail(2)) SWIG_fail;
11794 }
11795 }
11796 {
11797 PyThreadState* __tstate = wxPyBeginAllowThreads();
11798 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
11799
11800 wxPyEndAllowThreads(__tstate);
11801 if (PyErr_Occurred()) SWIG_fail;
11802 }
11803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
11804 {
11805 if (temp1)
11806 delete arg1;
11807 }
11808 return resultobj;
11809 fail:
11810 {
11811 if (temp1)
11812 delete arg1;
11813 }
11814 return NULL;
11815 }
11816
11817
11818 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
11819 PyObject *resultobj = NULL;
11820 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11821 int arg2 = (int) -1 ;
11822 wxPyProcess *result;
11823 PyObject * obj0 = 0 ;
11824 PyObject * obj1 = 0 ;
11825 char *kwnames[] = {
11826 (char *) "parent",(char *) "id", NULL
11827 };
11828
11829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
11830 if (obj0) {
11831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
11832 if (SWIG_arg_fail(1)) SWIG_fail;
11833 }
11834 if (obj1) {
11835 {
11836 arg2 = static_cast<int >(SWIG_As_int(obj1));
11837 if (SWIG_arg_fail(2)) SWIG_fail;
11838 }
11839 }
11840 {
11841 PyThreadState* __tstate = wxPyBeginAllowThreads();
11842 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
11843
11844 wxPyEndAllowThreads(__tstate);
11845 if (PyErr_Occurred()) SWIG_fail;
11846 }
11847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
11848 return resultobj;
11849 fail:
11850 return NULL;
11851 }
11852
11853
11854 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11855 PyObject *resultobj = NULL;
11856 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11857 PyObject *arg2 = (PyObject *) 0 ;
11858 PyObject *arg3 = (PyObject *) 0 ;
11859 PyObject * obj0 = 0 ;
11860 PyObject * obj1 = 0 ;
11861 PyObject * obj2 = 0 ;
11862 char *kwnames[] = {
11863 (char *) "self",(char *) "self",(char *) "_class", NULL
11864 };
11865
11866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11868 if (SWIG_arg_fail(1)) SWIG_fail;
11869 arg2 = obj1;
11870 arg3 = obj2;
11871 {
11872 PyThreadState* __tstate = wxPyBeginAllowThreads();
11873 (arg1)->_setCallbackInfo(arg2,arg3);
11874
11875 wxPyEndAllowThreads(__tstate);
11876 if (PyErr_Occurred()) SWIG_fail;
11877 }
11878 Py_INCREF(Py_None); resultobj = Py_None;
11879 return resultobj;
11880 fail:
11881 return NULL;
11882 }
11883
11884
11885 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
11886 PyObject *resultobj = NULL;
11887 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11888 int arg2 ;
11889 int arg3 ;
11890 PyObject * obj0 = 0 ;
11891 PyObject * obj1 = 0 ;
11892 PyObject * obj2 = 0 ;
11893 char *kwnames[] = {
11894 (char *) "self",(char *) "pid",(char *) "status", NULL
11895 };
11896
11897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
11898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11899 if (SWIG_arg_fail(1)) SWIG_fail;
11900 {
11901 arg2 = static_cast<int >(SWIG_As_int(obj1));
11902 if (SWIG_arg_fail(2)) SWIG_fail;
11903 }
11904 {
11905 arg3 = static_cast<int >(SWIG_As_int(obj2));
11906 if (SWIG_arg_fail(3)) SWIG_fail;
11907 }
11908 {
11909 PyThreadState* __tstate = wxPyBeginAllowThreads();
11910 (arg1)->base_OnTerminate(arg2,arg3);
11911
11912 wxPyEndAllowThreads(__tstate);
11913 if (PyErr_Occurred()) SWIG_fail;
11914 }
11915 Py_INCREF(Py_None); resultobj = Py_None;
11916 return resultobj;
11917 fail:
11918 return NULL;
11919 }
11920
11921
11922 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11923 PyObject *resultobj = NULL;
11924 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11925 PyObject * obj0 = 0 ;
11926 char *kwnames[] = {
11927 (char *) "self", NULL
11928 };
11929
11930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11932 if (SWIG_arg_fail(1)) SWIG_fail;
11933 {
11934 PyThreadState* __tstate = wxPyBeginAllowThreads();
11935 (arg1)->Redirect();
11936
11937 wxPyEndAllowThreads(__tstate);
11938 if (PyErr_Occurred()) SWIG_fail;
11939 }
11940 Py_INCREF(Py_None); resultobj = Py_None;
11941 return resultobj;
11942 fail:
11943 return NULL;
11944 }
11945
11946
11947 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11948 PyObject *resultobj = NULL;
11949 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11950 bool result;
11951 PyObject * obj0 = 0 ;
11952 char *kwnames[] = {
11953 (char *) "self", NULL
11954 };
11955
11956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11958 if (SWIG_arg_fail(1)) SWIG_fail;
11959 {
11960 PyThreadState* __tstate = wxPyBeginAllowThreads();
11961 result = (bool)(arg1)->IsRedirected();
11962
11963 wxPyEndAllowThreads(__tstate);
11964 if (PyErr_Occurred()) SWIG_fail;
11965 }
11966 {
11967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11968 }
11969 return resultobj;
11970 fail:
11971 return NULL;
11972 }
11973
11974
11975 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11976 PyObject *resultobj = NULL;
11977 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11978 PyObject * obj0 = 0 ;
11979 char *kwnames[] = {
11980 (char *) "self", NULL
11981 };
11982
11983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11985 if (SWIG_arg_fail(1)) SWIG_fail;
11986 {
11987 PyThreadState* __tstate = wxPyBeginAllowThreads();
11988 (arg1)->Detach();
11989
11990 wxPyEndAllowThreads(__tstate);
11991 if (PyErr_Occurred()) SWIG_fail;
11992 }
11993 Py_INCREF(Py_None); resultobj = Py_None;
11994 return resultobj;
11995 fail:
11996 return NULL;
11997 }
11998
11999
12000 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
12001 PyObject *resultobj = NULL;
12002 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12003 wxInputStream *result;
12004 PyObject * obj0 = 0 ;
12005 char *kwnames[] = {
12006 (char *) "self", NULL
12007 };
12008
12009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
12010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12011 if (SWIG_arg_fail(1)) SWIG_fail;
12012 {
12013 PyThreadState* __tstate = wxPyBeginAllowThreads();
12014 result = (wxInputStream *)(arg1)->GetInputStream();
12015
12016 wxPyEndAllowThreads(__tstate);
12017 if (PyErr_Occurred()) SWIG_fail;
12018 }
12019 {
12020 wxPyInputStream * _ptr = NULL;
12021
12022 if (result) {
12023 _ptr = new wxPyInputStream(result);
12024 }
12025 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12026 }
12027 return resultobj;
12028 fail:
12029 return NULL;
12030 }
12031
12032
12033 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
12034 PyObject *resultobj = NULL;
12035 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12036 wxInputStream *result;
12037 PyObject * obj0 = 0 ;
12038 char *kwnames[] = {
12039 (char *) "self", NULL
12040 };
12041
12042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
12043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12044 if (SWIG_arg_fail(1)) SWIG_fail;
12045 {
12046 PyThreadState* __tstate = wxPyBeginAllowThreads();
12047 result = (wxInputStream *)(arg1)->GetErrorStream();
12048
12049 wxPyEndAllowThreads(__tstate);
12050 if (PyErr_Occurred()) SWIG_fail;
12051 }
12052 {
12053 wxPyInputStream * _ptr = NULL;
12054
12055 if (result) {
12056 _ptr = new wxPyInputStream(result);
12057 }
12058 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12059 }
12060 return resultobj;
12061 fail:
12062 return NULL;
12063 }
12064
12065
12066 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
12067 PyObject *resultobj = NULL;
12068 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12069 wxOutputStream *result;
12070 PyObject * obj0 = 0 ;
12071 char *kwnames[] = {
12072 (char *) "self", NULL
12073 };
12074
12075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
12076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12077 if (SWIG_arg_fail(1)) SWIG_fail;
12078 {
12079 PyThreadState* __tstate = wxPyBeginAllowThreads();
12080 result = (wxOutputStream *)(arg1)->GetOutputStream();
12081
12082 wxPyEndAllowThreads(__tstate);
12083 if (PyErr_Occurred()) SWIG_fail;
12084 }
12085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
12086 return resultobj;
12087 fail:
12088 return NULL;
12089 }
12090
12091
12092 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
12093 PyObject *resultobj = NULL;
12094 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12095 PyObject * obj0 = 0 ;
12096 char *kwnames[] = {
12097 (char *) "self", NULL
12098 };
12099
12100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
12101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12102 if (SWIG_arg_fail(1)) SWIG_fail;
12103 {
12104 PyThreadState* __tstate = wxPyBeginAllowThreads();
12105 (arg1)->CloseOutput();
12106
12107 wxPyEndAllowThreads(__tstate);
12108 if (PyErr_Occurred()) SWIG_fail;
12109 }
12110 Py_INCREF(Py_None); resultobj = Py_None;
12111 return resultobj;
12112 fail:
12113 return NULL;
12114 }
12115
12116
12117 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
12118 PyObject *resultobj = NULL;
12119 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12120 bool result;
12121 PyObject * obj0 = 0 ;
12122 char *kwnames[] = {
12123 (char *) "self", NULL
12124 };
12125
12126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
12127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12128 if (SWIG_arg_fail(1)) SWIG_fail;
12129 {
12130 PyThreadState* __tstate = wxPyBeginAllowThreads();
12131 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
12132
12133 wxPyEndAllowThreads(__tstate);
12134 if (PyErr_Occurred()) SWIG_fail;
12135 }
12136 {
12137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12138 }
12139 return resultobj;
12140 fail:
12141 return NULL;
12142 }
12143
12144
12145 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
12146 PyObject *resultobj = NULL;
12147 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12148 bool result;
12149 PyObject * obj0 = 0 ;
12150 char *kwnames[] = {
12151 (char *) "self", NULL
12152 };
12153
12154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
12155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12156 if (SWIG_arg_fail(1)) SWIG_fail;
12157 {
12158 PyThreadState* __tstate = wxPyBeginAllowThreads();
12159 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
12160
12161 wxPyEndAllowThreads(__tstate);
12162 if (PyErr_Occurred()) SWIG_fail;
12163 }
12164 {
12165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12166 }
12167 return resultobj;
12168 fail:
12169 return NULL;
12170 }
12171
12172
12173 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
12174 PyObject *resultobj = NULL;
12175 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12176 bool result;
12177 PyObject * obj0 = 0 ;
12178 char *kwnames[] = {
12179 (char *) "self", NULL
12180 };
12181
12182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
12183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12184 if (SWIG_arg_fail(1)) SWIG_fail;
12185 {
12186 PyThreadState* __tstate = wxPyBeginAllowThreads();
12187 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
12188
12189 wxPyEndAllowThreads(__tstate);
12190 if (PyErr_Occurred()) SWIG_fail;
12191 }
12192 {
12193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12194 }
12195 return resultobj;
12196 fail:
12197 return NULL;
12198 }
12199
12200
12201 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
12202 PyObject *obj;
12203 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12204 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
12205 Py_INCREF(obj);
12206 return Py_BuildValue((char *)"");
12207 }
12208 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12209 PyObject *resultobj = NULL;
12210 int arg1 = (int) 0 ;
12211 int arg2 = (int) 0 ;
12212 int arg3 = (int) 0 ;
12213 wxProcessEvent *result;
12214 PyObject * obj0 = 0 ;
12215 PyObject * obj1 = 0 ;
12216 PyObject * obj2 = 0 ;
12217 char *kwnames[] = {
12218 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
12219 };
12220
12221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
12222 if (obj0) {
12223 {
12224 arg1 = static_cast<int >(SWIG_As_int(obj0));
12225 if (SWIG_arg_fail(1)) SWIG_fail;
12226 }
12227 }
12228 if (obj1) {
12229 {
12230 arg2 = static_cast<int >(SWIG_As_int(obj1));
12231 if (SWIG_arg_fail(2)) SWIG_fail;
12232 }
12233 }
12234 if (obj2) {
12235 {
12236 arg3 = static_cast<int >(SWIG_As_int(obj2));
12237 if (SWIG_arg_fail(3)) SWIG_fail;
12238 }
12239 }
12240 {
12241 PyThreadState* __tstate = wxPyBeginAllowThreads();
12242 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
12243
12244 wxPyEndAllowThreads(__tstate);
12245 if (PyErr_Occurred()) SWIG_fail;
12246 }
12247 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
12248 return resultobj;
12249 fail:
12250 return NULL;
12251 }
12252
12253
12254 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
12255 PyObject *resultobj = NULL;
12256 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12257 int result;
12258 PyObject * obj0 = 0 ;
12259 char *kwnames[] = {
12260 (char *) "self", NULL
12261 };
12262
12263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
12264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12265 if (SWIG_arg_fail(1)) SWIG_fail;
12266 {
12267 PyThreadState* __tstate = wxPyBeginAllowThreads();
12268 result = (int)(arg1)->GetPid();
12269
12270 wxPyEndAllowThreads(__tstate);
12271 if (PyErr_Occurred()) SWIG_fail;
12272 }
12273 {
12274 resultobj = SWIG_From_int(static_cast<int >(result));
12275 }
12276 return resultobj;
12277 fail:
12278 return NULL;
12279 }
12280
12281
12282 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
12283 PyObject *resultobj = NULL;
12284 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12285 int result;
12286 PyObject * obj0 = 0 ;
12287 char *kwnames[] = {
12288 (char *) "self", NULL
12289 };
12290
12291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
12292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12293 if (SWIG_arg_fail(1)) SWIG_fail;
12294 {
12295 PyThreadState* __tstate = wxPyBeginAllowThreads();
12296 result = (int)(arg1)->GetExitCode();
12297
12298 wxPyEndAllowThreads(__tstate);
12299 if (PyErr_Occurred()) SWIG_fail;
12300 }
12301 {
12302 resultobj = SWIG_From_int(static_cast<int >(result));
12303 }
12304 return resultobj;
12305 fail:
12306 return NULL;
12307 }
12308
12309
12310 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
12311 PyObject *resultobj = NULL;
12312 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12313 int arg2 ;
12314 PyObject * obj0 = 0 ;
12315 PyObject * obj1 = 0 ;
12316 char *kwnames[] = {
12317 (char *) "self",(char *) "m_pid", NULL
12318 };
12319
12320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
12321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12322 if (SWIG_arg_fail(1)) SWIG_fail;
12323 {
12324 arg2 = static_cast<int >(SWIG_As_int(obj1));
12325 if (SWIG_arg_fail(2)) SWIG_fail;
12326 }
12327 if (arg1) (arg1)->m_pid = arg2;
12328
12329 Py_INCREF(Py_None); resultobj = Py_None;
12330 return resultobj;
12331 fail:
12332 return NULL;
12333 }
12334
12335
12336 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
12337 PyObject *resultobj = NULL;
12338 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12339 int result;
12340 PyObject * obj0 = 0 ;
12341 char *kwnames[] = {
12342 (char *) "self", NULL
12343 };
12344
12345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
12346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12347 if (SWIG_arg_fail(1)) SWIG_fail;
12348 result = (int) ((arg1)->m_pid);
12349
12350 {
12351 resultobj = SWIG_From_int(static_cast<int >(result));
12352 }
12353 return resultobj;
12354 fail:
12355 return NULL;
12356 }
12357
12358
12359 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
12360 PyObject *resultobj = NULL;
12361 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12362 int arg2 ;
12363 PyObject * obj0 = 0 ;
12364 PyObject * obj1 = 0 ;
12365 char *kwnames[] = {
12366 (char *) "self",(char *) "m_exitcode", NULL
12367 };
12368
12369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
12370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12371 if (SWIG_arg_fail(1)) SWIG_fail;
12372 {
12373 arg2 = static_cast<int >(SWIG_As_int(obj1));
12374 if (SWIG_arg_fail(2)) SWIG_fail;
12375 }
12376 if (arg1) (arg1)->m_exitcode = arg2;
12377
12378 Py_INCREF(Py_None); resultobj = Py_None;
12379 return resultobj;
12380 fail:
12381 return NULL;
12382 }
12383
12384
12385 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
12386 PyObject *resultobj = NULL;
12387 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12388 int result;
12389 PyObject * obj0 = 0 ;
12390 char *kwnames[] = {
12391 (char *) "self", NULL
12392 };
12393
12394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
12395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12396 if (SWIG_arg_fail(1)) SWIG_fail;
12397 result = (int) ((arg1)->m_exitcode);
12398
12399 {
12400 resultobj = SWIG_From_int(static_cast<int >(result));
12401 }
12402 return resultobj;
12403 fail:
12404 return NULL;
12405 }
12406
12407
12408 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
12409 PyObject *obj;
12410 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12411 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
12412 Py_INCREF(obj);
12413 return Py_BuildValue((char *)"");
12414 }
12415 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
12416 PyObject *resultobj = NULL;
12417 wxString *arg1 = 0 ;
12418 int arg2 = (int) wxEXEC_ASYNC ;
12419 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
12420 long result;
12421 bool temp1 = false ;
12422 PyObject * obj0 = 0 ;
12423 PyObject * obj1 = 0 ;
12424 PyObject * obj2 = 0 ;
12425 char *kwnames[] = {
12426 (char *) "command",(char *) "flags",(char *) "process", NULL
12427 };
12428
12429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
12430 {
12431 arg1 = wxString_in_helper(obj0);
12432 if (arg1 == NULL) SWIG_fail;
12433 temp1 = true;
12434 }
12435 if (obj1) {
12436 {
12437 arg2 = static_cast<int >(SWIG_As_int(obj1));
12438 if (SWIG_arg_fail(2)) SWIG_fail;
12439 }
12440 }
12441 if (obj2) {
12442 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12443 if (SWIG_arg_fail(3)) SWIG_fail;
12444 }
12445 {
12446 if (!wxPyCheckForApp()) SWIG_fail;
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
12449
12450 wxPyEndAllowThreads(__tstate);
12451 if (PyErr_Occurred()) SWIG_fail;
12452 }
12453 {
12454 resultobj = SWIG_From_long(static_cast<long >(result));
12455 }
12456 {
12457 if (temp1)
12458 delete arg1;
12459 }
12460 return resultobj;
12461 fail:
12462 {
12463 if (temp1)
12464 delete arg1;
12465 }
12466 return NULL;
12467 }
12468
12469
12470 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
12471 PyObject *resultobj = NULL;
12472 long arg1 ;
12473 wxSignal arg2 = (wxSignal) wxSIGTERM ;
12474 wxKillError *arg3 = (wxKillError *) 0 ;
12475 int arg4 = (int) wxKILL_NOCHILDREN ;
12476 int result;
12477 wxKillError temp3 ;
12478 PyObject * obj0 = 0 ;
12479 PyObject * obj1 = 0 ;
12480 PyObject * obj2 = 0 ;
12481 char *kwnames[] = {
12482 (char *) "pid",(char *) "sig",(char *) "flags", NULL
12483 };
12484
12485 {
12486 arg3 = &temp3;
12487 }
12488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
12489 {
12490 arg1 = static_cast<long >(SWIG_As_long(obj0));
12491 if (SWIG_arg_fail(1)) SWIG_fail;
12492 }
12493 if (obj1) {
12494 {
12495 arg2 = static_cast<wxSignal >(SWIG_As_int(obj1));
12496 if (SWIG_arg_fail(2)) SWIG_fail;
12497 }
12498 }
12499 if (obj2) {
12500 {
12501 arg4 = static_cast<int >(SWIG_As_int(obj2));
12502 if (SWIG_arg_fail(4)) SWIG_fail;
12503 }
12504 }
12505 {
12506 PyThreadState* __tstate = wxPyBeginAllowThreads();
12507 result = (int)wxKill(arg1,arg2,arg3,arg4);
12508
12509 wxPyEndAllowThreads(__tstate);
12510 if (PyErr_Occurred()) SWIG_fail;
12511 }
12512 {
12513 resultobj = SWIG_From_int(static_cast<int >(result));
12514 }
12515 {
12516 PyObject* o;
12517 o = PyInt_FromLong((long) (*arg3));
12518
12519 resultobj = t_output_helper(resultobj, o);
12520
12521
12522
12523 }
12524 return resultobj;
12525 fail:
12526 return NULL;
12527 }
12528
12529
12530 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
12531 PyObject *resultobj = NULL;
12532 int arg1 = (int) wxJOYSTICK1 ;
12533 wxJoystick *result;
12534 PyObject * obj0 = 0 ;
12535 char *kwnames[] = {
12536 (char *) "joystick", NULL
12537 };
12538
12539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
12540 if (obj0) {
12541 {
12542 arg1 = static_cast<int >(SWIG_As_int(obj0));
12543 if (SWIG_arg_fail(1)) SWIG_fail;
12544 }
12545 }
12546 {
12547 if (!wxPyCheckForApp()) SWIG_fail;
12548 PyThreadState* __tstate = wxPyBeginAllowThreads();
12549 result = (wxJoystick *)new wxJoystick(arg1);
12550
12551 wxPyEndAllowThreads(__tstate);
12552 if (PyErr_Occurred()) SWIG_fail;
12553 }
12554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
12555 return resultobj;
12556 fail:
12557 return NULL;
12558 }
12559
12560
12561 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
12562 PyObject *resultobj = NULL;
12563 wxJoystick *arg1 = (wxJoystick *) 0 ;
12564 PyObject * obj0 = 0 ;
12565 char *kwnames[] = {
12566 (char *) "self", NULL
12567 };
12568
12569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
12570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12571 if (SWIG_arg_fail(1)) SWIG_fail;
12572 {
12573 PyThreadState* __tstate = wxPyBeginAllowThreads();
12574 delete arg1;
12575
12576 wxPyEndAllowThreads(__tstate);
12577 if (PyErr_Occurred()) SWIG_fail;
12578 }
12579 Py_INCREF(Py_None); resultobj = Py_None;
12580 return resultobj;
12581 fail:
12582 return NULL;
12583 }
12584
12585
12586 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12587 PyObject *resultobj = NULL;
12588 wxJoystick *arg1 = (wxJoystick *) 0 ;
12589 wxPoint result;
12590 PyObject * obj0 = 0 ;
12591 char *kwnames[] = {
12592 (char *) "self", NULL
12593 };
12594
12595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
12596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12597 if (SWIG_arg_fail(1)) SWIG_fail;
12598 {
12599 PyThreadState* __tstate = wxPyBeginAllowThreads();
12600 result = (arg1)->GetPosition();
12601
12602 wxPyEndAllowThreads(__tstate);
12603 if (PyErr_Occurred()) SWIG_fail;
12604 }
12605 {
12606 wxPoint * resultptr;
12607 resultptr = new wxPoint(static_cast<wxPoint & >(result));
12608 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12609 }
12610 return resultobj;
12611 fail:
12612 return NULL;
12613 }
12614
12615
12616 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12617 PyObject *resultobj = NULL;
12618 wxJoystick *arg1 = (wxJoystick *) 0 ;
12619 int result;
12620 PyObject * obj0 = 0 ;
12621 char *kwnames[] = {
12622 (char *) "self", NULL
12623 };
12624
12625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
12626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12627 if (SWIG_arg_fail(1)) SWIG_fail;
12628 {
12629 PyThreadState* __tstate = wxPyBeginAllowThreads();
12630 result = (int)(arg1)->GetZPosition();
12631
12632 wxPyEndAllowThreads(__tstate);
12633 if (PyErr_Occurred()) SWIG_fail;
12634 }
12635 {
12636 resultobj = SWIG_From_int(static_cast<int >(result));
12637 }
12638 return resultobj;
12639 fail:
12640 return NULL;
12641 }
12642
12643
12644 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12645 PyObject *resultobj = NULL;
12646 wxJoystick *arg1 = (wxJoystick *) 0 ;
12647 int result;
12648 PyObject * obj0 = 0 ;
12649 char *kwnames[] = {
12650 (char *) "self", NULL
12651 };
12652
12653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
12654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12655 if (SWIG_arg_fail(1)) SWIG_fail;
12656 {
12657 PyThreadState* __tstate = wxPyBeginAllowThreads();
12658 result = (int)(arg1)->GetButtonState();
12659
12660 wxPyEndAllowThreads(__tstate);
12661 if (PyErr_Occurred()) SWIG_fail;
12662 }
12663 {
12664 resultobj = SWIG_From_int(static_cast<int >(result));
12665 }
12666 return resultobj;
12667 fail:
12668 return NULL;
12669 }
12670
12671
12672 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12673 PyObject *resultobj = NULL;
12674 wxJoystick *arg1 = (wxJoystick *) 0 ;
12675 int result;
12676 PyObject * obj0 = 0 ;
12677 char *kwnames[] = {
12678 (char *) "self", NULL
12679 };
12680
12681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
12682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12683 if (SWIG_arg_fail(1)) SWIG_fail;
12684 {
12685 PyThreadState* __tstate = wxPyBeginAllowThreads();
12686 result = (int)(arg1)->GetPOVPosition();
12687
12688 wxPyEndAllowThreads(__tstate);
12689 if (PyErr_Occurred()) SWIG_fail;
12690 }
12691 {
12692 resultobj = SWIG_From_int(static_cast<int >(result));
12693 }
12694 return resultobj;
12695 fail:
12696 return NULL;
12697 }
12698
12699
12700 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12701 PyObject *resultobj = NULL;
12702 wxJoystick *arg1 = (wxJoystick *) 0 ;
12703 int result;
12704 PyObject * obj0 = 0 ;
12705 char *kwnames[] = {
12706 (char *) "self", NULL
12707 };
12708
12709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
12710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12711 if (SWIG_arg_fail(1)) SWIG_fail;
12712 {
12713 PyThreadState* __tstate = wxPyBeginAllowThreads();
12714 result = (int)(arg1)->GetPOVCTSPosition();
12715
12716 wxPyEndAllowThreads(__tstate);
12717 if (PyErr_Occurred()) SWIG_fail;
12718 }
12719 {
12720 resultobj = SWIG_From_int(static_cast<int >(result));
12721 }
12722 return resultobj;
12723 fail:
12724 return NULL;
12725 }
12726
12727
12728 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12729 PyObject *resultobj = NULL;
12730 wxJoystick *arg1 = (wxJoystick *) 0 ;
12731 int result;
12732 PyObject * obj0 = 0 ;
12733 char *kwnames[] = {
12734 (char *) "self", NULL
12735 };
12736
12737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
12738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12739 if (SWIG_arg_fail(1)) SWIG_fail;
12740 {
12741 PyThreadState* __tstate = wxPyBeginAllowThreads();
12742 result = (int)(arg1)->GetRudderPosition();
12743
12744 wxPyEndAllowThreads(__tstate);
12745 if (PyErr_Occurred()) SWIG_fail;
12746 }
12747 {
12748 resultobj = SWIG_From_int(static_cast<int >(result));
12749 }
12750 return resultobj;
12751 fail:
12752 return NULL;
12753 }
12754
12755
12756 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12757 PyObject *resultobj = NULL;
12758 wxJoystick *arg1 = (wxJoystick *) 0 ;
12759 int result;
12760 PyObject * obj0 = 0 ;
12761 char *kwnames[] = {
12762 (char *) "self", NULL
12763 };
12764
12765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
12766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12767 if (SWIG_arg_fail(1)) SWIG_fail;
12768 {
12769 PyThreadState* __tstate = wxPyBeginAllowThreads();
12770 result = (int)(arg1)->GetUPosition();
12771
12772 wxPyEndAllowThreads(__tstate);
12773 if (PyErr_Occurred()) SWIG_fail;
12774 }
12775 {
12776 resultobj = SWIG_From_int(static_cast<int >(result));
12777 }
12778 return resultobj;
12779 fail:
12780 return NULL;
12781 }
12782
12783
12784 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12785 PyObject *resultobj = NULL;
12786 wxJoystick *arg1 = (wxJoystick *) 0 ;
12787 int result;
12788 PyObject * obj0 = 0 ;
12789 char *kwnames[] = {
12790 (char *) "self", NULL
12791 };
12792
12793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
12794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12795 if (SWIG_arg_fail(1)) SWIG_fail;
12796 {
12797 PyThreadState* __tstate = wxPyBeginAllowThreads();
12798 result = (int)(arg1)->GetVPosition();
12799
12800 wxPyEndAllowThreads(__tstate);
12801 if (PyErr_Occurred()) SWIG_fail;
12802 }
12803 {
12804 resultobj = SWIG_From_int(static_cast<int >(result));
12805 }
12806 return resultobj;
12807 fail:
12808 return NULL;
12809 }
12810
12811
12812 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
12813 PyObject *resultobj = NULL;
12814 wxJoystick *arg1 = (wxJoystick *) 0 ;
12815 int result;
12816 PyObject * obj0 = 0 ;
12817 char *kwnames[] = {
12818 (char *) "self", NULL
12819 };
12820
12821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
12822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12823 if (SWIG_arg_fail(1)) SWIG_fail;
12824 {
12825 PyThreadState* __tstate = wxPyBeginAllowThreads();
12826 result = (int)(arg1)->GetMovementThreshold();
12827
12828 wxPyEndAllowThreads(__tstate);
12829 if (PyErr_Occurred()) SWIG_fail;
12830 }
12831 {
12832 resultobj = SWIG_From_int(static_cast<int >(result));
12833 }
12834 return resultobj;
12835 fail:
12836 return NULL;
12837 }
12838
12839
12840 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
12841 PyObject *resultobj = NULL;
12842 wxJoystick *arg1 = (wxJoystick *) 0 ;
12843 int arg2 ;
12844 PyObject * obj0 = 0 ;
12845 PyObject * obj1 = 0 ;
12846 char *kwnames[] = {
12847 (char *) "self",(char *) "threshold", NULL
12848 };
12849
12850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
12851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12852 if (SWIG_arg_fail(1)) SWIG_fail;
12853 {
12854 arg2 = static_cast<int >(SWIG_As_int(obj1));
12855 if (SWIG_arg_fail(2)) SWIG_fail;
12856 }
12857 {
12858 PyThreadState* __tstate = wxPyBeginAllowThreads();
12859 (arg1)->SetMovementThreshold(arg2);
12860
12861 wxPyEndAllowThreads(__tstate);
12862 if (PyErr_Occurred()) SWIG_fail;
12863 }
12864 Py_INCREF(Py_None); resultobj = Py_None;
12865 return resultobj;
12866 fail:
12867 return NULL;
12868 }
12869
12870
12871 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
12872 PyObject *resultobj = NULL;
12873 wxJoystick *arg1 = (wxJoystick *) 0 ;
12874 bool result;
12875 PyObject * obj0 = 0 ;
12876 char *kwnames[] = {
12877 (char *) "self", NULL
12878 };
12879
12880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
12881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12882 if (SWIG_arg_fail(1)) SWIG_fail;
12883 {
12884 PyThreadState* __tstate = wxPyBeginAllowThreads();
12885 result = (bool)(arg1)->IsOk();
12886
12887 wxPyEndAllowThreads(__tstate);
12888 if (PyErr_Occurred()) SWIG_fail;
12889 }
12890 {
12891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12892 }
12893 return resultobj;
12894 fail:
12895 return NULL;
12896 }
12897
12898
12899 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
12900 PyObject *resultobj = NULL;
12901 wxJoystick *arg1 = (wxJoystick *) 0 ;
12902 int result;
12903 PyObject * obj0 = 0 ;
12904 char *kwnames[] = {
12905 (char *) "self", NULL
12906 };
12907
12908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
12909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12910 if (SWIG_arg_fail(1)) SWIG_fail;
12911 {
12912 PyThreadState* __tstate = wxPyBeginAllowThreads();
12913 result = (int)(arg1)->GetNumberJoysticks();
12914
12915 wxPyEndAllowThreads(__tstate);
12916 if (PyErr_Occurred()) SWIG_fail;
12917 }
12918 {
12919 resultobj = SWIG_From_int(static_cast<int >(result));
12920 }
12921 return resultobj;
12922 fail:
12923 return NULL;
12924 }
12925
12926
12927 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12928 PyObject *resultobj = NULL;
12929 wxJoystick *arg1 = (wxJoystick *) 0 ;
12930 int result;
12931 PyObject * obj0 = 0 ;
12932 char *kwnames[] = {
12933 (char *) "self", NULL
12934 };
12935
12936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12938 if (SWIG_arg_fail(1)) SWIG_fail;
12939 {
12940 PyThreadState* __tstate = wxPyBeginAllowThreads();
12941 result = (int)(arg1)->GetManufacturerId();
12942
12943 wxPyEndAllowThreads(__tstate);
12944 if (PyErr_Occurred()) SWIG_fail;
12945 }
12946 {
12947 resultobj = SWIG_From_int(static_cast<int >(result));
12948 }
12949 return resultobj;
12950 fail:
12951 return NULL;
12952 }
12953
12954
12955 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12956 PyObject *resultobj = NULL;
12957 wxJoystick *arg1 = (wxJoystick *) 0 ;
12958 int result;
12959 PyObject * obj0 = 0 ;
12960 char *kwnames[] = {
12961 (char *) "self", NULL
12962 };
12963
12964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12966 if (SWIG_arg_fail(1)) SWIG_fail;
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 result = (int)(arg1)->GetProductId();
12970
12971 wxPyEndAllowThreads(__tstate);
12972 if (PyErr_Occurred()) SWIG_fail;
12973 }
12974 {
12975 resultobj = SWIG_From_int(static_cast<int >(result));
12976 }
12977 return resultobj;
12978 fail:
12979 return NULL;
12980 }
12981
12982
12983 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12984 PyObject *resultobj = NULL;
12985 wxJoystick *arg1 = (wxJoystick *) 0 ;
12986 wxString result;
12987 PyObject * obj0 = 0 ;
12988 char *kwnames[] = {
12989 (char *) "self", NULL
12990 };
12991
12992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12994 if (SWIG_arg_fail(1)) SWIG_fail;
12995 {
12996 PyThreadState* __tstate = wxPyBeginAllowThreads();
12997 result = (arg1)->GetProductName();
12998
12999 wxPyEndAllowThreads(__tstate);
13000 if (PyErr_Occurred()) SWIG_fail;
13001 }
13002 {
13003 #if wxUSE_UNICODE
13004 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13005 #else
13006 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13007 #endif
13008 }
13009 return resultobj;
13010 fail:
13011 return NULL;
13012 }
13013
13014
13015 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
13016 PyObject *resultobj = NULL;
13017 wxJoystick *arg1 = (wxJoystick *) 0 ;
13018 int result;
13019 PyObject * obj0 = 0 ;
13020 char *kwnames[] = {
13021 (char *) "self", NULL
13022 };
13023
13024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
13025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13026 if (SWIG_arg_fail(1)) SWIG_fail;
13027 {
13028 PyThreadState* __tstate = wxPyBeginAllowThreads();
13029 result = (int)(arg1)->GetXMin();
13030
13031 wxPyEndAllowThreads(__tstate);
13032 if (PyErr_Occurred()) SWIG_fail;
13033 }
13034 {
13035 resultobj = SWIG_From_int(static_cast<int >(result));
13036 }
13037 return resultobj;
13038 fail:
13039 return NULL;
13040 }
13041
13042
13043 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
13044 PyObject *resultobj = NULL;
13045 wxJoystick *arg1 = (wxJoystick *) 0 ;
13046 int result;
13047 PyObject * obj0 = 0 ;
13048 char *kwnames[] = {
13049 (char *) "self", NULL
13050 };
13051
13052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
13053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13054 if (SWIG_arg_fail(1)) SWIG_fail;
13055 {
13056 PyThreadState* __tstate = wxPyBeginAllowThreads();
13057 result = (int)(arg1)->GetYMin();
13058
13059 wxPyEndAllowThreads(__tstate);
13060 if (PyErr_Occurred()) SWIG_fail;
13061 }
13062 {
13063 resultobj = SWIG_From_int(static_cast<int >(result));
13064 }
13065 return resultobj;
13066 fail:
13067 return NULL;
13068 }
13069
13070
13071 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
13072 PyObject *resultobj = NULL;
13073 wxJoystick *arg1 = (wxJoystick *) 0 ;
13074 int result;
13075 PyObject * obj0 = 0 ;
13076 char *kwnames[] = {
13077 (char *) "self", NULL
13078 };
13079
13080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
13081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13082 if (SWIG_arg_fail(1)) SWIG_fail;
13083 {
13084 PyThreadState* __tstate = wxPyBeginAllowThreads();
13085 result = (int)(arg1)->GetZMin();
13086
13087 wxPyEndAllowThreads(__tstate);
13088 if (PyErr_Occurred()) SWIG_fail;
13089 }
13090 {
13091 resultobj = SWIG_From_int(static_cast<int >(result));
13092 }
13093 return resultobj;
13094 fail:
13095 return NULL;
13096 }
13097
13098
13099 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
13100 PyObject *resultobj = NULL;
13101 wxJoystick *arg1 = (wxJoystick *) 0 ;
13102 int result;
13103 PyObject * obj0 = 0 ;
13104 char *kwnames[] = {
13105 (char *) "self", NULL
13106 };
13107
13108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
13109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13110 if (SWIG_arg_fail(1)) SWIG_fail;
13111 {
13112 PyThreadState* __tstate = wxPyBeginAllowThreads();
13113 result = (int)(arg1)->GetXMax();
13114
13115 wxPyEndAllowThreads(__tstate);
13116 if (PyErr_Occurred()) SWIG_fail;
13117 }
13118 {
13119 resultobj = SWIG_From_int(static_cast<int >(result));
13120 }
13121 return resultobj;
13122 fail:
13123 return NULL;
13124 }
13125
13126
13127 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
13128 PyObject *resultobj = NULL;
13129 wxJoystick *arg1 = (wxJoystick *) 0 ;
13130 int result;
13131 PyObject * obj0 = 0 ;
13132 char *kwnames[] = {
13133 (char *) "self", NULL
13134 };
13135
13136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
13137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13138 if (SWIG_arg_fail(1)) SWIG_fail;
13139 {
13140 PyThreadState* __tstate = wxPyBeginAllowThreads();
13141 result = (int)(arg1)->GetYMax();
13142
13143 wxPyEndAllowThreads(__tstate);
13144 if (PyErr_Occurred()) SWIG_fail;
13145 }
13146 {
13147 resultobj = SWIG_From_int(static_cast<int >(result));
13148 }
13149 return resultobj;
13150 fail:
13151 return NULL;
13152 }
13153
13154
13155 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
13156 PyObject *resultobj = NULL;
13157 wxJoystick *arg1 = (wxJoystick *) 0 ;
13158 int result;
13159 PyObject * obj0 = 0 ;
13160 char *kwnames[] = {
13161 (char *) "self", NULL
13162 };
13163
13164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
13165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13166 if (SWIG_arg_fail(1)) SWIG_fail;
13167 {
13168 PyThreadState* __tstate = wxPyBeginAllowThreads();
13169 result = (int)(arg1)->GetZMax();
13170
13171 wxPyEndAllowThreads(__tstate);
13172 if (PyErr_Occurred()) SWIG_fail;
13173 }
13174 {
13175 resultobj = SWIG_From_int(static_cast<int >(result));
13176 }
13177 return resultobj;
13178 fail:
13179 return NULL;
13180 }
13181
13182
13183 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
13184 PyObject *resultobj = NULL;
13185 wxJoystick *arg1 = (wxJoystick *) 0 ;
13186 int result;
13187 PyObject * obj0 = 0 ;
13188 char *kwnames[] = {
13189 (char *) "self", NULL
13190 };
13191
13192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
13193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13194 if (SWIG_arg_fail(1)) SWIG_fail;
13195 {
13196 PyThreadState* __tstate = wxPyBeginAllowThreads();
13197 result = (int)(arg1)->GetNumberButtons();
13198
13199 wxPyEndAllowThreads(__tstate);
13200 if (PyErr_Occurred()) SWIG_fail;
13201 }
13202 {
13203 resultobj = SWIG_From_int(static_cast<int >(result));
13204 }
13205 return resultobj;
13206 fail:
13207 return NULL;
13208 }
13209
13210
13211 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
13212 PyObject *resultobj = NULL;
13213 wxJoystick *arg1 = (wxJoystick *) 0 ;
13214 int result;
13215 PyObject * obj0 = 0 ;
13216 char *kwnames[] = {
13217 (char *) "self", NULL
13218 };
13219
13220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
13221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13222 if (SWIG_arg_fail(1)) SWIG_fail;
13223 {
13224 PyThreadState* __tstate = wxPyBeginAllowThreads();
13225 result = (int)(arg1)->GetNumberAxes();
13226
13227 wxPyEndAllowThreads(__tstate);
13228 if (PyErr_Occurred()) SWIG_fail;
13229 }
13230 {
13231 resultobj = SWIG_From_int(static_cast<int >(result));
13232 }
13233 return resultobj;
13234 fail:
13235 return NULL;
13236 }
13237
13238
13239 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
13240 PyObject *resultobj = NULL;
13241 wxJoystick *arg1 = (wxJoystick *) 0 ;
13242 int result;
13243 PyObject * obj0 = 0 ;
13244 char *kwnames[] = {
13245 (char *) "self", NULL
13246 };
13247
13248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
13249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13250 if (SWIG_arg_fail(1)) SWIG_fail;
13251 {
13252 PyThreadState* __tstate = wxPyBeginAllowThreads();
13253 result = (int)(arg1)->GetMaxButtons();
13254
13255 wxPyEndAllowThreads(__tstate);
13256 if (PyErr_Occurred()) SWIG_fail;
13257 }
13258 {
13259 resultobj = SWIG_From_int(static_cast<int >(result));
13260 }
13261 return resultobj;
13262 fail:
13263 return NULL;
13264 }
13265
13266
13267 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
13268 PyObject *resultobj = NULL;
13269 wxJoystick *arg1 = (wxJoystick *) 0 ;
13270 int result;
13271 PyObject * obj0 = 0 ;
13272 char *kwnames[] = {
13273 (char *) "self", NULL
13274 };
13275
13276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
13277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13278 if (SWIG_arg_fail(1)) SWIG_fail;
13279 {
13280 PyThreadState* __tstate = wxPyBeginAllowThreads();
13281 result = (int)(arg1)->GetMaxAxes();
13282
13283 wxPyEndAllowThreads(__tstate);
13284 if (PyErr_Occurred()) SWIG_fail;
13285 }
13286 {
13287 resultobj = SWIG_From_int(static_cast<int >(result));
13288 }
13289 return resultobj;
13290 fail:
13291 return NULL;
13292 }
13293
13294
13295 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
13296 PyObject *resultobj = NULL;
13297 wxJoystick *arg1 = (wxJoystick *) 0 ;
13298 int result;
13299 PyObject * obj0 = 0 ;
13300 char *kwnames[] = {
13301 (char *) "self", NULL
13302 };
13303
13304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
13305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13306 if (SWIG_arg_fail(1)) SWIG_fail;
13307 {
13308 PyThreadState* __tstate = wxPyBeginAllowThreads();
13309 result = (int)(arg1)->GetPollingMin();
13310
13311 wxPyEndAllowThreads(__tstate);
13312 if (PyErr_Occurred()) SWIG_fail;
13313 }
13314 {
13315 resultobj = SWIG_From_int(static_cast<int >(result));
13316 }
13317 return resultobj;
13318 fail:
13319 return NULL;
13320 }
13321
13322
13323 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
13324 PyObject *resultobj = NULL;
13325 wxJoystick *arg1 = (wxJoystick *) 0 ;
13326 int result;
13327 PyObject * obj0 = 0 ;
13328 char *kwnames[] = {
13329 (char *) "self", NULL
13330 };
13331
13332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
13333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13334 if (SWIG_arg_fail(1)) SWIG_fail;
13335 {
13336 PyThreadState* __tstate = wxPyBeginAllowThreads();
13337 result = (int)(arg1)->GetPollingMax();
13338
13339 wxPyEndAllowThreads(__tstate);
13340 if (PyErr_Occurred()) SWIG_fail;
13341 }
13342 {
13343 resultobj = SWIG_From_int(static_cast<int >(result));
13344 }
13345 return resultobj;
13346 fail:
13347 return NULL;
13348 }
13349
13350
13351 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
13352 PyObject *resultobj = NULL;
13353 wxJoystick *arg1 = (wxJoystick *) 0 ;
13354 int result;
13355 PyObject * obj0 = 0 ;
13356 char *kwnames[] = {
13357 (char *) "self", NULL
13358 };
13359
13360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
13361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13362 if (SWIG_arg_fail(1)) SWIG_fail;
13363 {
13364 PyThreadState* __tstate = wxPyBeginAllowThreads();
13365 result = (int)(arg1)->GetRudderMin();
13366
13367 wxPyEndAllowThreads(__tstate);
13368 if (PyErr_Occurred()) SWIG_fail;
13369 }
13370 {
13371 resultobj = SWIG_From_int(static_cast<int >(result));
13372 }
13373 return resultobj;
13374 fail:
13375 return NULL;
13376 }
13377
13378
13379 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
13380 PyObject *resultobj = NULL;
13381 wxJoystick *arg1 = (wxJoystick *) 0 ;
13382 int result;
13383 PyObject * obj0 = 0 ;
13384 char *kwnames[] = {
13385 (char *) "self", NULL
13386 };
13387
13388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
13389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13390 if (SWIG_arg_fail(1)) SWIG_fail;
13391 {
13392 PyThreadState* __tstate = wxPyBeginAllowThreads();
13393 result = (int)(arg1)->GetRudderMax();
13394
13395 wxPyEndAllowThreads(__tstate);
13396 if (PyErr_Occurred()) SWIG_fail;
13397 }
13398 {
13399 resultobj = SWIG_From_int(static_cast<int >(result));
13400 }
13401 return resultobj;
13402 fail:
13403 return NULL;
13404 }
13405
13406
13407 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
13408 PyObject *resultobj = NULL;
13409 wxJoystick *arg1 = (wxJoystick *) 0 ;
13410 int result;
13411 PyObject * obj0 = 0 ;
13412 char *kwnames[] = {
13413 (char *) "self", NULL
13414 };
13415
13416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
13417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13418 if (SWIG_arg_fail(1)) SWIG_fail;
13419 {
13420 PyThreadState* __tstate = wxPyBeginAllowThreads();
13421 result = (int)(arg1)->GetUMin();
13422
13423 wxPyEndAllowThreads(__tstate);
13424 if (PyErr_Occurred()) SWIG_fail;
13425 }
13426 {
13427 resultobj = SWIG_From_int(static_cast<int >(result));
13428 }
13429 return resultobj;
13430 fail:
13431 return NULL;
13432 }
13433
13434
13435 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
13436 PyObject *resultobj = NULL;
13437 wxJoystick *arg1 = (wxJoystick *) 0 ;
13438 int result;
13439 PyObject * obj0 = 0 ;
13440 char *kwnames[] = {
13441 (char *) "self", NULL
13442 };
13443
13444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
13445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13446 if (SWIG_arg_fail(1)) SWIG_fail;
13447 {
13448 PyThreadState* __tstate = wxPyBeginAllowThreads();
13449 result = (int)(arg1)->GetUMax();
13450
13451 wxPyEndAllowThreads(__tstate);
13452 if (PyErr_Occurred()) SWIG_fail;
13453 }
13454 {
13455 resultobj = SWIG_From_int(static_cast<int >(result));
13456 }
13457 return resultobj;
13458 fail:
13459 return NULL;
13460 }
13461
13462
13463 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
13464 PyObject *resultobj = NULL;
13465 wxJoystick *arg1 = (wxJoystick *) 0 ;
13466 int result;
13467 PyObject * obj0 = 0 ;
13468 char *kwnames[] = {
13469 (char *) "self", NULL
13470 };
13471
13472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
13473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13474 if (SWIG_arg_fail(1)) SWIG_fail;
13475 {
13476 PyThreadState* __tstate = wxPyBeginAllowThreads();
13477 result = (int)(arg1)->GetVMin();
13478
13479 wxPyEndAllowThreads(__tstate);
13480 if (PyErr_Occurred()) SWIG_fail;
13481 }
13482 {
13483 resultobj = SWIG_From_int(static_cast<int >(result));
13484 }
13485 return resultobj;
13486 fail:
13487 return NULL;
13488 }
13489
13490
13491 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
13492 PyObject *resultobj = NULL;
13493 wxJoystick *arg1 = (wxJoystick *) 0 ;
13494 int result;
13495 PyObject * obj0 = 0 ;
13496 char *kwnames[] = {
13497 (char *) "self", NULL
13498 };
13499
13500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
13501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13502 if (SWIG_arg_fail(1)) SWIG_fail;
13503 {
13504 PyThreadState* __tstate = wxPyBeginAllowThreads();
13505 result = (int)(arg1)->GetVMax();
13506
13507 wxPyEndAllowThreads(__tstate);
13508 if (PyErr_Occurred()) SWIG_fail;
13509 }
13510 {
13511 resultobj = SWIG_From_int(static_cast<int >(result));
13512 }
13513 return resultobj;
13514 fail:
13515 return NULL;
13516 }
13517
13518
13519 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
13520 PyObject *resultobj = NULL;
13521 wxJoystick *arg1 = (wxJoystick *) 0 ;
13522 bool result;
13523 PyObject * obj0 = 0 ;
13524 char *kwnames[] = {
13525 (char *) "self", NULL
13526 };
13527
13528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
13529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13530 if (SWIG_arg_fail(1)) SWIG_fail;
13531 {
13532 PyThreadState* __tstate = wxPyBeginAllowThreads();
13533 result = (bool)(arg1)->HasRudder();
13534
13535 wxPyEndAllowThreads(__tstate);
13536 if (PyErr_Occurred()) SWIG_fail;
13537 }
13538 {
13539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13540 }
13541 return resultobj;
13542 fail:
13543 return NULL;
13544 }
13545
13546
13547 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
13548 PyObject *resultobj = NULL;
13549 wxJoystick *arg1 = (wxJoystick *) 0 ;
13550 bool result;
13551 PyObject * obj0 = 0 ;
13552 char *kwnames[] = {
13553 (char *) "self", NULL
13554 };
13555
13556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
13557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13558 if (SWIG_arg_fail(1)) SWIG_fail;
13559 {
13560 PyThreadState* __tstate = wxPyBeginAllowThreads();
13561 result = (bool)(arg1)->HasZ();
13562
13563 wxPyEndAllowThreads(__tstate);
13564 if (PyErr_Occurred()) SWIG_fail;
13565 }
13566 {
13567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13568 }
13569 return resultobj;
13570 fail:
13571 return NULL;
13572 }
13573
13574
13575 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
13576 PyObject *resultobj = NULL;
13577 wxJoystick *arg1 = (wxJoystick *) 0 ;
13578 bool result;
13579 PyObject * obj0 = 0 ;
13580 char *kwnames[] = {
13581 (char *) "self", NULL
13582 };
13583
13584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
13585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13586 if (SWIG_arg_fail(1)) SWIG_fail;
13587 {
13588 PyThreadState* __tstate = wxPyBeginAllowThreads();
13589 result = (bool)(arg1)->HasU();
13590
13591 wxPyEndAllowThreads(__tstate);
13592 if (PyErr_Occurred()) SWIG_fail;
13593 }
13594 {
13595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13596 }
13597 return resultobj;
13598 fail:
13599 return NULL;
13600 }
13601
13602
13603 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
13604 PyObject *resultobj = NULL;
13605 wxJoystick *arg1 = (wxJoystick *) 0 ;
13606 bool result;
13607 PyObject * obj0 = 0 ;
13608 char *kwnames[] = {
13609 (char *) "self", NULL
13610 };
13611
13612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
13613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13614 if (SWIG_arg_fail(1)) SWIG_fail;
13615 {
13616 PyThreadState* __tstate = wxPyBeginAllowThreads();
13617 result = (bool)(arg1)->HasV();
13618
13619 wxPyEndAllowThreads(__tstate);
13620 if (PyErr_Occurred()) SWIG_fail;
13621 }
13622 {
13623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13624 }
13625 return resultobj;
13626 fail:
13627 return NULL;
13628 }
13629
13630
13631 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
13632 PyObject *resultobj = NULL;
13633 wxJoystick *arg1 = (wxJoystick *) 0 ;
13634 bool result;
13635 PyObject * obj0 = 0 ;
13636 char *kwnames[] = {
13637 (char *) "self", NULL
13638 };
13639
13640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
13641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13642 if (SWIG_arg_fail(1)) SWIG_fail;
13643 {
13644 PyThreadState* __tstate = wxPyBeginAllowThreads();
13645 result = (bool)(arg1)->HasPOV();
13646
13647 wxPyEndAllowThreads(__tstate);
13648 if (PyErr_Occurred()) SWIG_fail;
13649 }
13650 {
13651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13652 }
13653 return resultobj;
13654 fail:
13655 return NULL;
13656 }
13657
13658
13659 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
13660 PyObject *resultobj = NULL;
13661 wxJoystick *arg1 = (wxJoystick *) 0 ;
13662 bool result;
13663 PyObject * obj0 = 0 ;
13664 char *kwnames[] = {
13665 (char *) "self", NULL
13666 };
13667
13668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
13669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13670 if (SWIG_arg_fail(1)) SWIG_fail;
13671 {
13672 PyThreadState* __tstate = wxPyBeginAllowThreads();
13673 result = (bool)(arg1)->HasPOV4Dir();
13674
13675 wxPyEndAllowThreads(__tstate);
13676 if (PyErr_Occurred()) SWIG_fail;
13677 }
13678 {
13679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13680 }
13681 return resultobj;
13682 fail:
13683 return NULL;
13684 }
13685
13686
13687 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
13688 PyObject *resultobj = NULL;
13689 wxJoystick *arg1 = (wxJoystick *) 0 ;
13690 bool result;
13691 PyObject * obj0 = 0 ;
13692 char *kwnames[] = {
13693 (char *) "self", NULL
13694 };
13695
13696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
13697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13698 if (SWIG_arg_fail(1)) SWIG_fail;
13699 {
13700 PyThreadState* __tstate = wxPyBeginAllowThreads();
13701 result = (bool)(arg1)->HasPOVCTS();
13702
13703 wxPyEndAllowThreads(__tstate);
13704 if (PyErr_Occurred()) SWIG_fail;
13705 }
13706 {
13707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13708 }
13709 return resultobj;
13710 fail:
13711 return NULL;
13712 }
13713
13714
13715 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
13716 PyObject *resultobj = NULL;
13717 wxJoystick *arg1 = (wxJoystick *) 0 ;
13718 wxWindow *arg2 = (wxWindow *) 0 ;
13719 int arg3 = (int) 0 ;
13720 bool result;
13721 PyObject * obj0 = 0 ;
13722 PyObject * obj1 = 0 ;
13723 PyObject * obj2 = 0 ;
13724 char *kwnames[] = {
13725 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
13726 };
13727
13728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
13729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13730 if (SWIG_arg_fail(1)) SWIG_fail;
13731 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13732 if (SWIG_arg_fail(2)) SWIG_fail;
13733 if (obj2) {
13734 {
13735 arg3 = static_cast<int >(SWIG_As_int(obj2));
13736 if (SWIG_arg_fail(3)) SWIG_fail;
13737 }
13738 }
13739 {
13740 PyThreadState* __tstate = wxPyBeginAllowThreads();
13741 result = (bool)(arg1)->SetCapture(arg2,arg3);
13742
13743 wxPyEndAllowThreads(__tstate);
13744 if (PyErr_Occurred()) SWIG_fail;
13745 }
13746 {
13747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13748 }
13749 return resultobj;
13750 fail:
13751 return NULL;
13752 }
13753
13754
13755 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
13756 PyObject *resultobj = NULL;
13757 wxJoystick *arg1 = (wxJoystick *) 0 ;
13758 bool result;
13759 PyObject * obj0 = 0 ;
13760 char *kwnames[] = {
13761 (char *) "self", NULL
13762 };
13763
13764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
13765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13766 if (SWIG_arg_fail(1)) SWIG_fail;
13767 {
13768 PyThreadState* __tstate = wxPyBeginAllowThreads();
13769 result = (bool)(arg1)->ReleaseCapture();
13770
13771 wxPyEndAllowThreads(__tstate);
13772 if (PyErr_Occurred()) SWIG_fail;
13773 }
13774 {
13775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13776 }
13777 return resultobj;
13778 fail:
13779 return NULL;
13780 }
13781
13782
13783 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
13784 PyObject *obj;
13785 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13786 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
13787 Py_INCREF(obj);
13788 return Py_BuildValue((char *)"");
13789 }
13790 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
13791 PyObject *resultobj = NULL;
13792 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
13793 int arg2 = (int) 0 ;
13794 int arg3 = (int) wxJOYSTICK1 ;
13795 int arg4 = (int) 0 ;
13796 wxJoystickEvent *result;
13797 PyObject * obj0 = 0 ;
13798 PyObject * obj1 = 0 ;
13799 PyObject * obj2 = 0 ;
13800 PyObject * obj3 = 0 ;
13801 char *kwnames[] = {
13802 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
13803 };
13804
13805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13806 if (obj0) {
13807 {
13808 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
13809 if (SWIG_arg_fail(1)) SWIG_fail;
13810 }
13811 }
13812 if (obj1) {
13813 {
13814 arg2 = static_cast<int >(SWIG_As_int(obj1));
13815 if (SWIG_arg_fail(2)) SWIG_fail;
13816 }
13817 }
13818 if (obj2) {
13819 {
13820 arg3 = static_cast<int >(SWIG_As_int(obj2));
13821 if (SWIG_arg_fail(3)) SWIG_fail;
13822 }
13823 }
13824 if (obj3) {
13825 {
13826 arg4 = static_cast<int >(SWIG_As_int(obj3));
13827 if (SWIG_arg_fail(4)) SWIG_fail;
13828 }
13829 }
13830 {
13831 PyThreadState* __tstate = wxPyBeginAllowThreads();
13832 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
13833
13834 wxPyEndAllowThreads(__tstate);
13835 if (PyErr_Occurred()) SWIG_fail;
13836 }
13837 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
13838 return resultobj;
13839 fail:
13840 return NULL;
13841 }
13842
13843
13844 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13845 PyObject *resultobj = NULL;
13846 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13847 wxPoint result;
13848 PyObject * obj0 = 0 ;
13849 char *kwnames[] = {
13850 (char *) "self", NULL
13851 };
13852
13853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
13854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13855 if (SWIG_arg_fail(1)) SWIG_fail;
13856 {
13857 PyThreadState* __tstate = wxPyBeginAllowThreads();
13858 result = ((wxJoystickEvent const *)arg1)->GetPosition();
13859
13860 wxPyEndAllowThreads(__tstate);
13861 if (PyErr_Occurred()) SWIG_fail;
13862 }
13863 {
13864 wxPoint * resultptr;
13865 resultptr = new wxPoint(static_cast<wxPoint & >(result));
13866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
13867 }
13868 return resultobj;
13869 fail:
13870 return NULL;
13871 }
13872
13873
13874 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13875 PyObject *resultobj = NULL;
13876 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13877 int result;
13878 PyObject * obj0 = 0 ;
13879 char *kwnames[] = {
13880 (char *) "self", NULL
13881 };
13882
13883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
13884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13885 if (SWIG_arg_fail(1)) SWIG_fail;
13886 {
13887 PyThreadState* __tstate = wxPyBeginAllowThreads();
13888 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
13889
13890 wxPyEndAllowThreads(__tstate);
13891 if (PyErr_Occurred()) SWIG_fail;
13892 }
13893 {
13894 resultobj = SWIG_From_int(static_cast<int >(result));
13895 }
13896 return resultobj;
13897 fail:
13898 return NULL;
13899 }
13900
13901
13902 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13903 PyObject *resultobj = NULL;
13904 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13905 int result;
13906 PyObject * obj0 = 0 ;
13907 char *kwnames[] = {
13908 (char *) "self", NULL
13909 };
13910
13911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13913 if (SWIG_arg_fail(1)) SWIG_fail;
13914 {
13915 PyThreadState* __tstate = wxPyBeginAllowThreads();
13916 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13917
13918 wxPyEndAllowThreads(__tstate);
13919 if (PyErr_Occurred()) SWIG_fail;
13920 }
13921 {
13922 resultobj = SWIG_From_int(static_cast<int >(result));
13923 }
13924 return resultobj;
13925 fail:
13926 return NULL;
13927 }
13928
13929
13930 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13931 PyObject *resultobj = NULL;
13932 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13933 int result;
13934 PyObject * obj0 = 0 ;
13935 char *kwnames[] = {
13936 (char *) "self", NULL
13937 };
13938
13939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13941 if (SWIG_arg_fail(1)) SWIG_fail;
13942 {
13943 PyThreadState* __tstate = wxPyBeginAllowThreads();
13944 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13945
13946 wxPyEndAllowThreads(__tstate);
13947 if (PyErr_Occurred()) SWIG_fail;
13948 }
13949 {
13950 resultobj = SWIG_From_int(static_cast<int >(result));
13951 }
13952 return resultobj;
13953 fail:
13954 return NULL;
13955 }
13956
13957
13958 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13959 PyObject *resultobj = NULL;
13960 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13961 int result;
13962 PyObject * obj0 = 0 ;
13963 char *kwnames[] = {
13964 (char *) "self", NULL
13965 };
13966
13967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13969 if (SWIG_arg_fail(1)) SWIG_fail;
13970 {
13971 PyThreadState* __tstate = wxPyBeginAllowThreads();
13972 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13973
13974 wxPyEndAllowThreads(__tstate);
13975 if (PyErr_Occurred()) SWIG_fail;
13976 }
13977 {
13978 resultobj = SWIG_From_int(static_cast<int >(result));
13979 }
13980 return resultobj;
13981 fail:
13982 return NULL;
13983 }
13984
13985
13986 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13987 PyObject *resultobj = NULL;
13988 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13989 int arg2 ;
13990 PyObject * obj0 = 0 ;
13991 PyObject * obj1 = 0 ;
13992 char *kwnames[] = {
13993 (char *) "self",(char *) "stick", NULL
13994 };
13995
13996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13998 if (SWIG_arg_fail(1)) SWIG_fail;
13999 {
14000 arg2 = static_cast<int >(SWIG_As_int(obj1));
14001 if (SWIG_arg_fail(2)) SWIG_fail;
14002 }
14003 {
14004 PyThreadState* __tstate = wxPyBeginAllowThreads();
14005 (arg1)->SetJoystick(arg2);
14006
14007 wxPyEndAllowThreads(__tstate);
14008 if (PyErr_Occurred()) SWIG_fail;
14009 }
14010 Py_INCREF(Py_None); resultobj = Py_None;
14011 return resultobj;
14012 fail:
14013 return NULL;
14014 }
14015
14016
14017 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
14018 PyObject *resultobj = NULL;
14019 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14020 int arg2 ;
14021 PyObject * obj0 = 0 ;
14022 PyObject * obj1 = 0 ;
14023 char *kwnames[] = {
14024 (char *) "self",(char *) "state", NULL
14025 };
14026
14027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
14028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14029 if (SWIG_arg_fail(1)) SWIG_fail;
14030 {
14031 arg2 = static_cast<int >(SWIG_As_int(obj1));
14032 if (SWIG_arg_fail(2)) SWIG_fail;
14033 }
14034 {
14035 PyThreadState* __tstate = wxPyBeginAllowThreads();
14036 (arg1)->SetButtonState(arg2);
14037
14038 wxPyEndAllowThreads(__tstate);
14039 if (PyErr_Occurred()) SWIG_fail;
14040 }
14041 Py_INCREF(Py_None); resultobj = Py_None;
14042 return resultobj;
14043 fail:
14044 return NULL;
14045 }
14046
14047
14048 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
14049 PyObject *resultobj = NULL;
14050 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14051 int arg2 ;
14052 PyObject * obj0 = 0 ;
14053 PyObject * obj1 = 0 ;
14054 char *kwnames[] = {
14055 (char *) "self",(char *) "change", NULL
14056 };
14057
14058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
14059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14060 if (SWIG_arg_fail(1)) SWIG_fail;
14061 {
14062 arg2 = static_cast<int >(SWIG_As_int(obj1));
14063 if (SWIG_arg_fail(2)) SWIG_fail;
14064 }
14065 {
14066 PyThreadState* __tstate = wxPyBeginAllowThreads();
14067 (arg1)->SetButtonChange(arg2);
14068
14069 wxPyEndAllowThreads(__tstate);
14070 if (PyErr_Occurred()) SWIG_fail;
14071 }
14072 Py_INCREF(Py_None); resultobj = Py_None;
14073 return resultobj;
14074 fail:
14075 return NULL;
14076 }
14077
14078
14079 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
14080 PyObject *resultobj = NULL;
14081 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14082 wxPoint *arg2 = 0 ;
14083 wxPoint temp2 ;
14084 PyObject * obj0 = 0 ;
14085 PyObject * obj1 = 0 ;
14086 char *kwnames[] = {
14087 (char *) "self",(char *) "pos", NULL
14088 };
14089
14090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
14091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14092 if (SWIG_arg_fail(1)) SWIG_fail;
14093 {
14094 arg2 = &temp2;
14095 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14096 }
14097 {
14098 PyThreadState* __tstate = wxPyBeginAllowThreads();
14099 (arg1)->SetPosition((wxPoint const &)*arg2);
14100
14101 wxPyEndAllowThreads(__tstate);
14102 if (PyErr_Occurred()) SWIG_fail;
14103 }
14104 Py_INCREF(Py_None); resultobj = Py_None;
14105 return resultobj;
14106 fail:
14107 return NULL;
14108 }
14109
14110
14111 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
14112 PyObject *resultobj = NULL;
14113 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14114 int arg2 ;
14115 PyObject * obj0 = 0 ;
14116 PyObject * obj1 = 0 ;
14117 char *kwnames[] = {
14118 (char *) "self",(char *) "zPos", NULL
14119 };
14120
14121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
14122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14123 if (SWIG_arg_fail(1)) SWIG_fail;
14124 {
14125 arg2 = static_cast<int >(SWIG_As_int(obj1));
14126 if (SWIG_arg_fail(2)) SWIG_fail;
14127 }
14128 {
14129 PyThreadState* __tstate = wxPyBeginAllowThreads();
14130 (arg1)->SetZPosition(arg2);
14131
14132 wxPyEndAllowThreads(__tstate);
14133 if (PyErr_Occurred()) SWIG_fail;
14134 }
14135 Py_INCREF(Py_None); resultobj = Py_None;
14136 return resultobj;
14137 fail:
14138 return NULL;
14139 }
14140
14141
14142 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
14143 PyObject *resultobj = NULL;
14144 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14145 bool result;
14146 PyObject * obj0 = 0 ;
14147 char *kwnames[] = {
14148 (char *) "self", NULL
14149 };
14150
14151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
14152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14153 if (SWIG_arg_fail(1)) SWIG_fail;
14154 {
14155 PyThreadState* __tstate = wxPyBeginAllowThreads();
14156 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
14157
14158 wxPyEndAllowThreads(__tstate);
14159 if (PyErr_Occurred()) SWIG_fail;
14160 }
14161 {
14162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14163 }
14164 return resultobj;
14165 fail:
14166 return NULL;
14167 }
14168
14169
14170 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
14171 PyObject *resultobj = NULL;
14172 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14173 bool result;
14174 PyObject * obj0 = 0 ;
14175 char *kwnames[] = {
14176 (char *) "self", NULL
14177 };
14178
14179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
14180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14181 if (SWIG_arg_fail(1)) SWIG_fail;
14182 {
14183 PyThreadState* __tstate = wxPyBeginAllowThreads();
14184 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
14185
14186 wxPyEndAllowThreads(__tstate);
14187 if (PyErr_Occurred()) SWIG_fail;
14188 }
14189 {
14190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14191 }
14192 return resultobj;
14193 fail:
14194 return NULL;
14195 }
14196
14197
14198 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
14199 PyObject *resultobj = NULL;
14200 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14201 bool result;
14202 PyObject * obj0 = 0 ;
14203 char *kwnames[] = {
14204 (char *) "self", NULL
14205 };
14206
14207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
14208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14209 if (SWIG_arg_fail(1)) SWIG_fail;
14210 {
14211 PyThreadState* __tstate = wxPyBeginAllowThreads();
14212 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
14213
14214 wxPyEndAllowThreads(__tstate);
14215 if (PyErr_Occurred()) SWIG_fail;
14216 }
14217 {
14218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14219 }
14220 return resultobj;
14221 fail:
14222 return NULL;
14223 }
14224
14225
14226 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
14227 PyObject *resultobj = NULL;
14228 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14229 int arg2 = (int) wxJOY_BUTTON_ANY ;
14230 bool result;
14231 PyObject * obj0 = 0 ;
14232 PyObject * obj1 = 0 ;
14233 char *kwnames[] = {
14234 (char *) "self",(char *) "but", NULL
14235 };
14236
14237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
14238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14239 if (SWIG_arg_fail(1)) SWIG_fail;
14240 if (obj1) {
14241 {
14242 arg2 = static_cast<int >(SWIG_As_int(obj1));
14243 if (SWIG_arg_fail(2)) SWIG_fail;
14244 }
14245 }
14246 {
14247 PyThreadState* __tstate = wxPyBeginAllowThreads();
14248 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
14249
14250 wxPyEndAllowThreads(__tstate);
14251 if (PyErr_Occurred()) SWIG_fail;
14252 }
14253 {
14254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14255 }
14256 return resultobj;
14257 fail:
14258 return NULL;
14259 }
14260
14261
14262 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
14263 PyObject *resultobj = NULL;
14264 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14265 int arg2 = (int) wxJOY_BUTTON_ANY ;
14266 bool result;
14267 PyObject * obj0 = 0 ;
14268 PyObject * obj1 = 0 ;
14269 char *kwnames[] = {
14270 (char *) "self",(char *) "but", NULL
14271 };
14272
14273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
14274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14275 if (SWIG_arg_fail(1)) SWIG_fail;
14276 if (obj1) {
14277 {
14278 arg2 = static_cast<int >(SWIG_As_int(obj1));
14279 if (SWIG_arg_fail(2)) SWIG_fail;
14280 }
14281 }
14282 {
14283 PyThreadState* __tstate = wxPyBeginAllowThreads();
14284 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
14285
14286 wxPyEndAllowThreads(__tstate);
14287 if (PyErr_Occurred()) SWIG_fail;
14288 }
14289 {
14290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14291 }
14292 return resultobj;
14293 fail:
14294 return NULL;
14295 }
14296
14297
14298 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
14299 PyObject *resultobj = NULL;
14300 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14301 int arg2 = (int) wxJOY_BUTTON_ANY ;
14302 bool result;
14303 PyObject * obj0 = 0 ;
14304 PyObject * obj1 = 0 ;
14305 char *kwnames[] = {
14306 (char *) "self",(char *) "but", NULL
14307 };
14308
14309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
14310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14311 if (SWIG_arg_fail(1)) SWIG_fail;
14312 if (obj1) {
14313 {
14314 arg2 = static_cast<int >(SWIG_As_int(obj1));
14315 if (SWIG_arg_fail(2)) SWIG_fail;
14316 }
14317 }
14318 {
14319 PyThreadState* __tstate = wxPyBeginAllowThreads();
14320 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
14321
14322 wxPyEndAllowThreads(__tstate);
14323 if (PyErr_Occurred()) SWIG_fail;
14324 }
14325 {
14326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14327 }
14328 return resultobj;
14329 fail:
14330 return NULL;
14331 }
14332
14333
14334 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
14335 PyObject *obj;
14336 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14337 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
14338 Py_INCREF(obj);
14339 return Py_BuildValue((char *)"");
14340 }
14341 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
14342 PyObject *resultobj = NULL;
14343 wxString const &arg1_defvalue = wxPyEmptyString ;
14344 wxString *arg1 = (wxString *) &arg1_defvalue ;
14345 wxSound *result;
14346 bool temp1 = false ;
14347 PyObject * obj0 = 0 ;
14348 char *kwnames[] = {
14349 (char *) "fileName", NULL
14350 };
14351
14352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
14353 if (obj0) {
14354 {
14355 arg1 = wxString_in_helper(obj0);
14356 if (arg1 == NULL) SWIG_fail;
14357 temp1 = true;
14358 }
14359 }
14360 {
14361 if (!wxPyCheckForApp()) SWIG_fail;
14362 PyThreadState* __tstate = wxPyBeginAllowThreads();
14363 result = (wxSound *)new_wxSound((wxString const &)*arg1);
14364
14365 wxPyEndAllowThreads(__tstate);
14366 if (PyErr_Occurred()) SWIG_fail;
14367 }
14368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
14369 {
14370 if (temp1)
14371 delete arg1;
14372 }
14373 return resultobj;
14374 fail:
14375 {
14376 if (temp1)
14377 delete arg1;
14378 }
14379 return NULL;
14380 }
14381
14382
14383 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
14384 PyObject *resultobj = NULL;
14385 PyObject *arg1 = (PyObject *) 0 ;
14386 wxSound *result;
14387 PyObject * obj0 = 0 ;
14388 char *kwnames[] = {
14389 (char *) "data", NULL
14390 };
14391
14392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
14393 arg1 = obj0;
14394 {
14395 if (!wxPyCheckForApp()) SWIG_fail;
14396 PyThreadState* __tstate = wxPyBeginAllowThreads();
14397 result = (wxSound *)new_wxSound(arg1);
14398
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
14403 return resultobj;
14404 fail:
14405 return NULL;
14406 }
14407
14408
14409 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
14410 PyObject *resultobj = NULL;
14411 wxSound *arg1 = (wxSound *) 0 ;
14412 PyObject * obj0 = 0 ;
14413 char *kwnames[] = {
14414 (char *) "self", NULL
14415 };
14416
14417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
14418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14419 if (SWIG_arg_fail(1)) SWIG_fail;
14420 {
14421 PyThreadState* __tstate = wxPyBeginAllowThreads();
14422 delete arg1;
14423
14424 wxPyEndAllowThreads(__tstate);
14425 if (PyErr_Occurred()) SWIG_fail;
14426 }
14427 Py_INCREF(Py_None); resultobj = Py_None;
14428 return resultobj;
14429 fail:
14430 return NULL;
14431 }
14432
14433
14434 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
14435 PyObject *resultobj = NULL;
14436 wxSound *arg1 = (wxSound *) 0 ;
14437 wxString *arg2 = 0 ;
14438 bool result;
14439 bool temp2 = false ;
14440 PyObject * obj0 = 0 ;
14441 PyObject * obj1 = 0 ;
14442 char *kwnames[] = {
14443 (char *) "self",(char *) "fileName", NULL
14444 };
14445
14446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
14447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14448 if (SWIG_arg_fail(1)) SWIG_fail;
14449 {
14450 arg2 = wxString_in_helper(obj1);
14451 if (arg2 == NULL) SWIG_fail;
14452 temp2 = true;
14453 }
14454 {
14455 PyThreadState* __tstate = wxPyBeginAllowThreads();
14456 result = (bool)(arg1)->Create((wxString const &)*arg2);
14457
14458 wxPyEndAllowThreads(__tstate);
14459 if (PyErr_Occurred()) SWIG_fail;
14460 }
14461 {
14462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14463 }
14464 {
14465 if (temp2)
14466 delete arg2;
14467 }
14468 return resultobj;
14469 fail:
14470 {
14471 if (temp2)
14472 delete arg2;
14473 }
14474 return NULL;
14475 }
14476
14477
14478 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
14479 PyObject *resultobj = NULL;
14480 wxSound *arg1 = (wxSound *) 0 ;
14481 PyObject *arg2 = (PyObject *) 0 ;
14482 bool result;
14483 PyObject * obj0 = 0 ;
14484 PyObject * obj1 = 0 ;
14485 char *kwnames[] = {
14486 (char *) "self",(char *) "data", NULL
14487 };
14488
14489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
14490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14491 if (SWIG_arg_fail(1)) SWIG_fail;
14492 arg2 = obj1;
14493 {
14494 PyThreadState* __tstate = wxPyBeginAllowThreads();
14495 result = (bool)wxSound_CreateFromData(arg1,arg2);
14496
14497 wxPyEndAllowThreads(__tstate);
14498 if (PyErr_Occurred()) SWIG_fail;
14499 }
14500 {
14501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14502 }
14503 return resultobj;
14504 fail:
14505 return NULL;
14506 }
14507
14508
14509 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
14510 PyObject *resultobj = NULL;
14511 wxSound *arg1 = (wxSound *) 0 ;
14512 bool result;
14513 PyObject * obj0 = 0 ;
14514 char *kwnames[] = {
14515 (char *) "self", NULL
14516 };
14517
14518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
14519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14520 if (SWIG_arg_fail(1)) SWIG_fail;
14521 {
14522 PyThreadState* __tstate = wxPyBeginAllowThreads();
14523 result = (bool)(arg1)->IsOk();
14524
14525 wxPyEndAllowThreads(__tstate);
14526 if (PyErr_Occurred()) SWIG_fail;
14527 }
14528 {
14529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14530 }
14531 return resultobj;
14532 fail:
14533 return NULL;
14534 }
14535
14536
14537 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
14538 PyObject *resultobj = NULL;
14539 wxSound *arg1 = (wxSound *) 0 ;
14540 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
14541 bool result;
14542 PyObject * obj0 = 0 ;
14543 PyObject * obj1 = 0 ;
14544 char *kwnames[] = {
14545 (char *) "self",(char *) "flags", NULL
14546 };
14547
14548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
14549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14550 if (SWIG_arg_fail(1)) SWIG_fail;
14551 if (obj1) {
14552 {
14553 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
14554 if (SWIG_arg_fail(2)) SWIG_fail;
14555 }
14556 }
14557 {
14558 if (!wxPyCheckForApp()) SWIG_fail;
14559 PyThreadState* __tstate = wxPyBeginAllowThreads();
14560 result = (bool)((wxSound const *)arg1)->Play(arg2);
14561
14562 wxPyEndAllowThreads(__tstate);
14563 if (PyErr_Occurred()) SWIG_fail;
14564 }
14565 {
14566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14567 }
14568 return resultobj;
14569 fail:
14570 return NULL;
14571 }
14572
14573
14574 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
14575 PyObject *resultobj = NULL;
14576 wxString *arg1 = 0 ;
14577 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
14578 bool result;
14579 bool temp1 = false ;
14580 PyObject * obj0 = 0 ;
14581 PyObject * obj1 = 0 ;
14582 char *kwnames[] = {
14583 (char *) "filename",(char *) "flags", NULL
14584 };
14585
14586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
14587 {
14588 arg1 = wxString_in_helper(obj0);
14589 if (arg1 == NULL) SWIG_fail;
14590 temp1 = true;
14591 }
14592 if (obj1) {
14593 {
14594 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
14595 if (SWIG_arg_fail(2)) SWIG_fail;
14596 }
14597 }
14598 {
14599 if (!wxPyCheckForApp()) SWIG_fail;
14600 PyThreadState* __tstate = wxPyBeginAllowThreads();
14601 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
14602
14603 wxPyEndAllowThreads(__tstate);
14604 if (PyErr_Occurred()) SWIG_fail;
14605 }
14606 {
14607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14608 }
14609 {
14610 if (temp1)
14611 delete arg1;
14612 }
14613 return resultobj;
14614 fail:
14615 {
14616 if (temp1)
14617 delete arg1;
14618 }
14619 return NULL;
14620 }
14621
14622
14623 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
14624 PyObject *resultobj = NULL;
14625 char *kwnames[] = {
14626 NULL
14627 };
14628
14629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
14630 {
14631 if (!wxPyCheckForApp()) SWIG_fail;
14632 PyThreadState* __tstate = wxPyBeginAllowThreads();
14633 wxSound::Stop();
14634
14635 wxPyEndAllowThreads(__tstate);
14636 if (PyErr_Occurred()) SWIG_fail;
14637 }
14638 Py_INCREF(Py_None); resultobj = Py_None;
14639 return resultobj;
14640 fail:
14641 return NULL;
14642 }
14643
14644
14645 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
14646 PyObject *obj;
14647 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14648 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
14649 Py_INCREF(obj);
14650 return Py_BuildValue((char *)"");
14651 }
14652 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14653 PyObject *resultobj = NULL;
14654 wxString *arg1 = 0 ;
14655 wxString *arg2 = 0 ;
14656 wxString *arg3 = 0 ;
14657 wxString *arg4 = 0 ;
14658 wxFileTypeInfo *result;
14659 bool temp1 = false ;
14660 bool temp2 = false ;
14661 bool temp3 = false ;
14662 bool temp4 = false ;
14663 PyObject * obj0 = 0 ;
14664 PyObject * obj1 = 0 ;
14665 PyObject * obj2 = 0 ;
14666 PyObject * obj3 = 0 ;
14667 char *kwnames[] = {
14668 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
14669 };
14670
14671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14672 {
14673 arg1 = wxString_in_helper(obj0);
14674 if (arg1 == NULL) SWIG_fail;
14675 temp1 = true;
14676 }
14677 {
14678 arg2 = wxString_in_helper(obj1);
14679 if (arg2 == NULL) SWIG_fail;
14680 temp2 = true;
14681 }
14682 {
14683 arg3 = wxString_in_helper(obj2);
14684 if (arg3 == NULL) SWIG_fail;
14685 temp3 = true;
14686 }
14687 {
14688 arg4 = wxString_in_helper(obj3);
14689 if (arg4 == NULL) SWIG_fail;
14690 temp4 = true;
14691 }
14692 {
14693 PyThreadState* __tstate = wxPyBeginAllowThreads();
14694 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
14695
14696 wxPyEndAllowThreads(__tstate);
14697 if (PyErr_Occurred()) SWIG_fail;
14698 }
14699 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
14700 {
14701 if (temp1)
14702 delete arg1;
14703 }
14704 {
14705 if (temp2)
14706 delete arg2;
14707 }
14708 {
14709 if (temp3)
14710 delete arg3;
14711 }
14712 {
14713 if (temp4)
14714 delete arg4;
14715 }
14716 return resultobj;
14717 fail:
14718 {
14719 if (temp1)
14720 delete arg1;
14721 }
14722 {
14723 if (temp2)
14724 delete arg2;
14725 }
14726 {
14727 if (temp3)
14728 delete arg3;
14729 }
14730 {
14731 if (temp4)
14732 delete arg4;
14733 }
14734 return NULL;
14735 }
14736
14737
14738 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
14739 PyObject *resultobj = NULL;
14740 wxArrayString *arg1 = 0 ;
14741 wxFileTypeInfo *result;
14742 bool temp1 = false ;
14743 PyObject * obj0 = 0 ;
14744 char *kwnames[] = {
14745 (char *) "sArray", NULL
14746 };
14747
14748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
14749 {
14750 if (! PySequence_Check(obj0)) {
14751 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
14752 SWIG_fail;
14753 }
14754 arg1 = new wxArrayString;
14755 temp1 = true;
14756 int i, len=PySequence_Length(obj0);
14757 for (i=0; i<len; i++) {
14758 PyObject* item = PySequence_GetItem(obj0, i);
14759 wxString* s = wxString_in_helper(item);
14760 if (PyErr_Occurred()) SWIG_fail;
14761 arg1->Add(*s);
14762 delete s;
14763 Py_DECREF(item);
14764 }
14765 }
14766 {
14767 PyThreadState* __tstate = wxPyBeginAllowThreads();
14768 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
14769
14770 wxPyEndAllowThreads(__tstate);
14771 if (PyErr_Occurred()) SWIG_fail;
14772 }
14773 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
14774 {
14775 if (temp1) delete arg1;
14776 }
14777 return resultobj;
14778 fail:
14779 {
14780 if (temp1) delete arg1;
14781 }
14782 return NULL;
14783 }
14784
14785
14786 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14787 PyObject *resultobj = NULL;
14788 wxFileTypeInfo *result;
14789 char *kwnames[] = {
14790 NULL
14791 };
14792
14793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
14794 {
14795 PyThreadState* __tstate = wxPyBeginAllowThreads();
14796 result = (wxFileTypeInfo *)new wxFileTypeInfo();
14797
14798 wxPyEndAllowThreads(__tstate);
14799 if (PyErr_Occurred()) SWIG_fail;
14800 }
14801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
14802 return resultobj;
14803 fail:
14804 return NULL;
14805 }
14806
14807
14808 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
14809 PyObject *resultobj = NULL;
14810 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14811 bool result;
14812 PyObject * obj0 = 0 ;
14813 char *kwnames[] = {
14814 (char *) "self", NULL
14815 };
14816
14817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
14818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14819 if (SWIG_arg_fail(1)) SWIG_fail;
14820 {
14821 PyThreadState* __tstate = wxPyBeginAllowThreads();
14822 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
14823
14824 wxPyEndAllowThreads(__tstate);
14825 if (PyErr_Occurred()) SWIG_fail;
14826 }
14827 {
14828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14829 }
14830 return resultobj;
14831 fail:
14832 return NULL;
14833 }
14834
14835
14836 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14837 PyObject *resultobj = NULL;
14838 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14839 wxString *arg2 = 0 ;
14840 int arg3 = (int) 0 ;
14841 bool temp2 = false ;
14842 PyObject * obj0 = 0 ;
14843 PyObject * obj1 = 0 ;
14844 PyObject * obj2 = 0 ;
14845 char *kwnames[] = {
14846 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
14847 };
14848
14849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14851 if (SWIG_arg_fail(1)) SWIG_fail;
14852 {
14853 arg2 = wxString_in_helper(obj1);
14854 if (arg2 == NULL) SWIG_fail;
14855 temp2 = true;
14856 }
14857 if (obj2) {
14858 {
14859 arg3 = static_cast<int >(SWIG_As_int(obj2));
14860 if (SWIG_arg_fail(3)) SWIG_fail;
14861 }
14862 }
14863 {
14864 PyThreadState* __tstate = wxPyBeginAllowThreads();
14865 (arg1)->SetIcon((wxString const &)*arg2,arg3);
14866
14867 wxPyEndAllowThreads(__tstate);
14868 if (PyErr_Occurred()) SWIG_fail;
14869 }
14870 Py_INCREF(Py_None); resultobj = Py_None;
14871 {
14872 if (temp2)
14873 delete arg2;
14874 }
14875 return resultobj;
14876 fail:
14877 {
14878 if (temp2)
14879 delete arg2;
14880 }
14881 return NULL;
14882 }
14883
14884
14885 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14886 PyObject *resultobj = NULL;
14887 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14888 wxString *arg2 = 0 ;
14889 bool temp2 = false ;
14890 PyObject * obj0 = 0 ;
14891 PyObject * obj1 = 0 ;
14892 char *kwnames[] = {
14893 (char *) "self",(char *) "shortDesc", NULL
14894 };
14895
14896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
14897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14898 if (SWIG_arg_fail(1)) SWIG_fail;
14899 {
14900 arg2 = wxString_in_helper(obj1);
14901 if (arg2 == NULL) SWIG_fail;
14902 temp2 = true;
14903 }
14904 {
14905 PyThreadState* __tstate = wxPyBeginAllowThreads();
14906 (arg1)->SetShortDesc((wxString const &)*arg2);
14907
14908 wxPyEndAllowThreads(__tstate);
14909 if (PyErr_Occurred()) SWIG_fail;
14910 }
14911 Py_INCREF(Py_None); resultobj = Py_None;
14912 {
14913 if (temp2)
14914 delete arg2;
14915 }
14916 return resultobj;
14917 fail:
14918 {
14919 if (temp2)
14920 delete arg2;
14921 }
14922 return NULL;
14923 }
14924
14925
14926 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14927 PyObject *resultobj = NULL;
14928 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14929 wxString *result;
14930 PyObject * obj0 = 0 ;
14931 char *kwnames[] = {
14932 (char *) "self", NULL
14933 };
14934
14935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14937 if (SWIG_arg_fail(1)) SWIG_fail;
14938 {
14939 PyThreadState* __tstate = wxPyBeginAllowThreads();
14940 {
14941 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14942 result = (wxString *) &_result_ref;
14943 }
14944
14945 wxPyEndAllowThreads(__tstate);
14946 if (PyErr_Occurred()) SWIG_fail;
14947 }
14948 {
14949 #if wxUSE_UNICODE
14950 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14951 #else
14952 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14953 #endif
14954 }
14955 return resultobj;
14956 fail:
14957 return NULL;
14958 }
14959
14960
14961 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14962 PyObject *resultobj = NULL;
14963 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14964 wxString *result;
14965 PyObject * obj0 = 0 ;
14966 char *kwnames[] = {
14967 (char *) "self", NULL
14968 };
14969
14970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14972 if (SWIG_arg_fail(1)) SWIG_fail;
14973 {
14974 PyThreadState* __tstate = wxPyBeginAllowThreads();
14975 {
14976 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14977 result = (wxString *) &_result_ref;
14978 }
14979
14980 wxPyEndAllowThreads(__tstate);
14981 if (PyErr_Occurred()) SWIG_fail;
14982 }
14983 {
14984 #if wxUSE_UNICODE
14985 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14986 #else
14987 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14988 #endif
14989 }
14990 return resultobj;
14991 fail:
14992 return NULL;
14993 }
14994
14995
14996 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14997 PyObject *resultobj = NULL;
14998 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14999 wxString *result;
15000 PyObject * obj0 = 0 ;
15001 char *kwnames[] = {
15002 (char *) "self", NULL
15003 };
15004
15005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
15006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15007 if (SWIG_arg_fail(1)) SWIG_fail;
15008 {
15009 PyThreadState* __tstate = wxPyBeginAllowThreads();
15010 {
15011 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
15012 result = (wxString *) &_result_ref;
15013 }
15014
15015 wxPyEndAllowThreads(__tstate);
15016 if (PyErr_Occurred()) SWIG_fail;
15017 }
15018 {
15019 #if wxUSE_UNICODE
15020 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15021 #else
15022 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15023 #endif
15024 }
15025 return resultobj;
15026 fail:
15027 return NULL;
15028 }
15029
15030
15031 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
15032 PyObject *resultobj = NULL;
15033 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15034 wxString *result;
15035 PyObject * obj0 = 0 ;
15036 char *kwnames[] = {
15037 (char *) "self", NULL
15038 };
15039
15040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
15041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15042 if (SWIG_arg_fail(1)) SWIG_fail;
15043 {
15044 PyThreadState* __tstate = wxPyBeginAllowThreads();
15045 {
15046 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
15047 result = (wxString *) &_result_ref;
15048 }
15049
15050 wxPyEndAllowThreads(__tstate);
15051 if (PyErr_Occurred()) SWIG_fail;
15052 }
15053 {
15054 #if wxUSE_UNICODE
15055 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15056 #else
15057 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15058 #endif
15059 }
15060 return resultobj;
15061 fail:
15062 return NULL;
15063 }
15064
15065
15066 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
15067 PyObject *resultobj = NULL;
15068 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15069 wxString *result;
15070 PyObject * obj0 = 0 ;
15071 char *kwnames[] = {
15072 (char *) "self", NULL
15073 };
15074
15075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
15076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15077 if (SWIG_arg_fail(1)) SWIG_fail;
15078 {
15079 PyThreadState* __tstate = wxPyBeginAllowThreads();
15080 {
15081 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
15082 result = (wxString *) &_result_ref;
15083 }
15084
15085 wxPyEndAllowThreads(__tstate);
15086 if (PyErr_Occurred()) SWIG_fail;
15087 }
15088 {
15089 #if wxUSE_UNICODE
15090 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15091 #else
15092 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15093 #endif
15094 }
15095 return resultobj;
15096 fail:
15097 return NULL;
15098 }
15099
15100
15101 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
15102 PyObject *resultobj = NULL;
15103 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15104 wxArrayString *result;
15105 PyObject * obj0 = 0 ;
15106 char *kwnames[] = {
15107 (char *) "self", NULL
15108 };
15109
15110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
15111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15112 if (SWIG_arg_fail(1)) SWIG_fail;
15113 {
15114 PyThreadState* __tstate = wxPyBeginAllowThreads();
15115 {
15116 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
15117 result = (wxArrayString *) &_result_ref;
15118 }
15119
15120 wxPyEndAllowThreads(__tstate);
15121 if (PyErr_Occurred()) SWIG_fail;
15122 }
15123 {
15124 resultobj = wxArrayString2PyList_helper(*result);
15125 }
15126 return resultobj;
15127 fail:
15128 return NULL;
15129 }
15130
15131
15132 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
15133 PyObject *resultobj = NULL;
15134 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15135 int result;
15136 PyObject * obj0 = 0 ;
15137 char *kwnames[] = {
15138 (char *) "self", NULL
15139 };
15140
15141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
15142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15143 if (SWIG_arg_fail(1)) SWIG_fail;
15144 {
15145 PyThreadState* __tstate = wxPyBeginAllowThreads();
15146 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
15147
15148 wxPyEndAllowThreads(__tstate);
15149 if (PyErr_Occurred()) SWIG_fail;
15150 }
15151 {
15152 resultobj = SWIG_From_int(static_cast<int >(result));
15153 }
15154 return resultobj;
15155 fail:
15156 return NULL;
15157 }
15158
15159
15160 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
15161 PyObject *resultobj = NULL;
15162 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15163 wxString *result;
15164 PyObject * obj0 = 0 ;
15165 char *kwnames[] = {
15166 (char *) "self", NULL
15167 };
15168
15169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
15170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15171 if (SWIG_arg_fail(1)) SWIG_fail;
15172 {
15173 PyThreadState* __tstate = wxPyBeginAllowThreads();
15174 {
15175 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
15176 result = (wxString *) &_result_ref;
15177 }
15178
15179 wxPyEndAllowThreads(__tstate);
15180 if (PyErr_Occurred()) SWIG_fail;
15181 }
15182 {
15183 #if wxUSE_UNICODE
15184 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15185 #else
15186 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15187 #endif
15188 }
15189 return resultobj;
15190 fail:
15191 return NULL;
15192 }
15193
15194
15195 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
15196 PyObject *resultobj = NULL;
15197 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15198 int result;
15199 PyObject * obj0 = 0 ;
15200 char *kwnames[] = {
15201 (char *) "self", NULL
15202 };
15203
15204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
15205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15206 if (SWIG_arg_fail(1)) SWIG_fail;
15207 {
15208 PyThreadState* __tstate = wxPyBeginAllowThreads();
15209 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
15210
15211 wxPyEndAllowThreads(__tstate);
15212 if (PyErr_Occurred()) SWIG_fail;
15213 }
15214 {
15215 resultobj = SWIG_From_int(static_cast<int >(result));
15216 }
15217 return resultobj;
15218 fail:
15219 return NULL;
15220 }
15221
15222
15223 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
15224 PyObject *obj;
15225 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15226 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
15227 Py_INCREF(obj);
15228 return Py_BuildValue((char *)"");
15229 }
15230 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
15231 PyObject *resultobj = NULL;
15232 wxFileTypeInfo *arg1 = 0 ;
15233 wxFileType *result;
15234 PyObject * obj0 = 0 ;
15235 char *kwnames[] = {
15236 (char *) "ftInfo", NULL
15237 };
15238
15239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
15240 {
15241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15242 if (SWIG_arg_fail(1)) SWIG_fail;
15243 if (arg1 == NULL) {
15244 SWIG_null_ref("wxFileTypeInfo");
15245 }
15246 if (SWIG_arg_fail(1)) SWIG_fail;
15247 }
15248 {
15249 PyThreadState* __tstate = wxPyBeginAllowThreads();
15250 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
15251
15252 wxPyEndAllowThreads(__tstate);
15253 if (PyErr_Occurred()) SWIG_fail;
15254 }
15255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15256 return resultobj;
15257 fail:
15258 return NULL;
15259 }
15260
15261
15262 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
15263 PyObject *resultobj = NULL;
15264 wxFileType *arg1 = (wxFileType *) 0 ;
15265 PyObject * obj0 = 0 ;
15266 char *kwnames[] = {
15267 (char *) "self", NULL
15268 };
15269
15270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
15271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15272 if (SWIG_arg_fail(1)) SWIG_fail;
15273 {
15274 PyThreadState* __tstate = wxPyBeginAllowThreads();
15275 delete arg1;
15276
15277 wxPyEndAllowThreads(__tstate);
15278 if (PyErr_Occurred()) SWIG_fail;
15279 }
15280 Py_INCREF(Py_None); resultobj = Py_None;
15281 return resultobj;
15282 fail:
15283 return NULL;
15284 }
15285
15286
15287 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15288 PyObject *resultobj = NULL;
15289 wxFileType *arg1 = (wxFileType *) 0 ;
15290 PyObject *result;
15291 PyObject * obj0 = 0 ;
15292 char *kwnames[] = {
15293 (char *) "self", NULL
15294 };
15295
15296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
15297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15298 if (SWIG_arg_fail(1)) SWIG_fail;
15299 {
15300 PyThreadState* __tstate = wxPyBeginAllowThreads();
15301 result = (PyObject *)wxFileType_GetMimeType(arg1);
15302
15303 wxPyEndAllowThreads(__tstate);
15304 if (PyErr_Occurred()) SWIG_fail;
15305 }
15306 resultobj = result;
15307 return resultobj;
15308 fail:
15309 return NULL;
15310 }
15311
15312
15313 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15314 PyObject *resultobj = NULL;
15315 wxFileType *arg1 = (wxFileType *) 0 ;
15316 PyObject *result;
15317 PyObject * obj0 = 0 ;
15318 char *kwnames[] = {
15319 (char *) "self", NULL
15320 };
15321
15322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
15323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15324 if (SWIG_arg_fail(1)) SWIG_fail;
15325 {
15326 PyThreadState* __tstate = wxPyBeginAllowThreads();
15327 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
15328
15329 wxPyEndAllowThreads(__tstate);
15330 if (PyErr_Occurred()) SWIG_fail;
15331 }
15332 resultobj = result;
15333 return resultobj;
15334 fail:
15335 return NULL;
15336 }
15337
15338
15339 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
15340 PyObject *resultobj = NULL;
15341 wxFileType *arg1 = (wxFileType *) 0 ;
15342 PyObject *result;
15343 PyObject * obj0 = 0 ;
15344 char *kwnames[] = {
15345 (char *) "self", NULL
15346 };
15347
15348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
15349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15350 if (SWIG_arg_fail(1)) SWIG_fail;
15351 {
15352 PyThreadState* __tstate = wxPyBeginAllowThreads();
15353 result = (PyObject *)wxFileType_GetExtensions(arg1);
15354
15355 wxPyEndAllowThreads(__tstate);
15356 if (PyErr_Occurred()) SWIG_fail;
15357 }
15358 resultobj = result;
15359 return resultobj;
15360 fail:
15361 return NULL;
15362 }
15363
15364
15365 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
15366 PyObject *resultobj = NULL;
15367 wxFileType *arg1 = (wxFileType *) 0 ;
15368 wxIcon *result;
15369 PyObject * obj0 = 0 ;
15370 char *kwnames[] = {
15371 (char *) "self", NULL
15372 };
15373
15374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
15375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15376 if (SWIG_arg_fail(1)) SWIG_fail;
15377 {
15378 PyThreadState* __tstate = wxPyBeginAllowThreads();
15379 result = (wxIcon *)wxFileType_GetIcon(arg1);
15380
15381 wxPyEndAllowThreads(__tstate);
15382 if (PyErr_Occurred()) SWIG_fail;
15383 }
15384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
15385 return resultobj;
15386 fail:
15387 return NULL;
15388 }
15389
15390
15391 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15392 PyObject *resultobj = NULL;
15393 wxFileType *arg1 = (wxFileType *) 0 ;
15394 PyObject *result;
15395 PyObject * obj0 = 0 ;
15396 char *kwnames[] = {
15397 (char *) "self", NULL
15398 };
15399
15400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
15401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15402 if (SWIG_arg_fail(1)) SWIG_fail;
15403 {
15404 PyThreadState* __tstate = wxPyBeginAllowThreads();
15405 result = (PyObject *)wxFileType_GetIconInfo(arg1);
15406
15407 wxPyEndAllowThreads(__tstate);
15408 if (PyErr_Occurred()) SWIG_fail;
15409 }
15410 resultobj = result;
15411 return resultobj;
15412 fail:
15413 return NULL;
15414 }
15415
15416
15417 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
15418 PyObject *resultobj = NULL;
15419 wxFileType *arg1 = (wxFileType *) 0 ;
15420 PyObject *result;
15421 PyObject * obj0 = 0 ;
15422 char *kwnames[] = {
15423 (char *) "self", NULL
15424 };
15425
15426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
15427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15428 if (SWIG_arg_fail(1)) SWIG_fail;
15429 {
15430 PyThreadState* __tstate = wxPyBeginAllowThreads();
15431 result = (PyObject *)wxFileType_GetDescription(arg1);
15432
15433 wxPyEndAllowThreads(__tstate);
15434 if (PyErr_Occurred()) SWIG_fail;
15435 }
15436 resultobj = result;
15437 return resultobj;
15438 fail:
15439 return NULL;
15440 }
15441
15442
15443 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15444 PyObject *resultobj = NULL;
15445 wxFileType *arg1 = (wxFileType *) 0 ;
15446 wxString *arg2 = 0 ;
15447 wxString const &arg3_defvalue = wxPyEmptyString ;
15448 wxString *arg3 = (wxString *) &arg3_defvalue ;
15449 PyObject *result;
15450 bool temp2 = false ;
15451 bool temp3 = false ;
15452 PyObject * obj0 = 0 ;
15453 PyObject * obj1 = 0 ;
15454 PyObject * obj2 = 0 ;
15455 char *kwnames[] = {
15456 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
15457 };
15458
15459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
15460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15461 if (SWIG_arg_fail(1)) SWIG_fail;
15462 {
15463 arg2 = wxString_in_helper(obj1);
15464 if (arg2 == NULL) SWIG_fail;
15465 temp2 = true;
15466 }
15467 if (obj2) {
15468 {
15469 arg3 = wxString_in_helper(obj2);
15470 if (arg3 == NULL) SWIG_fail;
15471 temp3 = true;
15472 }
15473 }
15474 {
15475 PyThreadState* __tstate = wxPyBeginAllowThreads();
15476 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15477
15478 wxPyEndAllowThreads(__tstate);
15479 if (PyErr_Occurred()) SWIG_fail;
15480 }
15481 resultobj = result;
15482 {
15483 if (temp2)
15484 delete arg2;
15485 }
15486 {
15487 if (temp3)
15488 delete arg3;
15489 }
15490 return resultobj;
15491 fail:
15492 {
15493 if (temp2)
15494 delete arg2;
15495 }
15496 {
15497 if (temp3)
15498 delete arg3;
15499 }
15500 return NULL;
15501 }
15502
15503
15504 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15505 PyObject *resultobj = NULL;
15506 wxFileType *arg1 = (wxFileType *) 0 ;
15507 wxString *arg2 = 0 ;
15508 wxString const &arg3_defvalue = wxPyEmptyString ;
15509 wxString *arg3 = (wxString *) &arg3_defvalue ;
15510 PyObject *result;
15511 bool temp2 = false ;
15512 bool temp3 = false ;
15513 PyObject * obj0 = 0 ;
15514 PyObject * obj1 = 0 ;
15515 PyObject * obj2 = 0 ;
15516 char *kwnames[] = {
15517 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
15518 };
15519
15520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
15521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15522 if (SWIG_arg_fail(1)) SWIG_fail;
15523 {
15524 arg2 = wxString_in_helper(obj1);
15525 if (arg2 == NULL) SWIG_fail;
15526 temp2 = true;
15527 }
15528 if (obj2) {
15529 {
15530 arg3 = wxString_in_helper(obj2);
15531 if (arg3 == NULL) SWIG_fail;
15532 temp3 = true;
15533 }
15534 }
15535 {
15536 PyThreadState* __tstate = wxPyBeginAllowThreads();
15537 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15538
15539 wxPyEndAllowThreads(__tstate);
15540 if (PyErr_Occurred()) SWIG_fail;
15541 }
15542 resultobj = result;
15543 {
15544 if (temp2)
15545 delete arg2;
15546 }
15547 {
15548 if (temp3)
15549 delete arg3;
15550 }
15551 return resultobj;
15552 fail:
15553 {
15554 if (temp2)
15555 delete arg2;
15556 }
15557 {
15558 if (temp3)
15559 delete arg3;
15560 }
15561 return NULL;
15562 }
15563
15564
15565 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
15566 PyObject *resultobj = NULL;
15567 wxFileType *arg1 = (wxFileType *) 0 ;
15568 wxString *arg2 = 0 ;
15569 wxString const &arg3_defvalue = wxPyEmptyString ;
15570 wxString *arg3 = (wxString *) &arg3_defvalue ;
15571 PyObject *result;
15572 bool temp2 = false ;
15573 bool temp3 = false ;
15574 PyObject * obj0 = 0 ;
15575 PyObject * obj1 = 0 ;
15576 PyObject * obj2 = 0 ;
15577 char *kwnames[] = {
15578 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
15579 };
15580
15581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
15582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15583 if (SWIG_arg_fail(1)) SWIG_fail;
15584 {
15585 arg2 = wxString_in_helper(obj1);
15586 if (arg2 == NULL) SWIG_fail;
15587 temp2 = true;
15588 }
15589 if (obj2) {
15590 {
15591 arg3 = wxString_in_helper(obj2);
15592 if (arg3 == NULL) SWIG_fail;
15593 temp3 = true;
15594 }
15595 }
15596 {
15597 PyThreadState* __tstate = wxPyBeginAllowThreads();
15598 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15599
15600 wxPyEndAllowThreads(__tstate);
15601 if (PyErr_Occurred()) SWIG_fail;
15602 }
15603 resultobj = result;
15604 {
15605 if (temp2)
15606 delete arg2;
15607 }
15608 {
15609 if (temp3)
15610 delete arg3;
15611 }
15612 return resultobj;
15613 fail:
15614 {
15615 if (temp2)
15616 delete arg2;
15617 }
15618 {
15619 if (temp3)
15620 delete arg3;
15621 }
15622 return NULL;
15623 }
15624
15625
15626 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15627 PyObject *resultobj = NULL;
15628 wxFileType *arg1 = (wxFileType *) 0 ;
15629 wxString *arg2 = 0 ;
15630 wxString *arg3 = 0 ;
15631 bool arg4 = (bool) true ;
15632 bool result;
15633 bool temp2 = false ;
15634 bool temp3 = false ;
15635 PyObject * obj0 = 0 ;
15636 PyObject * obj1 = 0 ;
15637 PyObject * obj2 = 0 ;
15638 PyObject * obj3 = 0 ;
15639 char *kwnames[] = {
15640 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
15641 };
15642
15643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15645 if (SWIG_arg_fail(1)) SWIG_fail;
15646 {
15647 arg2 = wxString_in_helper(obj1);
15648 if (arg2 == NULL) SWIG_fail;
15649 temp2 = true;
15650 }
15651 {
15652 arg3 = wxString_in_helper(obj2);
15653 if (arg3 == NULL) SWIG_fail;
15654 temp3 = true;
15655 }
15656 if (obj3) {
15657 {
15658 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
15659 if (SWIG_arg_fail(4)) SWIG_fail;
15660 }
15661 }
15662 {
15663 PyThreadState* __tstate = wxPyBeginAllowThreads();
15664 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
15665
15666 wxPyEndAllowThreads(__tstate);
15667 if (PyErr_Occurred()) SWIG_fail;
15668 }
15669 {
15670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15671 }
15672 {
15673 if (temp2)
15674 delete arg2;
15675 }
15676 {
15677 if (temp3)
15678 delete arg3;
15679 }
15680 return resultobj;
15681 fail:
15682 {
15683 if (temp2)
15684 delete arg2;
15685 }
15686 {
15687 if (temp3)
15688 delete arg3;
15689 }
15690 return NULL;
15691 }
15692
15693
15694 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
15695 PyObject *resultobj = NULL;
15696 wxFileType *arg1 = (wxFileType *) 0 ;
15697 wxString const &arg2_defvalue = wxPyEmptyString ;
15698 wxString *arg2 = (wxString *) &arg2_defvalue ;
15699 int arg3 = (int) 0 ;
15700 bool result;
15701 bool temp2 = false ;
15702 PyObject * obj0 = 0 ;
15703 PyObject * obj1 = 0 ;
15704 PyObject * obj2 = 0 ;
15705 char *kwnames[] = {
15706 (char *) "self",(char *) "cmd",(char *) "index", NULL
15707 };
15708
15709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
15710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15711 if (SWIG_arg_fail(1)) SWIG_fail;
15712 if (obj1) {
15713 {
15714 arg2 = wxString_in_helper(obj1);
15715 if (arg2 == NULL) SWIG_fail;
15716 temp2 = true;
15717 }
15718 }
15719 if (obj2) {
15720 {
15721 arg3 = static_cast<int >(SWIG_As_int(obj2));
15722 if (SWIG_arg_fail(3)) SWIG_fail;
15723 }
15724 }
15725 {
15726 PyThreadState* __tstate = wxPyBeginAllowThreads();
15727 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
15728
15729 wxPyEndAllowThreads(__tstate);
15730 if (PyErr_Occurred()) SWIG_fail;
15731 }
15732 {
15733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15734 }
15735 {
15736 if (temp2)
15737 delete arg2;
15738 }
15739 return resultobj;
15740 fail:
15741 {
15742 if (temp2)
15743 delete arg2;
15744 }
15745 return NULL;
15746 }
15747
15748
15749 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15750 PyObject *resultobj = NULL;
15751 wxFileType *arg1 = (wxFileType *) 0 ;
15752 bool result;
15753 PyObject * obj0 = 0 ;
15754 char *kwnames[] = {
15755 (char *) "self", NULL
15756 };
15757
15758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
15759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15760 if (SWIG_arg_fail(1)) SWIG_fail;
15761 {
15762 PyThreadState* __tstate = wxPyBeginAllowThreads();
15763 result = (bool)(arg1)->Unassociate();
15764
15765 wxPyEndAllowThreads(__tstate);
15766 if (PyErr_Occurred()) SWIG_fail;
15767 }
15768 {
15769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15770 }
15771 return resultobj;
15772 fail:
15773 return NULL;
15774 }
15775
15776
15777 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15778 PyObject *resultobj = NULL;
15779 wxString *arg1 = 0 ;
15780 wxString *arg2 = 0 ;
15781 wxString const &arg3_defvalue = wxPyEmptyString ;
15782 wxString *arg3 = (wxString *) &arg3_defvalue ;
15783 wxString result;
15784 bool temp1 = false ;
15785 bool temp2 = false ;
15786 bool temp3 = false ;
15787 PyObject * obj0 = 0 ;
15788 PyObject * obj1 = 0 ;
15789 PyObject * obj2 = 0 ;
15790 char *kwnames[] = {
15791 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
15792 };
15793
15794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
15795 {
15796 arg1 = wxString_in_helper(obj0);
15797 if (arg1 == NULL) SWIG_fail;
15798 temp1 = true;
15799 }
15800 {
15801 arg2 = wxString_in_helper(obj1);
15802 if (arg2 == NULL) SWIG_fail;
15803 temp2 = true;
15804 }
15805 if (obj2) {
15806 {
15807 arg3 = wxString_in_helper(obj2);
15808 if (arg3 == NULL) SWIG_fail;
15809 temp3 = true;
15810 }
15811 }
15812 {
15813 PyThreadState* __tstate = wxPyBeginAllowThreads();
15814 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15815
15816 wxPyEndAllowThreads(__tstate);
15817 if (PyErr_Occurred()) SWIG_fail;
15818 }
15819 {
15820 #if wxUSE_UNICODE
15821 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15822 #else
15823 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15824 #endif
15825 }
15826 {
15827 if (temp1)
15828 delete arg1;
15829 }
15830 {
15831 if (temp2)
15832 delete arg2;
15833 }
15834 {
15835 if (temp3)
15836 delete arg3;
15837 }
15838 return resultobj;
15839 fail:
15840 {
15841 if (temp1)
15842 delete arg1;
15843 }
15844 {
15845 if (temp2)
15846 delete arg2;
15847 }
15848 {
15849 if (temp3)
15850 delete arg3;
15851 }
15852 return NULL;
15853 }
15854
15855
15856 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
15857 PyObject *obj;
15858 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15859 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
15860 Py_INCREF(obj);
15861 return Py_BuildValue((char *)"");
15862 }
15863 static int _wrap_TheMimeTypesManager_set(PyObject *) {
15864 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
15865 return 1;
15866 }
15867
15868
15869 static PyObject *_wrap_TheMimeTypesManager_get(void) {
15870 PyObject *pyobj = NULL;
15871
15872 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
15873 return pyobj;
15874 }
15875
15876
15877 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
15878 PyObject *resultobj = NULL;
15879 wxString *arg1 = 0 ;
15880 wxString *arg2 = 0 ;
15881 bool result;
15882 bool temp1 = false ;
15883 bool temp2 = false ;
15884 PyObject * obj0 = 0 ;
15885 PyObject * obj1 = 0 ;
15886 char *kwnames[] = {
15887 (char *) "mimeType",(char *) "wildcard", NULL
15888 };
15889
15890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
15891 {
15892 arg1 = wxString_in_helper(obj0);
15893 if (arg1 == NULL) SWIG_fail;
15894 temp1 = true;
15895 }
15896 {
15897 arg2 = wxString_in_helper(obj1);
15898 if (arg2 == NULL) SWIG_fail;
15899 temp2 = true;
15900 }
15901 {
15902 PyThreadState* __tstate = wxPyBeginAllowThreads();
15903 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
15904
15905 wxPyEndAllowThreads(__tstate);
15906 if (PyErr_Occurred()) SWIG_fail;
15907 }
15908 {
15909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15910 }
15911 {
15912 if (temp1)
15913 delete arg1;
15914 }
15915 {
15916 if (temp2)
15917 delete arg2;
15918 }
15919 return resultobj;
15920 fail:
15921 {
15922 if (temp1)
15923 delete arg1;
15924 }
15925 {
15926 if (temp2)
15927 delete arg2;
15928 }
15929 return NULL;
15930 }
15931
15932
15933 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15934 PyObject *resultobj = NULL;
15935 wxMimeTypesManager *result;
15936 char *kwnames[] = {
15937 NULL
15938 };
15939
15940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15941 {
15942 PyThreadState* __tstate = wxPyBeginAllowThreads();
15943 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15944
15945 wxPyEndAllowThreads(__tstate);
15946 if (PyErr_Occurred()) SWIG_fail;
15947 }
15948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15949 return resultobj;
15950 fail:
15951 return NULL;
15952 }
15953
15954
15955 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15956 PyObject *resultobj = NULL;
15957 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15958 int arg2 = (int) wxMAILCAP_ALL ;
15959 wxString const &arg3_defvalue = wxPyEmptyString ;
15960 wxString *arg3 = (wxString *) &arg3_defvalue ;
15961 bool temp3 = false ;
15962 PyObject * obj0 = 0 ;
15963 PyObject * obj1 = 0 ;
15964 PyObject * obj2 = 0 ;
15965 char *kwnames[] = {
15966 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15967 };
15968
15969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15971 if (SWIG_arg_fail(1)) SWIG_fail;
15972 if (obj1) {
15973 {
15974 arg2 = static_cast<int >(SWIG_As_int(obj1));
15975 if (SWIG_arg_fail(2)) SWIG_fail;
15976 }
15977 }
15978 if (obj2) {
15979 {
15980 arg3 = wxString_in_helper(obj2);
15981 if (arg3 == NULL) SWIG_fail;
15982 temp3 = true;
15983 }
15984 }
15985 {
15986 PyThreadState* __tstate = wxPyBeginAllowThreads();
15987 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15988
15989 wxPyEndAllowThreads(__tstate);
15990 if (PyErr_Occurred()) SWIG_fail;
15991 }
15992 Py_INCREF(Py_None); resultobj = Py_None;
15993 {
15994 if (temp3)
15995 delete arg3;
15996 }
15997 return resultobj;
15998 fail:
15999 {
16000 if (temp3)
16001 delete arg3;
16002 }
16003 return NULL;
16004 }
16005
16006
16007 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
16008 PyObject *resultobj = NULL;
16009 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16010 PyObject * obj0 = 0 ;
16011 char *kwnames[] = {
16012 (char *) "self", NULL
16013 };
16014
16015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
16016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16017 if (SWIG_arg_fail(1)) SWIG_fail;
16018 {
16019 PyThreadState* __tstate = wxPyBeginAllowThreads();
16020 (arg1)->ClearData();
16021
16022 wxPyEndAllowThreads(__tstate);
16023 if (PyErr_Occurred()) SWIG_fail;
16024 }
16025 Py_INCREF(Py_None); resultobj = Py_None;
16026 return resultobj;
16027 fail:
16028 return NULL;
16029 }
16030
16031
16032 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
16033 PyObject *resultobj = NULL;
16034 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16035 wxString *arg2 = 0 ;
16036 wxFileType *result;
16037 bool temp2 = false ;
16038 PyObject * obj0 = 0 ;
16039 PyObject * obj1 = 0 ;
16040 char *kwnames[] = {
16041 (char *) "self",(char *) "ext", NULL
16042 };
16043
16044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
16045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16046 if (SWIG_arg_fail(1)) SWIG_fail;
16047 {
16048 arg2 = wxString_in_helper(obj1);
16049 if (arg2 == NULL) SWIG_fail;
16050 temp2 = true;
16051 }
16052 {
16053 PyThreadState* __tstate = wxPyBeginAllowThreads();
16054 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
16055
16056 wxPyEndAllowThreads(__tstate);
16057 if (PyErr_Occurred()) SWIG_fail;
16058 }
16059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
16060 {
16061 if (temp2)
16062 delete arg2;
16063 }
16064 return resultobj;
16065 fail:
16066 {
16067 if (temp2)
16068 delete arg2;
16069 }
16070 return NULL;
16071 }
16072
16073
16074 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
16075 PyObject *resultobj = NULL;
16076 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16077 wxString *arg2 = 0 ;
16078 wxFileType *result;
16079 bool temp2 = false ;
16080 PyObject * obj0 = 0 ;
16081 PyObject * obj1 = 0 ;
16082 char *kwnames[] = {
16083 (char *) "self",(char *) "mimeType", NULL
16084 };
16085
16086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
16087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16088 if (SWIG_arg_fail(1)) SWIG_fail;
16089 {
16090 arg2 = wxString_in_helper(obj1);
16091 if (arg2 == NULL) SWIG_fail;
16092 temp2 = true;
16093 }
16094 {
16095 PyThreadState* __tstate = wxPyBeginAllowThreads();
16096 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
16097
16098 wxPyEndAllowThreads(__tstate);
16099 if (PyErr_Occurred()) SWIG_fail;
16100 }
16101 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
16102 {
16103 if (temp2)
16104 delete arg2;
16105 }
16106 return resultobj;
16107 fail:
16108 {
16109 if (temp2)
16110 delete arg2;
16111 }
16112 return NULL;
16113 }
16114
16115
16116 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
16117 PyObject *resultobj = NULL;
16118 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16119 wxString *arg2 = 0 ;
16120 bool arg3 = (bool) false ;
16121 bool result;
16122 bool temp2 = false ;
16123 PyObject * obj0 = 0 ;
16124 PyObject * obj1 = 0 ;
16125 PyObject * obj2 = 0 ;
16126 char *kwnames[] = {
16127 (char *) "self",(char *) "filename",(char *) "fallback", NULL
16128 };
16129
16130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16132 if (SWIG_arg_fail(1)) SWIG_fail;
16133 {
16134 arg2 = wxString_in_helper(obj1);
16135 if (arg2 == NULL) SWIG_fail;
16136 temp2 = true;
16137 }
16138 if (obj2) {
16139 {
16140 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
16141 if (SWIG_arg_fail(3)) SWIG_fail;
16142 }
16143 }
16144 {
16145 PyThreadState* __tstate = wxPyBeginAllowThreads();
16146 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
16147
16148 wxPyEndAllowThreads(__tstate);
16149 if (PyErr_Occurred()) SWIG_fail;
16150 }
16151 {
16152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16153 }
16154 {
16155 if (temp2)
16156 delete arg2;
16157 }
16158 return resultobj;
16159 fail:
16160 {
16161 if (temp2)
16162 delete arg2;
16163 }
16164 return NULL;
16165 }
16166
16167
16168 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
16169 PyObject *resultobj = NULL;
16170 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16171 wxString *arg2 = 0 ;
16172 bool result;
16173 bool temp2 = false ;
16174 PyObject * obj0 = 0 ;
16175 PyObject * obj1 = 0 ;
16176 char *kwnames[] = {
16177 (char *) "self",(char *) "filename", NULL
16178 };
16179
16180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
16181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16182 if (SWIG_arg_fail(1)) SWIG_fail;
16183 {
16184 arg2 = wxString_in_helper(obj1);
16185 if (arg2 == NULL) SWIG_fail;
16186 temp2 = true;
16187 }
16188 {
16189 PyThreadState* __tstate = wxPyBeginAllowThreads();
16190 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
16191
16192 wxPyEndAllowThreads(__tstate);
16193 if (PyErr_Occurred()) SWIG_fail;
16194 }
16195 {
16196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16197 }
16198 {
16199 if (temp2)
16200 delete arg2;
16201 }
16202 return resultobj;
16203 fail:
16204 {
16205 if (temp2)
16206 delete arg2;
16207 }
16208 return NULL;
16209 }
16210
16211
16212 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
16213 PyObject *resultobj = NULL;
16214 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16215 PyObject *result;
16216 PyObject * obj0 = 0 ;
16217 char *kwnames[] = {
16218 (char *) "self", NULL
16219 };
16220
16221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
16222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16223 if (SWIG_arg_fail(1)) SWIG_fail;
16224 {
16225 PyThreadState* __tstate = wxPyBeginAllowThreads();
16226 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
16227
16228 wxPyEndAllowThreads(__tstate);
16229 if (PyErr_Occurred()) SWIG_fail;
16230 }
16231 resultobj = result;
16232 return resultobj;
16233 fail:
16234 return NULL;
16235 }
16236
16237
16238 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
16239 PyObject *resultobj = NULL;
16240 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16241 wxFileTypeInfo *arg2 = 0 ;
16242 PyObject * obj0 = 0 ;
16243 PyObject * obj1 = 0 ;
16244 char *kwnames[] = {
16245 (char *) "self",(char *) "ft", NULL
16246 };
16247
16248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
16249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16250 if (SWIG_arg_fail(1)) SWIG_fail;
16251 {
16252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
16253 if (SWIG_arg_fail(2)) SWIG_fail;
16254 if (arg2 == NULL) {
16255 SWIG_null_ref("wxFileTypeInfo");
16256 }
16257 if (SWIG_arg_fail(2)) SWIG_fail;
16258 }
16259 {
16260 PyThreadState* __tstate = wxPyBeginAllowThreads();
16261 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
16262
16263 wxPyEndAllowThreads(__tstate);
16264 if (PyErr_Occurred()) SWIG_fail;
16265 }
16266 Py_INCREF(Py_None); resultobj = Py_None;
16267 return resultobj;
16268 fail:
16269 return NULL;
16270 }
16271
16272
16273 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
16274 PyObject *resultobj = NULL;
16275 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16276 wxFileTypeInfo *arg2 = 0 ;
16277 wxFileType *result;
16278 PyObject * obj0 = 0 ;
16279 PyObject * obj1 = 0 ;
16280 char *kwnames[] = {
16281 (char *) "self",(char *) "ftInfo", NULL
16282 };
16283
16284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
16285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16286 if (SWIG_arg_fail(1)) SWIG_fail;
16287 {
16288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
16289 if (SWIG_arg_fail(2)) SWIG_fail;
16290 if (arg2 == NULL) {
16291 SWIG_null_ref("wxFileTypeInfo");
16292 }
16293 if (SWIG_arg_fail(2)) SWIG_fail;
16294 }
16295 {
16296 PyThreadState* __tstate = wxPyBeginAllowThreads();
16297 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
16298
16299 wxPyEndAllowThreads(__tstate);
16300 if (PyErr_Occurred()) SWIG_fail;
16301 }
16302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
16303 return resultobj;
16304 fail:
16305 return NULL;
16306 }
16307
16308
16309 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
16310 PyObject *resultobj = NULL;
16311 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16312 wxFileType *arg2 = (wxFileType *) 0 ;
16313 bool result;
16314 PyObject * obj0 = 0 ;
16315 PyObject * obj1 = 0 ;
16316 char *kwnames[] = {
16317 (char *) "self",(char *) "ft", NULL
16318 };
16319
16320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
16321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16322 if (SWIG_arg_fail(1)) SWIG_fail;
16323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
16324 if (SWIG_arg_fail(2)) SWIG_fail;
16325 {
16326 PyThreadState* __tstate = wxPyBeginAllowThreads();
16327 result = (bool)(arg1)->Unassociate(arg2);
16328
16329 wxPyEndAllowThreads(__tstate);
16330 if (PyErr_Occurred()) SWIG_fail;
16331 }
16332 {
16333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16334 }
16335 return resultobj;
16336 fail:
16337 return NULL;
16338 }
16339
16340
16341 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
16342 PyObject *resultobj = NULL;
16343 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16344 PyObject * obj0 = 0 ;
16345 char *kwnames[] = {
16346 (char *) "self", NULL
16347 };
16348
16349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
16350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16351 if (SWIG_arg_fail(1)) SWIG_fail;
16352 {
16353 PyThreadState* __tstate = wxPyBeginAllowThreads();
16354 delete arg1;
16355
16356 wxPyEndAllowThreads(__tstate);
16357 if (PyErr_Occurred()) SWIG_fail;
16358 }
16359 Py_INCREF(Py_None); resultobj = Py_None;
16360 return resultobj;
16361 fail:
16362 return NULL;
16363 }
16364
16365
16366 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
16367 PyObject *obj;
16368 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16369 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
16370 Py_INCREF(obj);
16371 return Py_BuildValue((char *)"");
16372 }
16373 static int _wrap_ART_TOOLBAR_set(PyObject *) {
16374 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
16375 return 1;
16376 }
16377
16378
16379 static PyObject *_wrap_ART_TOOLBAR_get(void) {
16380 PyObject *pyobj = NULL;
16381
16382 {
16383 #if wxUSE_UNICODE
16384 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
16385 #else
16386 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
16387 #endif
16388 }
16389 return pyobj;
16390 }
16391
16392
16393 static int _wrap_ART_MENU_set(PyObject *) {
16394 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
16395 return 1;
16396 }
16397
16398
16399 static PyObject *_wrap_ART_MENU_get(void) {
16400 PyObject *pyobj = NULL;
16401
16402 {
16403 #if wxUSE_UNICODE
16404 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
16405 #else
16406 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
16407 #endif
16408 }
16409 return pyobj;
16410 }
16411
16412
16413 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
16414 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
16415 return 1;
16416 }
16417
16418
16419 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
16420 PyObject *pyobj = NULL;
16421
16422 {
16423 #if wxUSE_UNICODE
16424 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
16425 #else
16426 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
16427 #endif
16428 }
16429 return pyobj;
16430 }
16431
16432
16433 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
16434 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
16435 return 1;
16436 }
16437
16438
16439 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
16440 PyObject *pyobj = NULL;
16441
16442 {
16443 #if wxUSE_UNICODE
16444 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
16445 #else
16446 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
16447 #endif
16448 }
16449 return pyobj;
16450 }
16451
16452
16453 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
16454 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
16455 return 1;
16456 }
16457
16458
16459 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
16460 PyObject *pyobj = NULL;
16461
16462 {
16463 #if wxUSE_UNICODE
16464 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
16465 #else
16466 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
16467 #endif
16468 }
16469 return pyobj;
16470 }
16471
16472
16473 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
16474 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
16475 return 1;
16476 }
16477
16478
16479 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
16480 PyObject *pyobj = NULL;
16481
16482 {
16483 #if wxUSE_UNICODE
16484 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
16485 #else
16486 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
16487 #endif
16488 }
16489 return pyobj;
16490 }
16491
16492
16493 static int _wrap_ART_BUTTON_set(PyObject *) {
16494 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
16495 return 1;
16496 }
16497
16498
16499 static PyObject *_wrap_ART_BUTTON_get(void) {
16500 PyObject *pyobj = NULL;
16501
16502 {
16503 #if wxUSE_UNICODE
16504 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
16505 #else
16506 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
16507 #endif
16508 }
16509 return pyobj;
16510 }
16511
16512
16513 static int _wrap_ART_OTHER_set(PyObject *) {
16514 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
16515 return 1;
16516 }
16517
16518
16519 static PyObject *_wrap_ART_OTHER_get(void) {
16520 PyObject *pyobj = NULL;
16521
16522 {
16523 #if wxUSE_UNICODE
16524 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
16525 #else
16526 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
16527 #endif
16528 }
16529 return pyobj;
16530 }
16531
16532
16533 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
16534 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
16535 return 1;
16536 }
16537
16538
16539 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
16540 PyObject *pyobj = NULL;
16541
16542 {
16543 #if wxUSE_UNICODE
16544 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
16545 #else
16546 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
16547 #endif
16548 }
16549 return pyobj;
16550 }
16551
16552
16553 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
16554 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
16555 return 1;
16556 }
16557
16558
16559 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
16560 PyObject *pyobj = NULL;
16561
16562 {
16563 #if wxUSE_UNICODE
16564 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
16565 #else
16566 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
16567 #endif
16568 }
16569 return pyobj;
16570 }
16571
16572
16573 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
16574 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
16575 return 1;
16576 }
16577
16578
16579 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
16580 PyObject *pyobj = NULL;
16581
16582 {
16583 #if wxUSE_UNICODE
16584 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
16585 #else
16586 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
16587 #endif
16588 }
16589 return pyobj;
16590 }
16591
16592
16593 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
16594 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
16595 return 1;
16596 }
16597
16598
16599 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
16600 PyObject *pyobj = NULL;
16601
16602 {
16603 #if wxUSE_UNICODE
16604 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
16605 #else
16606 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
16607 #endif
16608 }
16609 return pyobj;
16610 }
16611
16612
16613 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
16614 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
16615 return 1;
16616 }
16617
16618
16619 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
16620 PyObject *pyobj = NULL;
16621
16622 {
16623 #if wxUSE_UNICODE
16624 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
16625 #else
16626 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
16627 #endif
16628 }
16629 return pyobj;
16630 }
16631
16632
16633 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
16634 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
16635 return 1;
16636 }
16637
16638
16639 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
16640 PyObject *pyobj = NULL;
16641
16642 {
16643 #if wxUSE_UNICODE
16644 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
16645 #else
16646 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
16647 #endif
16648 }
16649 return pyobj;
16650 }
16651
16652
16653 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
16654 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
16655 return 1;
16656 }
16657
16658
16659 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
16660 PyObject *pyobj = NULL;
16661
16662 {
16663 #if wxUSE_UNICODE
16664 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
16665 #else
16666 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
16667 #endif
16668 }
16669 return pyobj;
16670 }
16671
16672
16673 static int _wrap_ART_GO_BACK_set(PyObject *) {
16674 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
16675 return 1;
16676 }
16677
16678
16679 static PyObject *_wrap_ART_GO_BACK_get(void) {
16680 PyObject *pyobj = NULL;
16681
16682 {
16683 #if wxUSE_UNICODE
16684 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
16685 #else
16686 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
16687 #endif
16688 }
16689 return pyobj;
16690 }
16691
16692
16693 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
16694 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
16695 return 1;
16696 }
16697
16698
16699 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
16700 PyObject *pyobj = NULL;
16701
16702 {
16703 #if wxUSE_UNICODE
16704 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
16705 #else
16706 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
16707 #endif
16708 }
16709 return pyobj;
16710 }
16711
16712
16713 static int _wrap_ART_GO_UP_set(PyObject *) {
16714 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
16715 return 1;
16716 }
16717
16718
16719 static PyObject *_wrap_ART_GO_UP_get(void) {
16720 PyObject *pyobj = NULL;
16721
16722 {
16723 #if wxUSE_UNICODE
16724 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
16725 #else
16726 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
16727 #endif
16728 }
16729 return pyobj;
16730 }
16731
16732
16733 static int _wrap_ART_GO_DOWN_set(PyObject *) {
16734 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
16735 return 1;
16736 }
16737
16738
16739 static PyObject *_wrap_ART_GO_DOWN_get(void) {
16740 PyObject *pyobj = NULL;
16741
16742 {
16743 #if wxUSE_UNICODE
16744 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
16745 #else
16746 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
16747 #endif
16748 }
16749 return pyobj;
16750 }
16751
16752
16753 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
16754 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
16755 return 1;
16756 }
16757
16758
16759 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
16760 PyObject *pyobj = NULL;
16761
16762 {
16763 #if wxUSE_UNICODE
16764 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
16765 #else
16766 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
16767 #endif
16768 }
16769 return pyobj;
16770 }
16771
16772
16773 static int _wrap_ART_GO_HOME_set(PyObject *) {
16774 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
16775 return 1;
16776 }
16777
16778
16779 static PyObject *_wrap_ART_GO_HOME_get(void) {
16780 PyObject *pyobj = NULL;
16781
16782 {
16783 #if wxUSE_UNICODE
16784 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
16785 #else
16786 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
16787 #endif
16788 }
16789 return pyobj;
16790 }
16791
16792
16793 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
16794 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
16795 return 1;
16796 }
16797
16798
16799 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
16800 PyObject *pyobj = NULL;
16801
16802 {
16803 #if wxUSE_UNICODE
16804 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
16805 #else
16806 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
16807 #endif
16808 }
16809 return pyobj;
16810 }
16811
16812
16813 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
16814 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
16815 return 1;
16816 }
16817
16818
16819 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
16820 PyObject *pyobj = NULL;
16821
16822 {
16823 #if wxUSE_UNICODE
16824 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
16825 #else
16826 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
16827 #endif
16828 }
16829 return pyobj;
16830 }
16831
16832
16833 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
16834 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
16835 return 1;
16836 }
16837
16838
16839 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
16840 PyObject *pyobj = NULL;
16841
16842 {
16843 #if wxUSE_UNICODE
16844 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
16845 #else
16846 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
16847 #endif
16848 }
16849 return pyobj;
16850 }
16851
16852
16853 static int _wrap_ART_PRINT_set(PyObject *) {
16854 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
16855 return 1;
16856 }
16857
16858
16859 static PyObject *_wrap_ART_PRINT_get(void) {
16860 PyObject *pyobj = NULL;
16861
16862 {
16863 #if wxUSE_UNICODE
16864 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16865 #else
16866 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16867 #endif
16868 }
16869 return pyobj;
16870 }
16871
16872
16873 static int _wrap_ART_HELP_set(PyObject *) {
16874 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
16875 return 1;
16876 }
16877
16878
16879 static PyObject *_wrap_ART_HELP_get(void) {
16880 PyObject *pyobj = NULL;
16881
16882 {
16883 #if wxUSE_UNICODE
16884 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16885 #else
16886 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16887 #endif
16888 }
16889 return pyobj;
16890 }
16891
16892
16893 static int _wrap_ART_TIP_set(PyObject *) {
16894 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
16895 return 1;
16896 }
16897
16898
16899 static PyObject *_wrap_ART_TIP_get(void) {
16900 PyObject *pyobj = NULL;
16901
16902 {
16903 #if wxUSE_UNICODE
16904 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16905 #else
16906 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16907 #endif
16908 }
16909 return pyobj;
16910 }
16911
16912
16913 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16914 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16915 return 1;
16916 }
16917
16918
16919 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16920 PyObject *pyobj = NULL;
16921
16922 {
16923 #if wxUSE_UNICODE
16924 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16925 #else
16926 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16927 #endif
16928 }
16929 return pyobj;
16930 }
16931
16932
16933 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16934 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16935 return 1;
16936 }
16937
16938
16939 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16940 PyObject *pyobj = NULL;
16941
16942 {
16943 #if wxUSE_UNICODE
16944 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16945 #else
16946 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16947 #endif
16948 }
16949 return pyobj;
16950 }
16951
16952
16953 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16954 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16955 return 1;
16956 }
16957
16958
16959 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16960 PyObject *pyobj = NULL;
16961
16962 {
16963 #if wxUSE_UNICODE
16964 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16965 #else
16966 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16967 #endif
16968 }
16969 return pyobj;
16970 }
16971
16972
16973 static int _wrap_ART_HARDDISK_set(PyObject *) {
16974 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16975 return 1;
16976 }
16977
16978
16979 static PyObject *_wrap_ART_HARDDISK_get(void) {
16980 PyObject *pyobj = NULL;
16981
16982 {
16983 #if wxUSE_UNICODE
16984 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16985 #else
16986 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16987 #endif
16988 }
16989 return pyobj;
16990 }
16991
16992
16993 static int _wrap_ART_FLOPPY_set(PyObject *) {
16994 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16995 return 1;
16996 }
16997
16998
16999 static PyObject *_wrap_ART_FLOPPY_get(void) {
17000 PyObject *pyobj = NULL;
17001
17002 {
17003 #if wxUSE_UNICODE
17004 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
17005 #else
17006 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
17007 #endif
17008 }
17009 return pyobj;
17010 }
17011
17012
17013 static int _wrap_ART_CDROM_set(PyObject *) {
17014 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
17015 return 1;
17016 }
17017
17018
17019 static PyObject *_wrap_ART_CDROM_get(void) {
17020 PyObject *pyobj = NULL;
17021
17022 {
17023 #if wxUSE_UNICODE
17024 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
17025 #else
17026 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
17027 #endif
17028 }
17029 return pyobj;
17030 }
17031
17032
17033 static int _wrap_ART_REMOVABLE_set(PyObject *) {
17034 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
17035 return 1;
17036 }
17037
17038
17039 static PyObject *_wrap_ART_REMOVABLE_get(void) {
17040 PyObject *pyobj = NULL;
17041
17042 {
17043 #if wxUSE_UNICODE
17044 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
17045 #else
17046 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
17047 #endif
17048 }
17049 return pyobj;
17050 }
17051
17052
17053 static int _wrap_ART_FOLDER_set(PyObject *) {
17054 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
17055 return 1;
17056 }
17057
17058
17059 static PyObject *_wrap_ART_FOLDER_get(void) {
17060 PyObject *pyobj = NULL;
17061
17062 {
17063 #if wxUSE_UNICODE
17064 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
17065 #else
17066 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
17067 #endif
17068 }
17069 return pyobj;
17070 }
17071
17072
17073 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
17074 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
17075 return 1;
17076 }
17077
17078
17079 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
17080 PyObject *pyobj = NULL;
17081
17082 {
17083 #if wxUSE_UNICODE
17084 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
17085 #else
17086 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
17087 #endif
17088 }
17089 return pyobj;
17090 }
17091
17092
17093 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
17094 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
17095 return 1;
17096 }
17097
17098
17099 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
17100 PyObject *pyobj = NULL;
17101
17102 {
17103 #if wxUSE_UNICODE
17104 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
17105 #else
17106 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
17107 #endif
17108 }
17109 return pyobj;
17110 }
17111
17112
17113 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
17114 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
17115 return 1;
17116 }
17117
17118
17119 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
17120 PyObject *pyobj = NULL;
17121
17122 {
17123 #if wxUSE_UNICODE
17124 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
17125 #else
17126 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
17127 #endif
17128 }
17129 return pyobj;
17130 }
17131
17132
17133 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
17134 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
17135 return 1;
17136 }
17137
17138
17139 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
17140 PyObject *pyobj = NULL;
17141
17142 {
17143 #if wxUSE_UNICODE
17144 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
17145 #else
17146 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
17147 #endif
17148 }
17149 return pyobj;
17150 }
17151
17152
17153 static int _wrap_ART_TICK_MARK_set(PyObject *) {
17154 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
17155 return 1;
17156 }
17157
17158
17159 static PyObject *_wrap_ART_TICK_MARK_get(void) {
17160 PyObject *pyobj = NULL;
17161
17162 {
17163 #if wxUSE_UNICODE
17164 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
17165 #else
17166 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
17167 #endif
17168 }
17169 return pyobj;
17170 }
17171
17172
17173 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
17174 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
17175 return 1;
17176 }
17177
17178
17179 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
17180 PyObject *pyobj = NULL;
17181
17182 {
17183 #if wxUSE_UNICODE
17184 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
17185 #else
17186 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
17187 #endif
17188 }
17189 return pyobj;
17190 }
17191
17192
17193 static int _wrap_ART_ERROR_set(PyObject *) {
17194 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
17195 return 1;
17196 }
17197
17198
17199 static PyObject *_wrap_ART_ERROR_get(void) {
17200 PyObject *pyobj = NULL;
17201
17202 {
17203 #if wxUSE_UNICODE
17204 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
17205 #else
17206 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
17207 #endif
17208 }
17209 return pyobj;
17210 }
17211
17212
17213 static int _wrap_ART_QUESTION_set(PyObject *) {
17214 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
17215 return 1;
17216 }
17217
17218
17219 static PyObject *_wrap_ART_QUESTION_get(void) {
17220 PyObject *pyobj = NULL;
17221
17222 {
17223 #if wxUSE_UNICODE
17224 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
17225 #else
17226 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
17227 #endif
17228 }
17229 return pyobj;
17230 }
17231
17232
17233 static int _wrap_ART_WARNING_set(PyObject *) {
17234 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
17235 return 1;
17236 }
17237
17238
17239 static PyObject *_wrap_ART_WARNING_get(void) {
17240 PyObject *pyobj = NULL;
17241
17242 {
17243 #if wxUSE_UNICODE
17244 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
17245 #else
17246 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
17247 #endif
17248 }
17249 return pyobj;
17250 }
17251
17252
17253 static int _wrap_ART_INFORMATION_set(PyObject *) {
17254 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
17255 return 1;
17256 }
17257
17258
17259 static PyObject *_wrap_ART_INFORMATION_get(void) {
17260 PyObject *pyobj = NULL;
17261
17262 {
17263 #if wxUSE_UNICODE
17264 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
17265 #else
17266 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
17267 #endif
17268 }
17269 return pyobj;
17270 }
17271
17272
17273 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
17274 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
17275 return 1;
17276 }
17277
17278
17279 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
17280 PyObject *pyobj = NULL;
17281
17282 {
17283 #if wxUSE_UNICODE
17284 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
17285 #else
17286 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
17287 #endif
17288 }
17289 return pyobj;
17290 }
17291
17292
17293 static int _wrap_ART_COPY_set(PyObject *) {
17294 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
17295 return 1;
17296 }
17297
17298
17299 static PyObject *_wrap_ART_COPY_get(void) {
17300 PyObject *pyobj = NULL;
17301
17302 {
17303 #if wxUSE_UNICODE
17304 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
17305 #else
17306 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
17307 #endif
17308 }
17309 return pyobj;
17310 }
17311
17312
17313 static int _wrap_ART_CUT_set(PyObject *) {
17314 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
17315 return 1;
17316 }
17317
17318
17319 static PyObject *_wrap_ART_CUT_get(void) {
17320 PyObject *pyobj = NULL;
17321
17322 {
17323 #if wxUSE_UNICODE
17324 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
17325 #else
17326 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
17327 #endif
17328 }
17329 return pyobj;
17330 }
17331
17332
17333 static int _wrap_ART_PASTE_set(PyObject *) {
17334 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
17335 return 1;
17336 }
17337
17338
17339 static PyObject *_wrap_ART_PASTE_get(void) {
17340 PyObject *pyobj = NULL;
17341
17342 {
17343 #if wxUSE_UNICODE
17344 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
17345 #else
17346 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
17347 #endif
17348 }
17349 return pyobj;
17350 }
17351
17352
17353 static int _wrap_ART_DELETE_set(PyObject *) {
17354 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
17355 return 1;
17356 }
17357
17358
17359 static PyObject *_wrap_ART_DELETE_get(void) {
17360 PyObject *pyobj = NULL;
17361
17362 {
17363 #if wxUSE_UNICODE
17364 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
17365 #else
17366 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
17367 #endif
17368 }
17369 return pyobj;
17370 }
17371
17372
17373 static int _wrap_ART_NEW_set(PyObject *) {
17374 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW is read-only.");
17375 return 1;
17376 }
17377
17378
17379 static PyObject *_wrap_ART_NEW_get(void) {
17380 PyObject *pyobj = NULL;
17381
17382 {
17383 #if wxUSE_UNICODE
17384 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
17385 #else
17386 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
17387 #endif
17388 }
17389 return pyobj;
17390 }
17391
17392
17393 static int _wrap_ART_UNDO_set(PyObject *) {
17394 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
17395 return 1;
17396 }
17397
17398
17399 static PyObject *_wrap_ART_UNDO_get(void) {
17400 PyObject *pyobj = NULL;
17401
17402 {
17403 #if wxUSE_UNICODE
17404 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
17405 #else
17406 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
17407 #endif
17408 }
17409 return pyobj;
17410 }
17411
17412
17413 static int _wrap_ART_REDO_set(PyObject *) {
17414 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
17415 return 1;
17416 }
17417
17418
17419 static PyObject *_wrap_ART_REDO_get(void) {
17420 PyObject *pyobj = NULL;
17421
17422 {
17423 #if wxUSE_UNICODE
17424 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
17425 #else
17426 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
17427 #endif
17428 }
17429 return pyobj;
17430 }
17431
17432
17433 static int _wrap_ART_QUIT_set(PyObject *) {
17434 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
17435 return 1;
17436 }
17437
17438
17439 static PyObject *_wrap_ART_QUIT_get(void) {
17440 PyObject *pyobj = NULL;
17441
17442 {
17443 #if wxUSE_UNICODE
17444 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
17445 #else
17446 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
17447 #endif
17448 }
17449 return pyobj;
17450 }
17451
17452
17453 static int _wrap_ART_FIND_set(PyObject *) {
17454 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
17455 return 1;
17456 }
17457
17458
17459 static PyObject *_wrap_ART_FIND_get(void) {
17460 PyObject *pyobj = NULL;
17461
17462 {
17463 #if wxUSE_UNICODE
17464 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
17465 #else
17466 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
17467 #endif
17468 }
17469 return pyobj;
17470 }
17471
17472
17473 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
17474 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
17475 return 1;
17476 }
17477
17478
17479 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
17480 PyObject *pyobj = NULL;
17481
17482 {
17483 #if wxUSE_UNICODE
17484 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
17485 #else
17486 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
17487 #endif
17488 }
17489 return pyobj;
17490 }
17491
17492
17493 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17494 PyObject *resultobj = NULL;
17495 wxPyArtProvider *result;
17496 char *kwnames[] = {
17497 NULL
17498 };
17499
17500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
17501 {
17502 if (!wxPyCheckForApp()) SWIG_fail;
17503 PyThreadState* __tstate = wxPyBeginAllowThreads();
17504 result = (wxPyArtProvider *)new wxPyArtProvider();
17505
17506 wxPyEndAllowThreads(__tstate);
17507 if (PyErr_Occurred()) SWIG_fail;
17508 }
17509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
17510 return resultobj;
17511 fail:
17512 return NULL;
17513 }
17514
17515
17516 static PyObject *_wrap_delete_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17517 PyObject *resultobj = NULL;
17518 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17519 PyObject * obj0 = 0 ;
17520 char *kwnames[] = {
17521 (char *) "self", NULL
17522 };
17523
17524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ArtProvider",kwnames,&obj0)) goto fail;
17525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17526 if (SWIG_arg_fail(1)) SWIG_fail;
17527 {
17528 PyThreadState* __tstate = wxPyBeginAllowThreads();
17529 delete arg1;
17530
17531 wxPyEndAllowThreads(__tstate);
17532 if (PyErr_Occurred()) SWIG_fail;
17533 }
17534 Py_INCREF(Py_None); resultobj = Py_None;
17535 return resultobj;
17536 fail:
17537 return NULL;
17538 }
17539
17540
17541 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
17542 PyObject *resultobj = NULL;
17543 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17544 PyObject *arg2 = (PyObject *) 0 ;
17545 PyObject *arg3 = (PyObject *) 0 ;
17546 PyObject * obj0 = 0 ;
17547 PyObject * obj1 = 0 ;
17548 PyObject * obj2 = 0 ;
17549 char *kwnames[] = {
17550 (char *) "self",(char *) "self",(char *) "_class", NULL
17551 };
17552
17553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
17554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17555 if (SWIG_arg_fail(1)) SWIG_fail;
17556 arg2 = obj1;
17557 arg3 = obj2;
17558 {
17559 PyThreadState* __tstate = wxPyBeginAllowThreads();
17560 (arg1)->_setCallbackInfo(arg2,arg3);
17561
17562 wxPyEndAllowThreads(__tstate);
17563 if (PyErr_Occurred()) SWIG_fail;
17564 }
17565 Py_INCREF(Py_None); resultobj = Py_None;
17566 return resultobj;
17567 fail:
17568 return NULL;
17569 }
17570
17571
17572 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17573 PyObject *resultobj = NULL;
17574 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17575 PyObject * obj0 = 0 ;
17576 char *kwnames[] = {
17577 (char *) "provider", NULL
17578 };
17579
17580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
17581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
17582 if (SWIG_arg_fail(1)) SWIG_fail;
17583 {
17584 PyThreadState* __tstate = wxPyBeginAllowThreads();
17585 wxPyArtProvider::PushProvider(arg1);
17586
17587 wxPyEndAllowThreads(__tstate);
17588 if (PyErr_Occurred()) SWIG_fail;
17589 }
17590 Py_INCREF(Py_None); resultobj = Py_None;
17591 return resultobj;
17592 fail:
17593 return NULL;
17594 }
17595
17596
17597 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17598 PyObject *resultobj = NULL;
17599 bool result;
17600 char *kwnames[] = {
17601 NULL
17602 };
17603
17604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
17605 {
17606 PyThreadState* __tstate = wxPyBeginAllowThreads();
17607 result = (bool)wxPyArtProvider::PopProvider();
17608
17609 wxPyEndAllowThreads(__tstate);
17610 if (PyErr_Occurred()) SWIG_fail;
17611 }
17612 {
17613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17614 }
17615 return resultobj;
17616 fail:
17617 return NULL;
17618 }
17619
17620
17621 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17622 PyObject *resultobj = NULL;
17623 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17624 bool result;
17625 PyObject * obj0 = 0 ;
17626 char *kwnames[] = {
17627 (char *) "provider", NULL
17628 };
17629
17630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
17631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17632 if (SWIG_arg_fail(1)) SWIG_fail;
17633 {
17634 PyThreadState* __tstate = wxPyBeginAllowThreads();
17635 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
17636
17637 wxPyEndAllowThreads(__tstate);
17638 if (PyErr_Occurred()) SWIG_fail;
17639 }
17640 {
17641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17642 }
17643 return resultobj;
17644 fail:
17645 return NULL;
17646 }
17647
17648
17649 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
17650 PyObject *resultobj = NULL;
17651 wxString *arg1 = 0 ;
17652 wxString const &arg2_defvalue = wxPyART_OTHER ;
17653 wxString *arg2 = (wxString *) &arg2_defvalue ;
17654 wxSize const &arg3_defvalue = wxDefaultSize ;
17655 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
17656 wxBitmap result;
17657 bool temp1 = false ;
17658 bool temp2 = false ;
17659 wxSize temp3 ;
17660 PyObject * obj0 = 0 ;
17661 PyObject * obj1 = 0 ;
17662 PyObject * obj2 = 0 ;
17663 char *kwnames[] = {
17664 (char *) "id",(char *) "client",(char *) "size", NULL
17665 };
17666
17667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
17668 {
17669 arg1 = wxString_in_helper(obj0);
17670 if (arg1 == NULL) SWIG_fail;
17671 temp1 = true;
17672 }
17673 if (obj1) {
17674 {
17675 arg2 = wxString_in_helper(obj1);
17676 if (arg2 == NULL) SWIG_fail;
17677 temp2 = true;
17678 }
17679 }
17680 if (obj2) {
17681 {
17682 arg3 = &temp3;
17683 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
17684 }
17685 }
17686 {
17687 if (!wxPyCheckForApp()) SWIG_fail;
17688 PyThreadState* __tstate = wxPyBeginAllowThreads();
17689 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
17690
17691 wxPyEndAllowThreads(__tstate);
17692 if (PyErr_Occurred()) SWIG_fail;
17693 }
17694 {
17695 wxBitmap * resultptr;
17696 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
17697 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
17698 }
17699 {
17700 if (temp1)
17701 delete arg1;
17702 }
17703 {
17704 if (temp2)
17705 delete arg2;
17706 }
17707 return resultobj;
17708 fail:
17709 {
17710 if (temp1)
17711 delete arg1;
17712 }
17713 {
17714 if (temp2)
17715 delete arg2;
17716 }
17717 return NULL;
17718 }
17719
17720
17721 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
17722 PyObject *resultobj = NULL;
17723 wxString *arg1 = 0 ;
17724 wxString const &arg2_defvalue = wxPyART_OTHER ;
17725 wxString *arg2 = (wxString *) &arg2_defvalue ;
17726 wxSize const &arg3_defvalue = wxDefaultSize ;
17727 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
17728 wxIcon result;
17729 bool temp1 = false ;
17730 bool temp2 = false ;
17731 wxSize temp3 ;
17732 PyObject * obj0 = 0 ;
17733 PyObject * obj1 = 0 ;
17734 PyObject * obj2 = 0 ;
17735 char *kwnames[] = {
17736 (char *) "id",(char *) "client",(char *) "size", NULL
17737 };
17738
17739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
17740 {
17741 arg1 = wxString_in_helper(obj0);
17742 if (arg1 == NULL) SWIG_fail;
17743 temp1 = true;
17744 }
17745 if (obj1) {
17746 {
17747 arg2 = wxString_in_helper(obj1);
17748 if (arg2 == NULL) SWIG_fail;
17749 temp2 = true;
17750 }
17751 }
17752 if (obj2) {
17753 {
17754 arg3 = &temp3;
17755 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
17756 }
17757 }
17758 {
17759 if (!wxPyCheckForApp()) SWIG_fail;
17760 PyThreadState* __tstate = wxPyBeginAllowThreads();
17761 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
17762
17763 wxPyEndAllowThreads(__tstate);
17764 if (PyErr_Occurred()) SWIG_fail;
17765 }
17766 {
17767 wxIcon * resultptr;
17768 resultptr = new wxIcon(static_cast<wxIcon & >(result));
17769 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
17770 }
17771 {
17772 if (temp1)
17773 delete arg1;
17774 }
17775 {
17776 if (temp2)
17777 delete arg2;
17778 }
17779 return resultobj;
17780 fail:
17781 {
17782 if (temp1)
17783 delete arg1;
17784 }
17785 {
17786 if (temp2)
17787 delete arg2;
17788 }
17789 return NULL;
17790 }
17791
17792
17793 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
17794 PyObject *resultobj = NULL;
17795 wxString *arg1 = 0 ;
17796 bool arg2 = (bool) false ;
17797 wxSize result;
17798 bool temp1 = false ;
17799 PyObject * obj0 = 0 ;
17800 PyObject * obj1 = 0 ;
17801 char *kwnames[] = {
17802 (char *) "client",(char *) "platform_dependent", NULL
17803 };
17804
17805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
17806 {
17807 arg1 = wxString_in_helper(obj0);
17808 if (arg1 == NULL) SWIG_fail;
17809 temp1 = true;
17810 }
17811 if (obj1) {
17812 {
17813 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
17814 if (SWIG_arg_fail(2)) SWIG_fail;
17815 }
17816 }
17817 {
17818 PyThreadState* __tstate = wxPyBeginAllowThreads();
17819 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
17820
17821 wxPyEndAllowThreads(__tstate);
17822 if (PyErr_Occurred()) SWIG_fail;
17823 }
17824 {
17825 wxSize * resultptr;
17826 resultptr = new wxSize(static_cast<wxSize & >(result));
17827 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
17828 }
17829 {
17830 if (temp1)
17831 delete arg1;
17832 }
17833 return resultobj;
17834 fail:
17835 {
17836 if (temp1)
17837 delete arg1;
17838 }
17839 return NULL;
17840 }
17841
17842
17843 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
17844 PyObject *resultobj = NULL;
17845 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17846 PyObject * obj0 = 0 ;
17847 char *kwnames[] = {
17848 (char *) "self", NULL
17849 };
17850
17851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
17852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17853 if (SWIG_arg_fail(1)) SWIG_fail;
17854 {
17855 PyThreadState* __tstate = wxPyBeginAllowThreads();
17856 wxPyArtProvider_Destroy(arg1);
17857
17858 wxPyEndAllowThreads(__tstate);
17859 if (PyErr_Occurred()) SWIG_fail;
17860 }
17861 Py_INCREF(Py_None); resultobj = Py_None;
17862 return resultobj;
17863 fail:
17864 return NULL;
17865 }
17866
17867
17868 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
17869 PyObject *obj;
17870 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17871 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
17872 Py_INCREF(obj);
17873 return Py_BuildValue((char *)"");
17874 }
17875 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
17876 PyObject *resultobj = NULL;
17877 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17878 PyObject * obj0 = 0 ;
17879 char *kwnames[] = {
17880 (char *) "self", NULL
17881 };
17882
17883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
17884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17885 if (SWIG_arg_fail(1)) SWIG_fail;
17886 {
17887 PyThreadState* __tstate = wxPyBeginAllowThreads();
17888 delete arg1;
17889
17890 wxPyEndAllowThreads(__tstate);
17891 if (PyErr_Occurred()) SWIG_fail;
17892 }
17893 Py_INCREF(Py_None); resultobj = Py_None;
17894 return resultobj;
17895 fail:
17896 return NULL;
17897 }
17898
17899
17900 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
17901 PyObject *resultobj = NULL;
17902 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17903 wxConfigBase *result;
17904 PyObject * obj0 = 0 ;
17905 char *kwnames[] = {
17906 (char *) "config", NULL
17907 };
17908
17909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
17910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
17911 if (SWIG_arg_fail(1)) SWIG_fail;
17912 {
17913 PyThreadState* __tstate = wxPyBeginAllowThreads();
17914 result = (wxConfigBase *)wxConfigBase::Set(arg1);
17915
17916 wxPyEndAllowThreads(__tstate);
17917 if (PyErr_Occurred()) SWIG_fail;
17918 }
17919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17920 return resultobj;
17921 fail:
17922 return NULL;
17923 }
17924
17925
17926 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
17927 PyObject *resultobj = NULL;
17928 bool arg1 = (bool) true ;
17929 wxConfigBase *result;
17930 PyObject * obj0 = 0 ;
17931 char *kwnames[] = {
17932 (char *) "createOnDemand", NULL
17933 };
17934
17935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
17936 if (obj0) {
17937 {
17938 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
17939 if (SWIG_arg_fail(1)) SWIG_fail;
17940 }
17941 }
17942 {
17943 PyThreadState* __tstate = wxPyBeginAllowThreads();
17944 result = (wxConfigBase *)wxConfigBase::Get(arg1);
17945
17946 wxPyEndAllowThreads(__tstate);
17947 if (PyErr_Occurred()) SWIG_fail;
17948 }
17949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17950 return resultobj;
17951 fail:
17952 return NULL;
17953 }
17954
17955
17956 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17957 PyObject *resultobj = NULL;
17958 wxConfigBase *result;
17959 char *kwnames[] = {
17960 NULL
17961 };
17962
17963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
17964 {
17965 PyThreadState* __tstate = wxPyBeginAllowThreads();
17966 result = (wxConfigBase *)wxConfigBase::Create();
17967
17968 wxPyEndAllowThreads(__tstate);
17969 if (PyErr_Occurred()) SWIG_fail;
17970 }
17971 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17972 return resultobj;
17973 fail:
17974 return NULL;
17975 }
17976
17977
17978 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17979 PyObject *resultobj = NULL;
17980 char *kwnames[] = {
17981 NULL
17982 };
17983
17984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17985 {
17986 PyThreadState* __tstate = wxPyBeginAllowThreads();
17987 wxConfigBase::DontCreateOnDemand();
17988
17989 wxPyEndAllowThreads(__tstate);
17990 if (PyErr_Occurred()) SWIG_fail;
17991 }
17992 Py_INCREF(Py_None); resultobj = Py_None;
17993 return resultobj;
17994 fail:
17995 return NULL;
17996 }
17997
17998
17999 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
18000 PyObject *resultobj = NULL;
18001 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18002 wxString *arg2 = 0 ;
18003 bool temp2 = false ;
18004 PyObject * obj0 = 0 ;
18005 PyObject * obj1 = 0 ;
18006 char *kwnames[] = {
18007 (char *) "self",(char *) "path", NULL
18008 };
18009
18010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
18011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18012 if (SWIG_arg_fail(1)) SWIG_fail;
18013 {
18014 arg2 = wxString_in_helper(obj1);
18015 if (arg2 == NULL) SWIG_fail;
18016 temp2 = true;
18017 }
18018 {
18019 PyThreadState* __tstate = wxPyBeginAllowThreads();
18020 (arg1)->SetPath((wxString const &)*arg2);
18021
18022 wxPyEndAllowThreads(__tstate);
18023 if (PyErr_Occurred()) SWIG_fail;
18024 }
18025 Py_INCREF(Py_None); resultobj = Py_None;
18026 {
18027 if (temp2)
18028 delete arg2;
18029 }
18030 return resultobj;
18031 fail:
18032 {
18033 if (temp2)
18034 delete arg2;
18035 }
18036 return NULL;
18037 }
18038
18039
18040 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
18041 PyObject *resultobj = NULL;
18042 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18043 wxString *result;
18044 PyObject * obj0 = 0 ;
18045 char *kwnames[] = {
18046 (char *) "self", NULL
18047 };
18048
18049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
18050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18051 if (SWIG_arg_fail(1)) SWIG_fail;
18052 {
18053 PyThreadState* __tstate = wxPyBeginAllowThreads();
18054 {
18055 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
18056 result = (wxString *) &_result_ref;
18057 }
18058
18059 wxPyEndAllowThreads(__tstate);
18060 if (PyErr_Occurred()) SWIG_fail;
18061 }
18062 {
18063 #if wxUSE_UNICODE
18064 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18065 #else
18066 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18067 #endif
18068 }
18069 return resultobj;
18070 fail:
18071 return NULL;
18072 }
18073
18074
18075 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18076 PyObject *resultobj = NULL;
18077 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18078 PyObject *result;
18079 PyObject * obj0 = 0 ;
18080 char *kwnames[] = {
18081 (char *) "self", NULL
18082 };
18083
18084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
18085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18086 if (SWIG_arg_fail(1)) SWIG_fail;
18087 {
18088 PyThreadState* __tstate = wxPyBeginAllowThreads();
18089 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
18090
18091 wxPyEndAllowThreads(__tstate);
18092 if (PyErr_Occurred()) SWIG_fail;
18093 }
18094 resultobj = result;
18095 return resultobj;
18096 fail:
18097 return NULL;
18098 }
18099
18100
18101 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18102 PyObject *resultobj = NULL;
18103 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18104 long arg2 ;
18105 PyObject *result;
18106 PyObject * obj0 = 0 ;
18107 PyObject * obj1 = 0 ;
18108 char *kwnames[] = {
18109 (char *) "self",(char *) "index", NULL
18110 };
18111
18112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
18113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18114 if (SWIG_arg_fail(1)) SWIG_fail;
18115 {
18116 arg2 = static_cast<long >(SWIG_As_long(obj1));
18117 if (SWIG_arg_fail(2)) SWIG_fail;
18118 }
18119 {
18120 PyThreadState* __tstate = wxPyBeginAllowThreads();
18121 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
18122
18123 wxPyEndAllowThreads(__tstate);
18124 if (PyErr_Occurred()) SWIG_fail;
18125 }
18126 resultobj = result;
18127 return resultobj;
18128 fail:
18129 return NULL;
18130 }
18131
18132
18133 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18134 PyObject *resultobj = NULL;
18135 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18136 PyObject *result;
18137 PyObject * obj0 = 0 ;
18138 char *kwnames[] = {
18139 (char *) "self", NULL
18140 };
18141
18142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
18143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18144 if (SWIG_arg_fail(1)) SWIG_fail;
18145 {
18146 PyThreadState* __tstate = wxPyBeginAllowThreads();
18147 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
18148
18149 wxPyEndAllowThreads(__tstate);
18150 if (PyErr_Occurred()) SWIG_fail;
18151 }
18152 resultobj = result;
18153 return resultobj;
18154 fail:
18155 return NULL;
18156 }
18157
18158
18159 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18160 PyObject *resultobj = NULL;
18161 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18162 long arg2 ;
18163 PyObject *result;
18164 PyObject * obj0 = 0 ;
18165 PyObject * obj1 = 0 ;
18166 char *kwnames[] = {
18167 (char *) "self",(char *) "index", NULL
18168 };
18169
18170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
18171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18172 if (SWIG_arg_fail(1)) SWIG_fail;
18173 {
18174 arg2 = static_cast<long >(SWIG_As_long(obj1));
18175 if (SWIG_arg_fail(2)) SWIG_fail;
18176 }
18177 {
18178 PyThreadState* __tstate = wxPyBeginAllowThreads();
18179 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
18180
18181 wxPyEndAllowThreads(__tstate);
18182 if (PyErr_Occurred()) SWIG_fail;
18183 }
18184 resultobj = result;
18185 return resultobj;
18186 fail:
18187 return NULL;
18188 }
18189
18190
18191 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
18192 PyObject *resultobj = NULL;
18193 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18194 bool arg2 = (bool) false ;
18195 size_t result;
18196 PyObject * obj0 = 0 ;
18197 PyObject * obj1 = 0 ;
18198 char *kwnames[] = {
18199 (char *) "self",(char *) "recursive", NULL
18200 };
18201
18202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
18203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18204 if (SWIG_arg_fail(1)) SWIG_fail;
18205 if (obj1) {
18206 {
18207 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18208 if (SWIG_arg_fail(2)) SWIG_fail;
18209 }
18210 }
18211 {
18212 PyThreadState* __tstate = wxPyBeginAllowThreads();
18213 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
18214
18215 wxPyEndAllowThreads(__tstate);
18216 if (PyErr_Occurred()) SWIG_fail;
18217 }
18218 {
18219 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
18220 }
18221 return resultobj;
18222 fail:
18223 return NULL;
18224 }
18225
18226
18227 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
18228 PyObject *resultobj = NULL;
18229 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18230 bool arg2 = (bool) false ;
18231 size_t result;
18232 PyObject * obj0 = 0 ;
18233 PyObject * obj1 = 0 ;
18234 char *kwnames[] = {
18235 (char *) "self",(char *) "recursive", NULL
18236 };
18237
18238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
18239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18240 if (SWIG_arg_fail(1)) SWIG_fail;
18241 if (obj1) {
18242 {
18243 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18244 if (SWIG_arg_fail(2)) SWIG_fail;
18245 }
18246 }
18247 {
18248 PyThreadState* __tstate = wxPyBeginAllowThreads();
18249 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
18250
18251 wxPyEndAllowThreads(__tstate);
18252 if (PyErr_Occurred()) SWIG_fail;
18253 }
18254 {
18255 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
18256 }
18257 return resultobj;
18258 fail:
18259 return NULL;
18260 }
18261
18262
18263 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18264 PyObject *resultobj = NULL;
18265 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18266 wxString *arg2 = 0 ;
18267 bool result;
18268 bool temp2 = false ;
18269 PyObject * obj0 = 0 ;
18270 PyObject * obj1 = 0 ;
18271 char *kwnames[] = {
18272 (char *) "self",(char *) "name", NULL
18273 };
18274
18275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
18276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18277 if (SWIG_arg_fail(1)) SWIG_fail;
18278 {
18279 arg2 = wxString_in_helper(obj1);
18280 if (arg2 == NULL) SWIG_fail;
18281 temp2 = true;
18282 }
18283 {
18284 PyThreadState* __tstate = wxPyBeginAllowThreads();
18285 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
18286
18287 wxPyEndAllowThreads(__tstate);
18288 if (PyErr_Occurred()) SWIG_fail;
18289 }
18290 {
18291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18292 }
18293 {
18294 if (temp2)
18295 delete arg2;
18296 }
18297 return resultobj;
18298 fail:
18299 {
18300 if (temp2)
18301 delete arg2;
18302 }
18303 return NULL;
18304 }
18305
18306
18307 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18308 PyObject *resultobj = NULL;
18309 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18310 wxString *arg2 = 0 ;
18311 bool result;
18312 bool temp2 = false ;
18313 PyObject * obj0 = 0 ;
18314 PyObject * obj1 = 0 ;
18315 char *kwnames[] = {
18316 (char *) "self",(char *) "name", NULL
18317 };
18318
18319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
18320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18321 if (SWIG_arg_fail(1)) SWIG_fail;
18322 {
18323 arg2 = wxString_in_helper(obj1);
18324 if (arg2 == NULL) SWIG_fail;
18325 temp2 = true;
18326 }
18327 {
18328 PyThreadState* __tstate = wxPyBeginAllowThreads();
18329 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
18330
18331 wxPyEndAllowThreads(__tstate);
18332 if (PyErr_Occurred()) SWIG_fail;
18333 }
18334 {
18335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18336 }
18337 {
18338 if (temp2)
18339 delete arg2;
18340 }
18341 return resultobj;
18342 fail:
18343 {
18344 if (temp2)
18345 delete arg2;
18346 }
18347 return NULL;
18348 }
18349
18350
18351 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
18352 PyObject *resultobj = NULL;
18353 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18354 wxString *arg2 = 0 ;
18355 bool result;
18356 bool temp2 = false ;
18357 PyObject * obj0 = 0 ;
18358 PyObject * obj1 = 0 ;
18359 char *kwnames[] = {
18360 (char *) "self",(char *) "name", NULL
18361 };
18362
18363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
18364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18365 if (SWIG_arg_fail(1)) SWIG_fail;
18366 {
18367 arg2 = wxString_in_helper(obj1);
18368 if (arg2 == NULL) SWIG_fail;
18369 temp2 = true;
18370 }
18371 {
18372 PyThreadState* __tstate = wxPyBeginAllowThreads();
18373 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
18374
18375 wxPyEndAllowThreads(__tstate);
18376 if (PyErr_Occurred()) SWIG_fail;
18377 }
18378 {
18379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18380 }
18381 {
18382 if (temp2)
18383 delete arg2;
18384 }
18385 return resultobj;
18386 fail:
18387 {
18388 if (temp2)
18389 delete arg2;
18390 }
18391 return NULL;
18392 }
18393
18394
18395 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
18396 PyObject *resultobj = NULL;
18397 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18398 wxString *arg2 = 0 ;
18399 wxConfigBase::EntryType result;
18400 bool temp2 = false ;
18401 PyObject * obj0 = 0 ;
18402 PyObject * obj1 = 0 ;
18403 char *kwnames[] = {
18404 (char *) "self",(char *) "name", NULL
18405 };
18406
18407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
18408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18409 if (SWIG_arg_fail(1)) SWIG_fail;
18410 {
18411 arg2 = wxString_in_helper(obj1);
18412 if (arg2 == NULL) SWIG_fail;
18413 temp2 = true;
18414 }
18415 {
18416 PyThreadState* __tstate = wxPyBeginAllowThreads();
18417 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
18418
18419 wxPyEndAllowThreads(__tstate);
18420 if (PyErr_Occurred()) SWIG_fail;
18421 }
18422 resultobj = SWIG_From_int((result));
18423 {
18424 if (temp2)
18425 delete arg2;
18426 }
18427 return resultobj;
18428 fail:
18429 {
18430 if (temp2)
18431 delete arg2;
18432 }
18433 return NULL;
18434 }
18435
18436
18437 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
18438 PyObject *resultobj = NULL;
18439 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18440 wxString *arg2 = 0 ;
18441 wxString const &arg3_defvalue = wxPyEmptyString ;
18442 wxString *arg3 = (wxString *) &arg3_defvalue ;
18443 wxString result;
18444 bool temp2 = false ;
18445 bool temp3 = false ;
18446 PyObject * obj0 = 0 ;
18447 PyObject * obj1 = 0 ;
18448 PyObject * obj2 = 0 ;
18449 char *kwnames[] = {
18450 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
18451 };
18452
18453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
18454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18455 if (SWIG_arg_fail(1)) SWIG_fail;
18456 {
18457 arg2 = wxString_in_helper(obj1);
18458 if (arg2 == NULL) SWIG_fail;
18459 temp2 = true;
18460 }
18461 if (obj2) {
18462 {
18463 arg3 = wxString_in_helper(obj2);
18464 if (arg3 == NULL) SWIG_fail;
18465 temp3 = true;
18466 }
18467 }
18468 {
18469 PyThreadState* __tstate = wxPyBeginAllowThreads();
18470 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
18471
18472 wxPyEndAllowThreads(__tstate);
18473 if (PyErr_Occurred()) SWIG_fail;
18474 }
18475 {
18476 #if wxUSE_UNICODE
18477 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18478 #else
18479 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18480 #endif
18481 }
18482 {
18483 if (temp2)
18484 delete arg2;
18485 }
18486 {
18487 if (temp3)
18488 delete arg3;
18489 }
18490 return resultobj;
18491 fail:
18492 {
18493 if (temp2)
18494 delete arg2;
18495 }
18496 {
18497 if (temp3)
18498 delete arg3;
18499 }
18500 return NULL;
18501 }
18502
18503
18504 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
18505 PyObject *resultobj = NULL;
18506 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18507 wxString *arg2 = 0 ;
18508 long arg3 = (long) 0 ;
18509 long result;
18510 bool temp2 = false ;
18511 PyObject * obj0 = 0 ;
18512 PyObject * obj1 = 0 ;
18513 PyObject * obj2 = 0 ;
18514 char *kwnames[] = {
18515 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
18516 };
18517
18518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
18519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18520 if (SWIG_arg_fail(1)) SWIG_fail;
18521 {
18522 arg2 = wxString_in_helper(obj1);
18523 if (arg2 == NULL) SWIG_fail;
18524 temp2 = true;
18525 }
18526 if (obj2) {
18527 {
18528 arg3 = static_cast<long >(SWIG_As_long(obj2));
18529 if (SWIG_arg_fail(3)) SWIG_fail;
18530 }
18531 }
18532 {
18533 PyThreadState* __tstate = wxPyBeginAllowThreads();
18534 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
18535
18536 wxPyEndAllowThreads(__tstate);
18537 if (PyErr_Occurred()) SWIG_fail;
18538 }
18539 {
18540 resultobj = SWIG_From_long(static_cast<long >(result));
18541 }
18542 {
18543 if (temp2)
18544 delete arg2;
18545 }
18546 return resultobj;
18547 fail:
18548 {
18549 if (temp2)
18550 delete arg2;
18551 }
18552 return NULL;
18553 }
18554
18555
18556 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
18557 PyObject *resultobj = NULL;
18558 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18559 wxString *arg2 = 0 ;
18560 double arg3 = (double) 0.0 ;
18561 double result;
18562 bool temp2 = false ;
18563 PyObject * obj0 = 0 ;
18564 PyObject * obj1 = 0 ;
18565 PyObject * obj2 = 0 ;
18566 char *kwnames[] = {
18567 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
18568 };
18569
18570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
18571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18572 if (SWIG_arg_fail(1)) SWIG_fail;
18573 {
18574 arg2 = wxString_in_helper(obj1);
18575 if (arg2 == NULL) SWIG_fail;
18576 temp2 = true;
18577 }
18578 if (obj2) {
18579 {
18580 arg3 = static_cast<double >(SWIG_As_double(obj2));
18581 if (SWIG_arg_fail(3)) SWIG_fail;
18582 }
18583 }
18584 {
18585 PyThreadState* __tstate = wxPyBeginAllowThreads();
18586 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
18587
18588 wxPyEndAllowThreads(__tstate);
18589 if (PyErr_Occurred()) SWIG_fail;
18590 }
18591 {
18592 resultobj = SWIG_From_double(static_cast<double >(result));
18593 }
18594 {
18595 if (temp2)
18596 delete arg2;
18597 }
18598 return resultobj;
18599 fail:
18600 {
18601 if (temp2)
18602 delete arg2;
18603 }
18604 return NULL;
18605 }
18606
18607
18608 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
18609 PyObject *resultobj = NULL;
18610 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18611 wxString *arg2 = 0 ;
18612 bool arg3 = (bool) false ;
18613 bool result;
18614 bool temp2 = false ;
18615 PyObject * obj0 = 0 ;
18616 PyObject * obj1 = 0 ;
18617 PyObject * obj2 = 0 ;
18618 char *kwnames[] = {
18619 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
18620 };
18621
18622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
18623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18624 if (SWIG_arg_fail(1)) SWIG_fail;
18625 {
18626 arg2 = wxString_in_helper(obj1);
18627 if (arg2 == NULL) SWIG_fail;
18628 temp2 = true;
18629 }
18630 if (obj2) {
18631 {
18632 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
18633 if (SWIG_arg_fail(3)) SWIG_fail;
18634 }
18635 }
18636 {
18637 PyThreadState* __tstate = wxPyBeginAllowThreads();
18638 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
18639
18640 wxPyEndAllowThreads(__tstate);
18641 if (PyErr_Occurred()) SWIG_fail;
18642 }
18643 {
18644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18645 }
18646 {
18647 if (temp2)
18648 delete arg2;
18649 }
18650 return resultobj;
18651 fail:
18652 {
18653 if (temp2)
18654 delete arg2;
18655 }
18656 return NULL;
18657 }
18658
18659
18660 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
18661 PyObject *resultobj = NULL;
18662 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18663 wxString *arg2 = 0 ;
18664 wxString *arg3 = 0 ;
18665 bool result;
18666 bool temp2 = false ;
18667 bool temp3 = false ;
18668 PyObject * obj0 = 0 ;
18669 PyObject * obj1 = 0 ;
18670 PyObject * obj2 = 0 ;
18671 char *kwnames[] = {
18672 (char *) "self",(char *) "key",(char *) "value", NULL
18673 };
18674
18675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
18676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18677 if (SWIG_arg_fail(1)) SWIG_fail;
18678 {
18679 arg2 = wxString_in_helper(obj1);
18680 if (arg2 == NULL) SWIG_fail;
18681 temp2 = true;
18682 }
18683 {
18684 arg3 = wxString_in_helper(obj2);
18685 if (arg3 == NULL) SWIG_fail;
18686 temp3 = true;
18687 }
18688 {
18689 PyThreadState* __tstate = wxPyBeginAllowThreads();
18690 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
18691
18692 wxPyEndAllowThreads(__tstate);
18693 if (PyErr_Occurred()) SWIG_fail;
18694 }
18695 {
18696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18697 }
18698 {
18699 if (temp2)
18700 delete arg2;
18701 }
18702 {
18703 if (temp3)
18704 delete arg3;
18705 }
18706 return resultobj;
18707 fail:
18708 {
18709 if (temp2)
18710 delete arg2;
18711 }
18712 {
18713 if (temp3)
18714 delete arg3;
18715 }
18716 return NULL;
18717 }
18718
18719
18720 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
18721 PyObject *resultobj = NULL;
18722 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18723 wxString *arg2 = 0 ;
18724 long arg3 ;
18725 bool result;
18726 bool temp2 = false ;
18727 PyObject * obj0 = 0 ;
18728 PyObject * obj1 = 0 ;
18729 PyObject * obj2 = 0 ;
18730 char *kwnames[] = {
18731 (char *) "self",(char *) "key",(char *) "value", NULL
18732 };
18733
18734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
18735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18736 if (SWIG_arg_fail(1)) SWIG_fail;
18737 {
18738 arg2 = wxString_in_helper(obj1);
18739 if (arg2 == NULL) SWIG_fail;
18740 temp2 = true;
18741 }
18742 {
18743 arg3 = static_cast<long >(SWIG_As_long(obj2));
18744 if (SWIG_arg_fail(3)) SWIG_fail;
18745 }
18746 {
18747 PyThreadState* __tstate = wxPyBeginAllowThreads();
18748 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
18749
18750 wxPyEndAllowThreads(__tstate);
18751 if (PyErr_Occurred()) SWIG_fail;
18752 }
18753 {
18754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18755 }
18756 {
18757 if (temp2)
18758 delete arg2;
18759 }
18760 return resultobj;
18761 fail:
18762 {
18763 if (temp2)
18764 delete arg2;
18765 }
18766 return NULL;
18767 }
18768
18769
18770 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
18771 PyObject *resultobj = NULL;
18772 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18773 wxString *arg2 = 0 ;
18774 double arg3 ;
18775 bool result;
18776 bool temp2 = false ;
18777 PyObject * obj0 = 0 ;
18778 PyObject * obj1 = 0 ;
18779 PyObject * obj2 = 0 ;
18780 char *kwnames[] = {
18781 (char *) "self",(char *) "key",(char *) "value", NULL
18782 };
18783
18784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
18785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18786 if (SWIG_arg_fail(1)) SWIG_fail;
18787 {
18788 arg2 = wxString_in_helper(obj1);
18789 if (arg2 == NULL) SWIG_fail;
18790 temp2 = true;
18791 }
18792 {
18793 arg3 = static_cast<double >(SWIG_As_double(obj2));
18794 if (SWIG_arg_fail(3)) SWIG_fail;
18795 }
18796 {
18797 PyThreadState* __tstate = wxPyBeginAllowThreads();
18798 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
18799
18800 wxPyEndAllowThreads(__tstate);
18801 if (PyErr_Occurred()) SWIG_fail;
18802 }
18803 {
18804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18805 }
18806 {
18807 if (temp2)
18808 delete arg2;
18809 }
18810 return resultobj;
18811 fail:
18812 {
18813 if (temp2)
18814 delete arg2;
18815 }
18816 return NULL;
18817 }
18818
18819
18820 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
18821 PyObject *resultobj = NULL;
18822 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18823 wxString *arg2 = 0 ;
18824 bool arg3 ;
18825 bool result;
18826 bool temp2 = false ;
18827 PyObject * obj0 = 0 ;
18828 PyObject * obj1 = 0 ;
18829 PyObject * obj2 = 0 ;
18830 char *kwnames[] = {
18831 (char *) "self",(char *) "key",(char *) "value", NULL
18832 };
18833
18834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
18835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18836 if (SWIG_arg_fail(1)) SWIG_fail;
18837 {
18838 arg2 = wxString_in_helper(obj1);
18839 if (arg2 == NULL) SWIG_fail;
18840 temp2 = true;
18841 }
18842 {
18843 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
18844 if (SWIG_arg_fail(3)) SWIG_fail;
18845 }
18846 {
18847 PyThreadState* __tstate = wxPyBeginAllowThreads();
18848 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
18849
18850 wxPyEndAllowThreads(__tstate);
18851 if (PyErr_Occurred()) SWIG_fail;
18852 }
18853 {
18854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18855 }
18856 {
18857 if (temp2)
18858 delete arg2;
18859 }
18860 return resultobj;
18861 fail:
18862 {
18863 if (temp2)
18864 delete arg2;
18865 }
18866 return NULL;
18867 }
18868
18869
18870 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
18871 PyObject *resultobj = NULL;
18872 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18873 bool arg2 = (bool) false ;
18874 bool result;
18875 PyObject * obj0 = 0 ;
18876 PyObject * obj1 = 0 ;
18877 char *kwnames[] = {
18878 (char *) "self",(char *) "currentOnly", NULL
18879 };
18880
18881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
18882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18883 if (SWIG_arg_fail(1)) SWIG_fail;
18884 if (obj1) {
18885 {
18886 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18887 if (SWIG_arg_fail(2)) SWIG_fail;
18888 }
18889 }
18890 {
18891 PyThreadState* __tstate = wxPyBeginAllowThreads();
18892 result = (bool)(arg1)->Flush(arg2);
18893
18894 wxPyEndAllowThreads(__tstate);
18895 if (PyErr_Occurred()) SWIG_fail;
18896 }
18897 {
18898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18899 }
18900 return resultobj;
18901 fail:
18902 return NULL;
18903 }
18904
18905
18906 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18907 PyObject *resultobj = NULL;
18908 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18909 wxString *arg2 = 0 ;
18910 wxString *arg3 = 0 ;
18911 bool result;
18912 bool temp2 = false ;
18913 bool temp3 = false ;
18914 PyObject * obj0 = 0 ;
18915 PyObject * obj1 = 0 ;
18916 PyObject * obj2 = 0 ;
18917 char *kwnames[] = {
18918 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18919 };
18920
18921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18923 if (SWIG_arg_fail(1)) SWIG_fail;
18924 {
18925 arg2 = wxString_in_helper(obj1);
18926 if (arg2 == NULL) SWIG_fail;
18927 temp2 = true;
18928 }
18929 {
18930 arg3 = wxString_in_helper(obj2);
18931 if (arg3 == NULL) SWIG_fail;
18932 temp3 = true;
18933 }
18934 {
18935 PyThreadState* __tstate = wxPyBeginAllowThreads();
18936 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
18937
18938 wxPyEndAllowThreads(__tstate);
18939 if (PyErr_Occurred()) SWIG_fail;
18940 }
18941 {
18942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18943 }
18944 {
18945 if (temp2)
18946 delete arg2;
18947 }
18948 {
18949 if (temp3)
18950 delete arg3;
18951 }
18952 return resultobj;
18953 fail:
18954 {
18955 if (temp2)
18956 delete arg2;
18957 }
18958 {
18959 if (temp3)
18960 delete arg3;
18961 }
18962 return NULL;
18963 }
18964
18965
18966 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18967 PyObject *resultobj = NULL;
18968 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18969 wxString *arg2 = 0 ;
18970 wxString *arg3 = 0 ;
18971 bool result;
18972 bool temp2 = false ;
18973 bool temp3 = false ;
18974 PyObject * obj0 = 0 ;
18975 PyObject * obj1 = 0 ;
18976 PyObject * obj2 = 0 ;
18977 char *kwnames[] = {
18978 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18979 };
18980
18981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18983 if (SWIG_arg_fail(1)) SWIG_fail;
18984 {
18985 arg2 = wxString_in_helper(obj1);
18986 if (arg2 == NULL) SWIG_fail;
18987 temp2 = true;
18988 }
18989 {
18990 arg3 = wxString_in_helper(obj2);
18991 if (arg3 == NULL) SWIG_fail;
18992 temp3 = true;
18993 }
18994 {
18995 PyThreadState* __tstate = wxPyBeginAllowThreads();
18996 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18997
18998 wxPyEndAllowThreads(__tstate);
18999 if (PyErr_Occurred()) SWIG_fail;
19000 }
19001 {
19002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19003 }
19004 {
19005 if (temp2)
19006 delete arg2;
19007 }
19008 {
19009 if (temp3)
19010 delete arg3;
19011 }
19012 return resultobj;
19013 fail:
19014 {
19015 if (temp2)
19016 delete arg2;
19017 }
19018 {
19019 if (temp3)
19020 delete arg3;
19021 }
19022 return NULL;
19023 }
19024
19025
19026 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
19027 PyObject *resultobj = NULL;
19028 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19029 wxString *arg2 = 0 ;
19030 bool arg3 = (bool) true ;
19031 bool result;
19032 bool temp2 = false ;
19033 PyObject * obj0 = 0 ;
19034 PyObject * obj1 = 0 ;
19035 PyObject * obj2 = 0 ;
19036 char *kwnames[] = {
19037 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
19038 };
19039
19040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
19041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19042 if (SWIG_arg_fail(1)) SWIG_fail;
19043 {
19044 arg2 = wxString_in_helper(obj1);
19045 if (arg2 == NULL) SWIG_fail;
19046 temp2 = true;
19047 }
19048 if (obj2) {
19049 {
19050 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
19051 if (SWIG_arg_fail(3)) SWIG_fail;
19052 }
19053 }
19054 {
19055 PyThreadState* __tstate = wxPyBeginAllowThreads();
19056 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
19057
19058 wxPyEndAllowThreads(__tstate);
19059 if (PyErr_Occurred()) SWIG_fail;
19060 }
19061 {
19062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19063 }
19064 {
19065 if (temp2)
19066 delete arg2;
19067 }
19068 return resultobj;
19069 fail:
19070 {
19071 if (temp2)
19072 delete arg2;
19073 }
19074 return NULL;
19075 }
19076
19077
19078 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
19079 PyObject *resultobj = NULL;
19080 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19081 wxString *arg2 = 0 ;
19082 bool result;
19083 bool temp2 = false ;
19084 PyObject * obj0 = 0 ;
19085 PyObject * obj1 = 0 ;
19086 char *kwnames[] = {
19087 (char *) "self",(char *) "key", NULL
19088 };
19089
19090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
19091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19092 if (SWIG_arg_fail(1)) SWIG_fail;
19093 {
19094 arg2 = wxString_in_helper(obj1);
19095 if (arg2 == NULL) SWIG_fail;
19096 temp2 = true;
19097 }
19098 {
19099 PyThreadState* __tstate = wxPyBeginAllowThreads();
19100 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
19101
19102 wxPyEndAllowThreads(__tstate);
19103 if (PyErr_Occurred()) SWIG_fail;
19104 }
19105 {
19106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19107 }
19108 {
19109 if (temp2)
19110 delete arg2;
19111 }
19112 return resultobj;
19113 fail:
19114 {
19115 if (temp2)
19116 delete arg2;
19117 }
19118 return NULL;
19119 }
19120
19121
19122 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
19123 PyObject *resultobj = NULL;
19124 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19125 bool result;
19126 PyObject * obj0 = 0 ;
19127 char *kwnames[] = {
19128 (char *) "self", NULL
19129 };
19130
19131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
19132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19133 if (SWIG_arg_fail(1)) SWIG_fail;
19134 {
19135 PyThreadState* __tstate = wxPyBeginAllowThreads();
19136 result = (bool)(arg1)->DeleteAll();
19137
19138 wxPyEndAllowThreads(__tstate);
19139 if (PyErr_Occurred()) SWIG_fail;
19140 }
19141 {
19142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19143 }
19144 return resultobj;
19145 fail:
19146 return NULL;
19147 }
19148
19149
19150 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19151 PyObject *resultobj = NULL;
19152 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19153 bool arg2 = (bool) true ;
19154 PyObject * obj0 = 0 ;
19155 PyObject * obj1 = 0 ;
19156 char *kwnames[] = {
19157 (char *) "self",(char *) "doIt", NULL
19158 };
19159
19160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
19161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19162 if (SWIG_arg_fail(1)) SWIG_fail;
19163 if (obj1) {
19164 {
19165 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19166 if (SWIG_arg_fail(2)) SWIG_fail;
19167 }
19168 }
19169 {
19170 PyThreadState* __tstate = wxPyBeginAllowThreads();
19171 (arg1)->SetExpandEnvVars(arg2);
19172
19173 wxPyEndAllowThreads(__tstate);
19174 if (PyErr_Occurred()) SWIG_fail;
19175 }
19176 Py_INCREF(Py_None); resultobj = Py_None;
19177 return resultobj;
19178 fail:
19179 return NULL;
19180 }
19181
19182
19183 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19184 PyObject *resultobj = NULL;
19185 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19186 bool result;
19187 PyObject * obj0 = 0 ;
19188 char *kwnames[] = {
19189 (char *) "self", NULL
19190 };
19191
19192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
19193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19194 if (SWIG_arg_fail(1)) SWIG_fail;
19195 {
19196 PyThreadState* __tstate = wxPyBeginAllowThreads();
19197 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
19198
19199 wxPyEndAllowThreads(__tstate);
19200 if (PyErr_Occurred()) SWIG_fail;
19201 }
19202 {
19203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19204 }
19205 return resultobj;
19206 fail:
19207 return NULL;
19208 }
19209
19210
19211 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
19212 PyObject *resultobj = NULL;
19213 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19214 bool arg2 = (bool) true ;
19215 PyObject * obj0 = 0 ;
19216 PyObject * obj1 = 0 ;
19217 char *kwnames[] = {
19218 (char *) "self",(char *) "doIt", NULL
19219 };
19220
19221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
19222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19223 if (SWIG_arg_fail(1)) SWIG_fail;
19224 if (obj1) {
19225 {
19226 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19227 if (SWIG_arg_fail(2)) SWIG_fail;
19228 }
19229 }
19230 {
19231 PyThreadState* __tstate = wxPyBeginAllowThreads();
19232 (arg1)->SetRecordDefaults(arg2);
19233
19234 wxPyEndAllowThreads(__tstate);
19235 if (PyErr_Occurred()) SWIG_fail;
19236 }
19237 Py_INCREF(Py_None); resultobj = Py_None;
19238 return resultobj;
19239 fail:
19240 return NULL;
19241 }
19242
19243
19244 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
19245 PyObject *resultobj = NULL;
19246 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19247 bool result;
19248 PyObject * obj0 = 0 ;
19249 char *kwnames[] = {
19250 (char *) "self", NULL
19251 };
19252
19253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
19254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19255 if (SWIG_arg_fail(1)) SWIG_fail;
19256 {
19257 PyThreadState* __tstate = wxPyBeginAllowThreads();
19258 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
19259
19260 wxPyEndAllowThreads(__tstate);
19261 if (PyErr_Occurred()) SWIG_fail;
19262 }
19263 {
19264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19265 }
19266 return resultobj;
19267 fail:
19268 return NULL;
19269 }
19270
19271
19272 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19273 PyObject *resultobj = NULL;
19274 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19275 wxString *arg2 = 0 ;
19276 wxString result;
19277 bool temp2 = false ;
19278 PyObject * obj0 = 0 ;
19279 PyObject * obj1 = 0 ;
19280 char *kwnames[] = {
19281 (char *) "self",(char *) "str", NULL
19282 };
19283
19284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
19285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19286 if (SWIG_arg_fail(1)) SWIG_fail;
19287 {
19288 arg2 = wxString_in_helper(obj1);
19289 if (arg2 == NULL) SWIG_fail;
19290 temp2 = true;
19291 }
19292 {
19293 PyThreadState* __tstate = wxPyBeginAllowThreads();
19294 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
19295
19296 wxPyEndAllowThreads(__tstate);
19297 if (PyErr_Occurred()) SWIG_fail;
19298 }
19299 {
19300 #if wxUSE_UNICODE
19301 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19302 #else
19303 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19304 #endif
19305 }
19306 {
19307 if (temp2)
19308 delete arg2;
19309 }
19310 return resultobj;
19311 fail:
19312 {
19313 if (temp2)
19314 delete arg2;
19315 }
19316 return NULL;
19317 }
19318
19319
19320 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
19321 PyObject *resultobj = NULL;
19322 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19323 wxString result;
19324 PyObject * obj0 = 0 ;
19325 char *kwnames[] = {
19326 (char *) "self", NULL
19327 };
19328
19329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
19330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19331 if (SWIG_arg_fail(1)) SWIG_fail;
19332 {
19333 PyThreadState* __tstate = wxPyBeginAllowThreads();
19334 result = ((wxConfigBase const *)arg1)->GetAppName();
19335
19336 wxPyEndAllowThreads(__tstate);
19337 if (PyErr_Occurred()) SWIG_fail;
19338 }
19339 {
19340 #if wxUSE_UNICODE
19341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19342 #else
19343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19344 #endif
19345 }
19346 return resultobj;
19347 fail:
19348 return NULL;
19349 }
19350
19351
19352 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
19353 PyObject *resultobj = NULL;
19354 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19355 wxString result;
19356 PyObject * obj0 = 0 ;
19357 char *kwnames[] = {
19358 (char *) "self", NULL
19359 };
19360
19361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
19362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19363 if (SWIG_arg_fail(1)) SWIG_fail;
19364 {
19365 PyThreadState* __tstate = wxPyBeginAllowThreads();
19366 result = ((wxConfigBase const *)arg1)->GetVendorName();
19367
19368 wxPyEndAllowThreads(__tstate);
19369 if (PyErr_Occurred()) SWIG_fail;
19370 }
19371 {
19372 #if wxUSE_UNICODE
19373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19374 #else
19375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19376 #endif
19377 }
19378 return resultobj;
19379 fail:
19380 return NULL;
19381 }
19382
19383
19384 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
19385 PyObject *resultobj = NULL;
19386 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19387 wxString *arg2 = 0 ;
19388 bool temp2 = false ;
19389 PyObject * obj0 = 0 ;
19390 PyObject * obj1 = 0 ;
19391 char *kwnames[] = {
19392 (char *) "self",(char *) "appName", NULL
19393 };
19394
19395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
19396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19397 if (SWIG_arg_fail(1)) SWIG_fail;
19398 {
19399 arg2 = wxString_in_helper(obj1);
19400 if (arg2 == NULL) SWIG_fail;
19401 temp2 = true;
19402 }
19403 {
19404 PyThreadState* __tstate = wxPyBeginAllowThreads();
19405 (arg1)->SetAppName((wxString const &)*arg2);
19406
19407 wxPyEndAllowThreads(__tstate);
19408 if (PyErr_Occurred()) SWIG_fail;
19409 }
19410 Py_INCREF(Py_None); resultobj = Py_None;
19411 {
19412 if (temp2)
19413 delete arg2;
19414 }
19415 return resultobj;
19416 fail:
19417 {
19418 if (temp2)
19419 delete arg2;
19420 }
19421 return NULL;
19422 }
19423
19424
19425 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
19426 PyObject *resultobj = NULL;
19427 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19428 wxString *arg2 = 0 ;
19429 bool temp2 = false ;
19430 PyObject * obj0 = 0 ;
19431 PyObject * obj1 = 0 ;
19432 char *kwnames[] = {
19433 (char *) "self",(char *) "vendorName", NULL
19434 };
19435
19436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
19437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19438 if (SWIG_arg_fail(1)) SWIG_fail;
19439 {
19440 arg2 = wxString_in_helper(obj1);
19441 if (arg2 == NULL) SWIG_fail;
19442 temp2 = true;
19443 }
19444 {
19445 PyThreadState* __tstate = wxPyBeginAllowThreads();
19446 (arg1)->SetVendorName((wxString const &)*arg2);
19447
19448 wxPyEndAllowThreads(__tstate);
19449 if (PyErr_Occurred()) SWIG_fail;
19450 }
19451 Py_INCREF(Py_None); resultobj = Py_None;
19452 {
19453 if (temp2)
19454 delete arg2;
19455 }
19456 return resultobj;
19457 fail:
19458 {
19459 if (temp2)
19460 delete arg2;
19461 }
19462 return NULL;
19463 }
19464
19465
19466 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
19467 PyObject *resultobj = NULL;
19468 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19469 long arg2 ;
19470 PyObject * obj0 = 0 ;
19471 PyObject * obj1 = 0 ;
19472 char *kwnames[] = {
19473 (char *) "self",(char *) "style", NULL
19474 };
19475
19476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
19477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19478 if (SWIG_arg_fail(1)) SWIG_fail;
19479 {
19480 arg2 = static_cast<long >(SWIG_As_long(obj1));
19481 if (SWIG_arg_fail(2)) SWIG_fail;
19482 }
19483 {
19484 PyThreadState* __tstate = wxPyBeginAllowThreads();
19485 (arg1)->SetStyle(arg2);
19486
19487 wxPyEndAllowThreads(__tstate);
19488 if (PyErr_Occurred()) SWIG_fail;
19489 }
19490 Py_INCREF(Py_None); resultobj = Py_None;
19491 return resultobj;
19492 fail:
19493 return NULL;
19494 }
19495
19496
19497 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
19498 PyObject *resultobj = NULL;
19499 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19500 long result;
19501 PyObject * obj0 = 0 ;
19502 char *kwnames[] = {
19503 (char *) "self", NULL
19504 };
19505
19506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
19507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19508 if (SWIG_arg_fail(1)) SWIG_fail;
19509 {
19510 PyThreadState* __tstate = wxPyBeginAllowThreads();
19511 result = (long)((wxConfigBase const *)arg1)->GetStyle();
19512
19513 wxPyEndAllowThreads(__tstate);
19514 if (PyErr_Occurred()) SWIG_fail;
19515 }
19516 {
19517 resultobj = SWIG_From_long(static_cast<long >(result));
19518 }
19519 return resultobj;
19520 fail:
19521 return NULL;
19522 }
19523
19524
19525 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
19526 PyObject *obj;
19527 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19528 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
19529 Py_INCREF(obj);
19530 return Py_BuildValue((char *)"");
19531 }
19532 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
19533 PyObject *resultobj = NULL;
19534 wxString const &arg1_defvalue = wxPyEmptyString ;
19535 wxString *arg1 = (wxString *) &arg1_defvalue ;
19536 wxString const &arg2_defvalue = wxPyEmptyString ;
19537 wxString *arg2 = (wxString *) &arg2_defvalue ;
19538 wxString const &arg3_defvalue = wxPyEmptyString ;
19539 wxString *arg3 = (wxString *) &arg3_defvalue ;
19540 wxString const &arg4_defvalue = wxPyEmptyString ;
19541 wxString *arg4 = (wxString *) &arg4_defvalue ;
19542 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
19543 wxConfig *result;
19544 bool temp1 = false ;
19545 bool temp2 = false ;
19546 bool temp3 = false ;
19547 bool temp4 = false ;
19548 PyObject * obj0 = 0 ;
19549 PyObject * obj1 = 0 ;
19550 PyObject * obj2 = 0 ;
19551 PyObject * obj3 = 0 ;
19552 PyObject * obj4 = 0 ;
19553 char *kwnames[] = {
19554 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
19555 };
19556
19557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19558 if (obj0) {
19559 {
19560 arg1 = wxString_in_helper(obj0);
19561 if (arg1 == NULL) SWIG_fail;
19562 temp1 = true;
19563 }
19564 }
19565 if (obj1) {
19566 {
19567 arg2 = wxString_in_helper(obj1);
19568 if (arg2 == NULL) SWIG_fail;
19569 temp2 = true;
19570 }
19571 }
19572 if (obj2) {
19573 {
19574 arg3 = wxString_in_helper(obj2);
19575 if (arg3 == NULL) SWIG_fail;
19576 temp3 = true;
19577 }
19578 }
19579 if (obj3) {
19580 {
19581 arg4 = wxString_in_helper(obj3);
19582 if (arg4 == NULL) SWIG_fail;
19583 temp4 = true;
19584 }
19585 }
19586 if (obj4) {
19587 {
19588 arg5 = static_cast<long >(SWIG_As_long(obj4));
19589 if (SWIG_arg_fail(5)) SWIG_fail;
19590 }
19591 }
19592 {
19593 PyThreadState* __tstate = wxPyBeginAllowThreads();
19594 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
19595
19596 wxPyEndAllowThreads(__tstate);
19597 if (PyErr_Occurred()) SWIG_fail;
19598 }
19599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
19600 {
19601 if (temp1)
19602 delete arg1;
19603 }
19604 {
19605 if (temp2)
19606 delete arg2;
19607 }
19608 {
19609 if (temp3)
19610 delete arg3;
19611 }
19612 {
19613 if (temp4)
19614 delete arg4;
19615 }
19616 return resultobj;
19617 fail:
19618 {
19619 if (temp1)
19620 delete arg1;
19621 }
19622 {
19623 if (temp2)
19624 delete arg2;
19625 }
19626 {
19627 if (temp3)
19628 delete arg3;
19629 }
19630 {
19631 if (temp4)
19632 delete arg4;
19633 }
19634 return NULL;
19635 }
19636
19637
19638 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
19639 PyObject *resultobj = NULL;
19640 wxConfig *arg1 = (wxConfig *) 0 ;
19641 PyObject * obj0 = 0 ;
19642 char *kwnames[] = {
19643 (char *) "self", NULL
19644 };
19645
19646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
19647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
19648 if (SWIG_arg_fail(1)) SWIG_fail;
19649 {
19650 PyThreadState* __tstate = wxPyBeginAllowThreads();
19651 delete arg1;
19652
19653 wxPyEndAllowThreads(__tstate);
19654 if (PyErr_Occurred()) SWIG_fail;
19655 }
19656 Py_INCREF(Py_None); resultobj = Py_None;
19657 return resultobj;
19658 fail:
19659 return NULL;
19660 }
19661
19662
19663 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
19664 PyObject *obj;
19665 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19666 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
19667 Py_INCREF(obj);
19668 return Py_BuildValue((char *)"");
19669 }
19670 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
19671 PyObject *resultobj = NULL;
19672 wxString const &arg1_defvalue = wxPyEmptyString ;
19673 wxString *arg1 = (wxString *) &arg1_defvalue ;
19674 wxString const &arg2_defvalue = wxPyEmptyString ;
19675 wxString *arg2 = (wxString *) &arg2_defvalue ;
19676 wxString const &arg3_defvalue = wxPyEmptyString ;
19677 wxString *arg3 = (wxString *) &arg3_defvalue ;
19678 wxString const &arg4_defvalue = wxPyEmptyString ;
19679 wxString *arg4 = (wxString *) &arg4_defvalue ;
19680 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
19681 wxFileConfig *result;
19682 bool temp1 = false ;
19683 bool temp2 = false ;
19684 bool temp3 = false ;
19685 bool temp4 = false ;
19686 PyObject * obj0 = 0 ;
19687 PyObject * obj1 = 0 ;
19688 PyObject * obj2 = 0 ;
19689 PyObject * obj3 = 0 ;
19690 PyObject * obj4 = 0 ;
19691 char *kwnames[] = {
19692 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
19693 };
19694
19695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19696 if (obj0) {
19697 {
19698 arg1 = wxString_in_helper(obj0);
19699 if (arg1 == NULL) SWIG_fail;
19700 temp1 = true;
19701 }
19702 }
19703 if (obj1) {
19704 {
19705 arg2 = wxString_in_helper(obj1);
19706 if (arg2 == NULL) SWIG_fail;
19707 temp2 = true;
19708 }
19709 }
19710 if (obj2) {
19711 {
19712 arg3 = wxString_in_helper(obj2);
19713 if (arg3 == NULL) SWIG_fail;
19714 temp3 = true;
19715 }
19716 }
19717 if (obj3) {
19718 {
19719 arg4 = wxString_in_helper(obj3);
19720 if (arg4 == NULL) SWIG_fail;
19721 temp4 = true;
19722 }
19723 }
19724 if (obj4) {
19725 {
19726 arg5 = static_cast<long >(SWIG_As_long(obj4));
19727 if (SWIG_arg_fail(5)) SWIG_fail;
19728 }
19729 }
19730 {
19731 PyThreadState* __tstate = wxPyBeginAllowThreads();
19732 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
19733
19734 wxPyEndAllowThreads(__tstate);
19735 if (PyErr_Occurred()) SWIG_fail;
19736 }
19737 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
19738 {
19739 if (temp1)
19740 delete arg1;
19741 }
19742 {
19743 if (temp2)
19744 delete arg2;
19745 }
19746 {
19747 if (temp3)
19748 delete arg3;
19749 }
19750 {
19751 if (temp4)
19752 delete arg4;
19753 }
19754 return resultobj;
19755 fail:
19756 {
19757 if (temp1)
19758 delete arg1;
19759 }
19760 {
19761 if (temp2)
19762 delete arg2;
19763 }
19764 {
19765 if (temp3)
19766 delete arg3;
19767 }
19768 {
19769 if (temp4)
19770 delete arg4;
19771 }
19772 return NULL;
19773 }
19774
19775
19776 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
19777 PyObject *resultobj = NULL;
19778 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
19779 PyObject * obj0 = 0 ;
19780 char *kwnames[] = {
19781 (char *) "self", NULL
19782 };
19783
19784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
19785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
19786 if (SWIG_arg_fail(1)) SWIG_fail;
19787 {
19788 PyThreadState* __tstate = wxPyBeginAllowThreads();
19789 delete arg1;
19790
19791 wxPyEndAllowThreads(__tstate);
19792 if (PyErr_Occurred()) SWIG_fail;
19793 }
19794 Py_INCREF(Py_None); resultobj = Py_None;
19795 return resultobj;
19796 fail:
19797 return NULL;
19798 }
19799
19800
19801 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
19802 PyObject *obj;
19803 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19804 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
19805 Py_INCREF(obj);
19806 return Py_BuildValue((char *)"");
19807 }
19808 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
19809 PyObject *resultobj = NULL;
19810 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19811 wxString *arg2 = 0 ;
19812 wxConfigPathChanger *result;
19813 bool temp2 = false ;
19814 PyObject * obj0 = 0 ;
19815 PyObject * obj1 = 0 ;
19816 char *kwnames[] = {
19817 (char *) "config",(char *) "entry", NULL
19818 };
19819
19820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
19821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19822 if (SWIG_arg_fail(1)) SWIG_fail;
19823 {
19824 arg2 = wxString_in_helper(obj1);
19825 if (arg2 == NULL) SWIG_fail;
19826 temp2 = true;
19827 }
19828 {
19829 PyThreadState* __tstate = wxPyBeginAllowThreads();
19830 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
19831
19832 wxPyEndAllowThreads(__tstate);
19833 if (PyErr_Occurred()) SWIG_fail;
19834 }
19835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
19836 {
19837 if (temp2)
19838 delete arg2;
19839 }
19840 return resultobj;
19841 fail:
19842 {
19843 if (temp2)
19844 delete arg2;
19845 }
19846 return NULL;
19847 }
19848
19849
19850 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
19851 PyObject *resultobj = NULL;
19852 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
19853 PyObject * obj0 = 0 ;
19854 char *kwnames[] = {
19855 (char *) "self", NULL
19856 };
19857
19858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
19859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
19860 if (SWIG_arg_fail(1)) SWIG_fail;
19861 {
19862 PyThreadState* __tstate = wxPyBeginAllowThreads();
19863 delete arg1;
19864
19865 wxPyEndAllowThreads(__tstate);
19866 if (PyErr_Occurred()) SWIG_fail;
19867 }
19868 Py_INCREF(Py_None); resultobj = Py_None;
19869 return resultobj;
19870 fail:
19871 return NULL;
19872 }
19873
19874
19875 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
19876 PyObject *resultobj = NULL;
19877 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
19878 wxString *result;
19879 PyObject * obj0 = 0 ;
19880 char *kwnames[] = {
19881 (char *) "self", NULL
19882 };
19883
19884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
19885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
19886 if (SWIG_arg_fail(1)) SWIG_fail;
19887 {
19888 PyThreadState* __tstate = wxPyBeginAllowThreads();
19889 {
19890 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
19891 result = (wxString *) &_result_ref;
19892 }
19893
19894 wxPyEndAllowThreads(__tstate);
19895 if (PyErr_Occurred()) SWIG_fail;
19896 }
19897 {
19898 #if wxUSE_UNICODE
19899 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19900 #else
19901 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19902 #endif
19903 }
19904 return resultobj;
19905 fail:
19906 return NULL;
19907 }
19908
19909
19910 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
19911 PyObject *obj;
19912 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19913 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
19914 Py_INCREF(obj);
19915 return Py_BuildValue((char *)"");
19916 }
19917 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19918 PyObject *resultobj = NULL;
19919 wxString *arg1 = 0 ;
19920 wxString result;
19921 bool temp1 = false ;
19922 PyObject * obj0 = 0 ;
19923 char *kwnames[] = {
19924 (char *) "sz", NULL
19925 };
19926
19927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
19928 {
19929 arg1 = wxString_in_helper(obj0);
19930 if (arg1 == NULL) SWIG_fail;
19931 temp1 = true;
19932 }
19933 {
19934 PyThreadState* __tstate = wxPyBeginAllowThreads();
19935 result = wxExpandEnvVars((wxString const &)*arg1);
19936
19937 wxPyEndAllowThreads(__tstate);
19938 if (PyErr_Occurred()) SWIG_fail;
19939 }
19940 {
19941 #if wxUSE_UNICODE
19942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19943 #else
19944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19945 #endif
19946 }
19947 {
19948 if (temp1)
19949 delete arg1;
19950 }
19951 return resultobj;
19952 fail:
19953 {
19954 if (temp1)
19955 delete arg1;
19956 }
19957 return NULL;
19958 }
19959
19960
19961 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
19962 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
19963 return 1;
19964 }
19965
19966
19967 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19968 PyObject *pyobj = NULL;
19969
19970 {
19971 #if wxUSE_UNICODE
19972 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19973 #else
19974 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19975 #endif
19976 }
19977 return pyobj;
19978 }
19979
19980
19981 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19982 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19983 return 1;
19984 }
19985
19986
19987 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19988 PyObject *pyobj = NULL;
19989
19990 {
19991 #if wxUSE_UNICODE
19992 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19993 #else
19994 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19995 #endif
19996 }
19997 return pyobj;
19998 }
19999
20000
20001 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
20002 PyObject *resultobj = NULL;
20003 wxDateTime::Country arg1 ;
20004 PyObject * obj0 = 0 ;
20005 char *kwnames[] = {
20006 (char *) "country", NULL
20007 };
20008
20009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
20010 {
20011 arg1 = static_cast<wxDateTime::Country >(SWIG_As_int(obj0));
20012 if (SWIG_arg_fail(1)) SWIG_fail;
20013 }
20014 {
20015 PyThreadState* __tstate = wxPyBeginAllowThreads();
20016 wxDateTime::SetCountry(arg1);
20017
20018 wxPyEndAllowThreads(__tstate);
20019 if (PyErr_Occurred()) SWIG_fail;
20020 }
20021 Py_INCREF(Py_None); resultobj = Py_None;
20022 return resultobj;
20023 fail:
20024 return NULL;
20025 }
20026
20027
20028 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
20029 PyObject *resultobj = NULL;
20030 wxDateTime::Country result;
20031 char *kwnames[] = {
20032 NULL
20033 };
20034
20035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
20036 {
20037 PyThreadState* __tstate = wxPyBeginAllowThreads();
20038 result = (wxDateTime::Country)wxDateTime::GetCountry();
20039
20040 wxPyEndAllowThreads(__tstate);
20041 if (PyErr_Occurred()) SWIG_fail;
20042 }
20043 resultobj = SWIG_From_int((result));
20044 return resultobj;
20045 fail:
20046 return NULL;
20047 }
20048
20049
20050 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
20051 PyObject *resultobj = NULL;
20052 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
20053 bool result;
20054 PyObject * obj0 = 0 ;
20055 char *kwnames[] = {
20056 (char *) "country", NULL
20057 };
20058
20059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
20060 if (obj0) {
20061 {
20062 arg1 = static_cast<wxDateTime::Country >(SWIG_As_int(obj0));
20063 if (SWIG_arg_fail(1)) SWIG_fail;
20064 }
20065 }
20066 {
20067 PyThreadState* __tstate = wxPyBeginAllowThreads();
20068 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
20069
20070 wxPyEndAllowThreads(__tstate);
20071 if (PyErr_Occurred()) SWIG_fail;
20072 }
20073 {
20074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20075 }
20076 return resultobj;
20077 fail:
20078 return NULL;
20079 }
20080
20081
20082 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
20083 PyObject *resultobj = NULL;
20084 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20085 int result;
20086 PyObject * obj0 = 0 ;
20087 char *kwnames[] = {
20088 (char *) "cal", NULL
20089 };
20090
20091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
20092 if (obj0) {
20093 {
20094 arg1 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj0));
20095 if (SWIG_arg_fail(1)) SWIG_fail;
20096 }
20097 }
20098 {
20099 PyThreadState* __tstate = wxPyBeginAllowThreads();
20100 result = (int)wxDateTime::GetCurrentYear(arg1);
20101
20102 wxPyEndAllowThreads(__tstate);
20103 if (PyErr_Occurred()) SWIG_fail;
20104 }
20105 {
20106 resultobj = SWIG_From_int(static_cast<int >(result));
20107 }
20108 return resultobj;
20109 fail:
20110 return NULL;
20111 }
20112
20113
20114 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
20115 PyObject *resultobj = NULL;
20116 int arg1 ;
20117 int result;
20118 PyObject * obj0 = 0 ;
20119 char *kwnames[] = {
20120 (char *) "year", NULL
20121 };
20122
20123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
20124 {
20125 arg1 = static_cast<int >(SWIG_As_int(obj0));
20126 if (SWIG_arg_fail(1)) SWIG_fail;
20127 }
20128 {
20129 PyThreadState* __tstate = wxPyBeginAllowThreads();
20130 result = (int)wxDateTime::ConvertYearToBC(arg1);
20131
20132 wxPyEndAllowThreads(__tstate);
20133 if (PyErr_Occurred()) SWIG_fail;
20134 }
20135 {
20136 resultobj = SWIG_From_int(static_cast<int >(result));
20137 }
20138 return resultobj;
20139 fail:
20140 return NULL;
20141 }
20142
20143
20144 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20145 PyObject *resultobj = NULL;
20146 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20147 wxDateTime::Month result;
20148 PyObject * obj0 = 0 ;
20149 char *kwnames[] = {
20150 (char *) "cal", NULL
20151 };
20152
20153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
20154 if (obj0) {
20155 {
20156 arg1 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj0));
20157 if (SWIG_arg_fail(1)) SWIG_fail;
20158 }
20159 }
20160 {
20161 PyThreadState* __tstate = wxPyBeginAllowThreads();
20162 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
20163
20164 wxPyEndAllowThreads(__tstate);
20165 if (PyErr_Occurred()) SWIG_fail;
20166 }
20167 resultobj = SWIG_From_int((result));
20168 return resultobj;
20169 fail:
20170 return NULL;
20171 }
20172
20173
20174 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
20175 PyObject *resultobj = NULL;
20176 int arg1 = (int) wxDateTime::Inv_Year ;
20177 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20178 bool result;
20179 PyObject * obj0 = 0 ;
20180 PyObject * obj1 = 0 ;
20181 char *kwnames[] = {
20182 (char *) "year",(char *) "cal", NULL
20183 };
20184
20185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
20186 if (obj0) {
20187 {
20188 arg1 = static_cast<int >(SWIG_As_int(obj0));
20189 if (SWIG_arg_fail(1)) SWIG_fail;
20190 }
20191 }
20192 if (obj1) {
20193 {
20194 arg2 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj1));
20195 if (SWIG_arg_fail(2)) SWIG_fail;
20196 }
20197 }
20198 {
20199 PyThreadState* __tstate = wxPyBeginAllowThreads();
20200 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
20201
20202 wxPyEndAllowThreads(__tstate);
20203 if (PyErr_Occurred()) SWIG_fail;
20204 }
20205 {
20206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20207 }
20208 return resultobj;
20209 fail:
20210 return NULL;
20211 }
20212
20213
20214 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
20215 PyObject *resultobj = NULL;
20216 int arg1 = (int) wxDateTime::Inv_Year ;
20217 int result;
20218 PyObject * obj0 = 0 ;
20219 char *kwnames[] = {
20220 (char *) "year", NULL
20221 };
20222
20223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
20224 if (obj0) {
20225 {
20226 arg1 = static_cast<int >(SWIG_As_int(obj0));
20227 if (SWIG_arg_fail(1)) SWIG_fail;
20228 }
20229 }
20230 {
20231 PyThreadState* __tstate = wxPyBeginAllowThreads();
20232 result = (int)wxDateTime::GetCentury(arg1);
20233
20234 wxPyEndAllowThreads(__tstate);
20235 if (PyErr_Occurred()) SWIG_fail;
20236 }
20237 {
20238 resultobj = SWIG_From_int(static_cast<int >(result));
20239 }
20240 return resultobj;
20241 fail:
20242 return NULL;
20243 }
20244
20245
20246 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
20247 PyObject *resultobj = NULL;
20248 int arg1 ;
20249 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20250 int result;
20251 PyObject * obj0 = 0 ;
20252 PyObject * obj1 = 0 ;
20253 char *kwnames[] = {
20254 (char *) "year",(char *) "cal", NULL
20255 };
20256
20257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
20258 {
20259 arg1 = static_cast<int >(SWIG_As_int(obj0));
20260 if (SWIG_arg_fail(1)) SWIG_fail;
20261 }
20262 if (obj1) {
20263 {
20264 arg2 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj1));
20265 if (SWIG_arg_fail(2)) SWIG_fail;
20266 }
20267 }
20268 {
20269 PyThreadState* __tstate = wxPyBeginAllowThreads();
20270 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
20271
20272 wxPyEndAllowThreads(__tstate);
20273 if (PyErr_Occurred()) SWIG_fail;
20274 }
20275 {
20276 resultobj = SWIG_From_int(static_cast<int >(result));
20277 }
20278 return resultobj;
20279 fail:
20280 return NULL;
20281 }
20282
20283
20284 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20285 PyObject *resultobj = NULL;
20286 wxDateTime::Month arg1 ;
20287 int arg2 = (int) wxDateTime::Inv_Year ;
20288 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20289 int result;
20290 PyObject * obj0 = 0 ;
20291 PyObject * obj1 = 0 ;
20292 PyObject * obj2 = 0 ;
20293 char *kwnames[] = {
20294 (char *) "month",(char *) "year",(char *) "cal", NULL
20295 };
20296
20297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
20298 {
20299 arg1 = static_cast<wxDateTime::Month >(SWIG_As_int(obj0));
20300 if (SWIG_arg_fail(1)) SWIG_fail;
20301 }
20302 if (obj1) {
20303 {
20304 arg2 = static_cast<int >(SWIG_As_int(obj1));
20305 if (SWIG_arg_fail(2)) SWIG_fail;
20306 }
20307 }
20308 if (obj2) {
20309 {
20310 arg3 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj2));
20311 if (SWIG_arg_fail(3)) SWIG_fail;
20312 }
20313 }
20314 {
20315 PyThreadState* __tstate = wxPyBeginAllowThreads();
20316 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
20317
20318 wxPyEndAllowThreads(__tstate);
20319 if (PyErr_Occurred()) SWIG_fail;
20320 }
20321 {
20322 resultobj = SWIG_From_int(static_cast<int >(result));
20323 }
20324 return resultobj;
20325 fail:
20326 return NULL;
20327 }
20328
20329
20330 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
20331 PyObject *resultobj = NULL;
20332 wxDateTime::Month arg1 ;
20333 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
20334 wxString result;
20335 PyObject * obj0 = 0 ;
20336 PyObject * obj1 = 0 ;
20337 char *kwnames[] = {
20338 (char *) "month",(char *) "flags", NULL
20339 };
20340
20341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
20342 {
20343 arg1 = static_cast<wxDateTime::Month >(SWIG_As_int(obj0));
20344 if (SWIG_arg_fail(1)) SWIG_fail;
20345 }
20346 if (obj1) {
20347 {
20348 arg2 = static_cast<wxDateTime::NameFlags >(SWIG_As_int(obj1));
20349 if (SWIG_arg_fail(2)) SWIG_fail;
20350 }
20351 }
20352 {
20353 PyThreadState* __tstate = wxPyBeginAllowThreads();
20354 result = wxDateTime::GetMonthName(arg1,arg2);
20355
20356 wxPyEndAllowThreads(__tstate);
20357 if (PyErr_Occurred()) SWIG_fail;
20358 }
20359 {
20360 #if wxUSE_UNICODE
20361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20362 #else
20363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20364 #endif
20365 }
20366 return resultobj;
20367 fail:
20368 return NULL;
20369 }
20370
20371
20372 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
20373 PyObject *resultobj = NULL;
20374 wxDateTime::WeekDay arg1 ;
20375 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
20376 wxString result;
20377 PyObject * obj0 = 0 ;
20378 PyObject * obj1 = 0 ;
20379 char *kwnames[] = {
20380 (char *) "weekday",(char *) "flags", NULL
20381 };
20382
20383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
20384 {
20385 arg1 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj0));
20386 if (SWIG_arg_fail(1)) SWIG_fail;
20387 }
20388 if (obj1) {
20389 {
20390 arg2 = static_cast<wxDateTime::NameFlags >(SWIG_As_int(obj1));
20391 if (SWIG_arg_fail(2)) SWIG_fail;
20392 }
20393 }
20394 {
20395 PyThreadState* __tstate = wxPyBeginAllowThreads();
20396 result = wxDateTime::GetWeekDayName(arg1,arg2);
20397
20398 wxPyEndAllowThreads(__tstate);
20399 if (PyErr_Occurred()) SWIG_fail;
20400 }
20401 {
20402 #if wxUSE_UNICODE
20403 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20404 #else
20405 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20406 #endif
20407 }
20408 return resultobj;
20409 fail:
20410 return NULL;
20411 }
20412
20413
20414 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
20415 PyObject *resultobj = NULL;
20416 PyObject *result;
20417 char *kwnames[] = {
20418 NULL
20419 };
20420
20421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
20422 {
20423 PyThreadState* __tstate = wxPyBeginAllowThreads();
20424 result = (PyObject *)wxDateTime_GetAmPmStrings();
20425
20426 wxPyEndAllowThreads(__tstate);
20427 if (PyErr_Occurred()) SWIG_fail;
20428 }
20429 resultobj = result;
20430 return resultobj;
20431 fail:
20432 return NULL;
20433 }
20434
20435
20436 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
20437 PyObject *resultobj = NULL;
20438 int arg1 = (int) wxDateTime::Inv_Year ;
20439 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20440 bool result;
20441 PyObject * obj0 = 0 ;
20442 PyObject * obj1 = 0 ;
20443 char *kwnames[] = {
20444 (char *) "year",(char *) "country", NULL
20445 };
20446
20447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
20448 if (obj0) {
20449 {
20450 arg1 = static_cast<int >(SWIG_As_int(obj0));
20451 if (SWIG_arg_fail(1)) SWIG_fail;
20452 }
20453 }
20454 if (obj1) {
20455 {
20456 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
20457 if (SWIG_arg_fail(2)) SWIG_fail;
20458 }
20459 }
20460 {
20461 PyThreadState* __tstate = wxPyBeginAllowThreads();
20462 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
20463
20464 wxPyEndAllowThreads(__tstate);
20465 if (PyErr_Occurred()) SWIG_fail;
20466 }
20467 {
20468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20469 }
20470 return resultobj;
20471 fail:
20472 return NULL;
20473 }
20474
20475
20476 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
20477 PyObject *resultobj = NULL;
20478 int arg1 = (int) wxDateTime::Inv_Year ;
20479 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20480 wxDateTime result;
20481 PyObject * obj0 = 0 ;
20482 PyObject * obj1 = 0 ;
20483 char *kwnames[] = {
20484 (char *) "year",(char *) "country", NULL
20485 };
20486
20487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
20488 if (obj0) {
20489 {
20490 arg1 = static_cast<int >(SWIG_As_int(obj0));
20491 if (SWIG_arg_fail(1)) SWIG_fail;
20492 }
20493 }
20494 if (obj1) {
20495 {
20496 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
20497 if (SWIG_arg_fail(2)) SWIG_fail;
20498 }
20499 }
20500 {
20501 PyThreadState* __tstate = wxPyBeginAllowThreads();
20502 result = wxDateTime::GetBeginDST(arg1,arg2);
20503
20504 wxPyEndAllowThreads(__tstate);
20505 if (PyErr_Occurred()) SWIG_fail;
20506 }
20507 {
20508 wxDateTime * resultptr;
20509 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20510 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20511 }
20512 return resultobj;
20513 fail:
20514 return NULL;
20515 }
20516
20517
20518 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
20519 PyObject *resultobj = NULL;
20520 int arg1 = (int) wxDateTime::Inv_Year ;
20521 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20522 wxDateTime result;
20523 PyObject * obj0 = 0 ;
20524 PyObject * obj1 = 0 ;
20525 char *kwnames[] = {
20526 (char *) "year",(char *) "country", NULL
20527 };
20528
20529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
20530 if (obj0) {
20531 {
20532 arg1 = static_cast<int >(SWIG_As_int(obj0));
20533 if (SWIG_arg_fail(1)) SWIG_fail;
20534 }
20535 }
20536 if (obj1) {
20537 {
20538 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
20539 if (SWIG_arg_fail(2)) SWIG_fail;
20540 }
20541 }
20542 {
20543 PyThreadState* __tstate = wxPyBeginAllowThreads();
20544 result = wxDateTime::GetEndDST(arg1,arg2);
20545
20546 wxPyEndAllowThreads(__tstate);
20547 if (PyErr_Occurred()) SWIG_fail;
20548 }
20549 {
20550 wxDateTime * resultptr;
20551 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20552 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20553 }
20554 return resultobj;
20555 fail:
20556 return NULL;
20557 }
20558
20559
20560 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
20561 PyObject *resultobj = NULL;
20562 wxDateTime result;
20563 char *kwnames[] = {
20564 NULL
20565 };
20566
20567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
20568 {
20569 PyThreadState* __tstate = wxPyBeginAllowThreads();
20570 result = wxDateTime::Now();
20571
20572 wxPyEndAllowThreads(__tstate);
20573 if (PyErr_Occurred()) SWIG_fail;
20574 }
20575 {
20576 wxDateTime * resultptr;
20577 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20578 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20579 }
20580 return resultobj;
20581 fail:
20582 return NULL;
20583 }
20584
20585
20586 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
20587 PyObject *resultobj = NULL;
20588 wxDateTime result;
20589 char *kwnames[] = {
20590 NULL
20591 };
20592
20593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
20594 {
20595 PyThreadState* __tstate = wxPyBeginAllowThreads();
20596 result = wxDateTime::UNow();
20597
20598 wxPyEndAllowThreads(__tstate);
20599 if (PyErr_Occurred()) SWIG_fail;
20600 }
20601 {
20602 wxDateTime * resultptr;
20603 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20604 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20605 }
20606 return resultobj;
20607 fail:
20608 return NULL;
20609 }
20610
20611
20612 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
20613 PyObject *resultobj = NULL;
20614 wxDateTime result;
20615 char *kwnames[] = {
20616 NULL
20617 };
20618
20619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
20620 {
20621 PyThreadState* __tstate = wxPyBeginAllowThreads();
20622 result = wxDateTime::Today();
20623
20624 wxPyEndAllowThreads(__tstate);
20625 if (PyErr_Occurred()) SWIG_fail;
20626 }
20627 {
20628 wxDateTime * resultptr;
20629 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20630 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20631 }
20632 return resultobj;
20633 fail:
20634 return NULL;
20635 }
20636
20637
20638 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20639 PyObject *resultobj = NULL;
20640 wxDateTime *result;
20641 char *kwnames[] = {
20642 NULL
20643 };
20644
20645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
20646 {
20647 PyThreadState* __tstate = wxPyBeginAllowThreads();
20648 result = (wxDateTime *)new wxDateTime();
20649
20650 wxPyEndAllowThreads(__tstate);
20651 if (PyErr_Occurred()) SWIG_fail;
20652 }
20653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20654 return resultobj;
20655 fail:
20656 return NULL;
20657 }
20658
20659
20660 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
20661 PyObject *resultobj = NULL;
20662 time_t arg1 ;
20663 wxDateTime *result;
20664 PyObject * obj0 = 0 ;
20665 char *kwnames[] = {
20666 (char *) "timet", NULL
20667 };
20668
20669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
20670 {
20671 arg1 = static_cast<time_t >(SWIG_As_unsigned_SS_int(obj0));
20672 if (SWIG_arg_fail(1)) SWIG_fail;
20673 }
20674 {
20675 PyThreadState* __tstate = wxPyBeginAllowThreads();
20676 result = (wxDateTime *)new wxDateTime(arg1);
20677
20678 wxPyEndAllowThreads(__tstate);
20679 if (PyErr_Occurred()) SWIG_fail;
20680 }
20681 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20682 return resultobj;
20683 fail:
20684 return NULL;
20685 }
20686
20687
20688 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20689 PyObject *resultobj = NULL;
20690 double arg1 ;
20691 wxDateTime *result;
20692 PyObject * obj0 = 0 ;
20693 char *kwnames[] = {
20694 (char *) "jdn", NULL
20695 };
20696
20697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
20698 {
20699 arg1 = static_cast<double >(SWIG_As_double(obj0));
20700 if (SWIG_arg_fail(1)) SWIG_fail;
20701 }
20702 {
20703 PyThreadState* __tstate = wxPyBeginAllowThreads();
20704 result = (wxDateTime *)new wxDateTime(arg1);
20705
20706 wxPyEndAllowThreads(__tstate);
20707 if (PyErr_Occurred()) SWIG_fail;
20708 }
20709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20710 return resultobj;
20711 fail:
20712 return NULL;
20713 }
20714
20715
20716 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20717 PyObject *resultobj = NULL;
20718 int arg1 ;
20719 int arg2 = (int) 0 ;
20720 int arg3 = (int) 0 ;
20721 int arg4 = (int) 0 ;
20722 wxDateTime *result;
20723 PyObject * obj0 = 0 ;
20724 PyObject * obj1 = 0 ;
20725 PyObject * obj2 = 0 ;
20726 PyObject * obj3 = 0 ;
20727 char *kwnames[] = {
20728 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20729 };
20730
20731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20732 {
20733 arg1 = static_cast<int >(SWIG_As_int(obj0));
20734 if (SWIG_arg_fail(1)) SWIG_fail;
20735 }
20736 if (obj1) {
20737 {
20738 arg2 = static_cast<int >(SWIG_As_int(obj1));
20739 if (SWIG_arg_fail(2)) SWIG_fail;
20740 }
20741 }
20742 if (obj2) {
20743 {
20744 arg3 = static_cast<int >(SWIG_As_int(obj2));
20745 if (SWIG_arg_fail(3)) SWIG_fail;
20746 }
20747 }
20748 if (obj3) {
20749 {
20750 arg4 = static_cast<int >(SWIG_As_int(obj3));
20751 if (SWIG_arg_fail(4)) SWIG_fail;
20752 }
20753 }
20754 {
20755 PyThreadState* __tstate = wxPyBeginAllowThreads();
20756 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
20757
20758 wxPyEndAllowThreads(__tstate);
20759 if (PyErr_Occurred()) SWIG_fail;
20760 }
20761 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20762 return resultobj;
20763 fail:
20764 return NULL;
20765 }
20766
20767
20768 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
20769 PyObject *resultobj = NULL;
20770 int arg1 ;
20771 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20772 int arg3 = (int) wxDateTime::Inv_Year ;
20773 int arg4 = (int) 0 ;
20774 int arg5 = (int) 0 ;
20775 int arg6 = (int) 0 ;
20776 int arg7 = (int) 0 ;
20777 wxDateTime *result;
20778 PyObject * obj0 = 0 ;
20779 PyObject * obj1 = 0 ;
20780 PyObject * obj2 = 0 ;
20781 PyObject * obj3 = 0 ;
20782 PyObject * obj4 = 0 ;
20783 PyObject * obj5 = 0 ;
20784 PyObject * obj6 = 0 ;
20785 char *kwnames[] = {
20786 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20787 };
20788
20789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
20790 {
20791 arg1 = static_cast<int >(SWIG_As_int(obj0));
20792 if (SWIG_arg_fail(1)) SWIG_fail;
20793 }
20794 if (obj1) {
20795 {
20796 arg2 = static_cast<wxDateTime::Month >(SWIG_As_int(obj1));
20797 if (SWIG_arg_fail(2)) SWIG_fail;
20798 }
20799 }
20800 if (obj2) {
20801 {
20802 arg3 = static_cast<int >(SWIG_As_int(obj2));
20803 if (SWIG_arg_fail(3)) SWIG_fail;
20804 }
20805 }
20806 if (obj3) {
20807 {
20808 arg4 = static_cast<int >(SWIG_As_int(obj3));
20809 if (SWIG_arg_fail(4)) SWIG_fail;
20810 }
20811 }
20812 if (obj4) {
20813 {
20814 arg5 = static_cast<int >(SWIG_As_int(obj4));
20815 if (SWIG_arg_fail(5)) SWIG_fail;
20816 }
20817 }
20818 if (obj5) {
20819 {
20820 arg6 = static_cast<int >(SWIG_As_int(obj5));
20821 if (SWIG_arg_fail(6)) SWIG_fail;
20822 }
20823 }
20824 if (obj6) {
20825 {
20826 arg7 = static_cast<int >(SWIG_As_int(obj6));
20827 if (SWIG_arg_fail(7)) SWIG_fail;
20828 }
20829 }
20830 {
20831 PyThreadState* __tstate = wxPyBeginAllowThreads();
20832 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
20833
20834 wxPyEndAllowThreads(__tstate);
20835 if (PyErr_Occurred()) SWIG_fail;
20836 }
20837 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20838 return resultobj;
20839 fail:
20840 return NULL;
20841 }
20842
20843
20844 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20845 PyObject *resultobj = NULL;
20846 wxDateTime *arg1 = (wxDateTime *) 0 ;
20847 PyObject * obj0 = 0 ;
20848 char *kwnames[] = {
20849 (char *) "self", NULL
20850 };
20851
20852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
20853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20854 if (SWIG_arg_fail(1)) SWIG_fail;
20855 {
20856 PyThreadState* __tstate = wxPyBeginAllowThreads();
20857 delete arg1;
20858
20859 wxPyEndAllowThreads(__tstate);
20860 if (PyErr_Occurred()) SWIG_fail;
20861 }
20862 Py_INCREF(Py_None); resultobj = Py_None;
20863 return resultobj;
20864 fail:
20865 return NULL;
20866 }
20867
20868
20869 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
20870 PyObject *resultobj = NULL;
20871 wxDateTime *arg1 = (wxDateTime *) 0 ;
20872 wxDateTime *result;
20873 PyObject * obj0 = 0 ;
20874 char *kwnames[] = {
20875 (char *) "self", NULL
20876 };
20877
20878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
20879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20880 if (SWIG_arg_fail(1)) SWIG_fail;
20881 {
20882 PyThreadState* __tstate = wxPyBeginAllowThreads();
20883 {
20884 wxDateTime &_result_ref = (arg1)->SetToCurrent();
20885 result = (wxDateTime *) &_result_ref;
20886 }
20887
20888 wxPyEndAllowThreads(__tstate);
20889 if (PyErr_Occurred()) SWIG_fail;
20890 }
20891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20892 return resultobj;
20893 fail:
20894 return NULL;
20895 }
20896
20897
20898 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
20899 PyObject *resultobj = NULL;
20900 wxDateTime *arg1 = (wxDateTime *) 0 ;
20901 time_t arg2 ;
20902 wxDateTime *result;
20903 PyObject * obj0 = 0 ;
20904 PyObject * obj1 = 0 ;
20905 char *kwnames[] = {
20906 (char *) "self",(char *) "timet", NULL
20907 };
20908
20909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
20910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20911 if (SWIG_arg_fail(1)) SWIG_fail;
20912 {
20913 arg2 = static_cast<time_t >(SWIG_As_unsigned_SS_int(obj1));
20914 if (SWIG_arg_fail(2)) SWIG_fail;
20915 }
20916 {
20917 PyThreadState* __tstate = wxPyBeginAllowThreads();
20918 {
20919 wxDateTime &_result_ref = (arg1)->Set(arg2);
20920 result = (wxDateTime *) &_result_ref;
20921 }
20922
20923 wxPyEndAllowThreads(__tstate);
20924 if (PyErr_Occurred()) SWIG_fail;
20925 }
20926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20927 return resultobj;
20928 fail:
20929 return NULL;
20930 }
20931
20932
20933 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20934 PyObject *resultobj = NULL;
20935 wxDateTime *arg1 = (wxDateTime *) 0 ;
20936 double arg2 ;
20937 wxDateTime *result;
20938 PyObject * obj0 = 0 ;
20939 PyObject * obj1 = 0 ;
20940 char *kwnames[] = {
20941 (char *) "self",(char *) "jdn", NULL
20942 };
20943
20944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
20945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20946 if (SWIG_arg_fail(1)) SWIG_fail;
20947 {
20948 arg2 = static_cast<double >(SWIG_As_double(obj1));
20949 if (SWIG_arg_fail(2)) SWIG_fail;
20950 }
20951 {
20952 PyThreadState* __tstate = wxPyBeginAllowThreads();
20953 {
20954 wxDateTime &_result_ref = (arg1)->Set(arg2);
20955 result = (wxDateTime *) &_result_ref;
20956 }
20957
20958 wxPyEndAllowThreads(__tstate);
20959 if (PyErr_Occurred()) SWIG_fail;
20960 }
20961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20962 return resultobj;
20963 fail:
20964 return NULL;
20965 }
20966
20967
20968 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20969 PyObject *resultobj = NULL;
20970 wxDateTime *arg1 = (wxDateTime *) 0 ;
20971 int arg2 ;
20972 int arg3 = (int) 0 ;
20973 int arg4 = (int) 0 ;
20974 int arg5 = (int) 0 ;
20975 wxDateTime *result;
20976 PyObject * obj0 = 0 ;
20977 PyObject * obj1 = 0 ;
20978 PyObject * obj2 = 0 ;
20979 PyObject * obj3 = 0 ;
20980 PyObject * obj4 = 0 ;
20981 char *kwnames[] = {
20982 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20983 };
20984
20985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20987 if (SWIG_arg_fail(1)) SWIG_fail;
20988 {
20989 arg2 = static_cast<int >(SWIG_As_int(obj1));
20990 if (SWIG_arg_fail(2)) SWIG_fail;
20991 }
20992 if (obj2) {
20993 {
20994 arg3 = static_cast<int >(SWIG_As_int(obj2));
20995 if (SWIG_arg_fail(3)) SWIG_fail;
20996 }
20997 }
20998 if (obj3) {
20999 {
21000 arg4 = static_cast<int >(SWIG_As_int(obj3));
21001 if (SWIG_arg_fail(4)) SWIG_fail;
21002 }
21003 }
21004 if (obj4) {
21005 {
21006 arg5 = static_cast<int >(SWIG_As_int(obj4));
21007 if (SWIG_arg_fail(5)) SWIG_fail;
21008 }
21009 }
21010 {
21011 PyThreadState* __tstate = wxPyBeginAllowThreads();
21012 {
21013 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
21014 result = (wxDateTime *) &_result_ref;
21015 }
21016
21017 wxPyEndAllowThreads(__tstate);
21018 if (PyErr_Occurred()) SWIG_fail;
21019 }
21020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21021 return resultobj;
21022 fail:
21023 return NULL;
21024 }
21025
21026
21027 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
21028 PyObject *resultobj = NULL;
21029 wxDateTime *arg1 = (wxDateTime *) 0 ;
21030 int arg2 ;
21031 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21032 int arg4 = (int) wxDateTime::Inv_Year ;
21033 int arg5 = (int) 0 ;
21034 int arg6 = (int) 0 ;
21035 int arg7 = (int) 0 ;
21036 int arg8 = (int) 0 ;
21037 wxDateTime *result;
21038 PyObject * obj0 = 0 ;
21039 PyObject * obj1 = 0 ;
21040 PyObject * obj2 = 0 ;
21041 PyObject * obj3 = 0 ;
21042 PyObject * obj4 = 0 ;
21043 PyObject * obj5 = 0 ;
21044 PyObject * obj6 = 0 ;
21045 PyObject * obj7 = 0 ;
21046 char *kwnames[] = {
21047 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
21048 };
21049
21050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
21051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21052 if (SWIG_arg_fail(1)) SWIG_fail;
21053 {
21054 arg2 = static_cast<int >(SWIG_As_int(obj1));
21055 if (SWIG_arg_fail(2)) SWIG_fail;
21056 }
21057 if (obj2) {
21058 {
21059 arg3 = static_cast<wxDateTime::Month >(SWIG_As_int(obj2));
21060 if (SWIG_arg_fail(3)) SWIG_fail;
21061 }
21062 }
21063 if (obj3) {
21064 {
21065 arg4 = static_cast<int >(SWIG_As_int(obj3));
21066 if (SWIG_arg_fail(4)) SWIG_fail;
21067 }
21068 }
21069 if (obj4) {
21070 {
21071 arg5 = static_cast<int >(SWIG_As_int(obj4));
21072 if (SWIG_arg_fail(5)) SWIG_fail;
21073 }
21074 }
21075 if (obj5) {
21076 {
21077 arg6 = static_cast<int >(SWIG_As_int(obj5));
21078 if (SWIG_arg_fail(6)) SWIG_fail;
21079 }
21080 }
21081 if (obj6) {
21082 {
21083 arg7 = static_cast<int >(SWIG_As_int(obj6));
21084 if (SWIG_arg_fail(7)) SWIG_fail;
21085 }
21086 }
21087 if (obj7) {
21088 {
21089 arg8 = static_cast<int >(SWIG_As_int(obj7));
21090 if (SWIG_arg_fail(8)) SWIG_fail;
21091 }
21092 }
21093 {
21094 PyThreadState* __tstate = wxPyBeginAllowThreads();
21095 {
21096 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21097 result = (wxDateTime *) &_result_ref;
21098 }
21099
21100 wxPyEndAllowThreads(__tstate);
21101 if (PyErr_Occurred()) SWIG_fail;
21102 }
21103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21104 return resultobj;
21105 fail:
21106 return NULL;
21107 }
21108
21109
21110 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
21111 PyObject *resultobj = NULL;
21112 wxDateTime *arg1 = (wxDateTime *) 0 ;
21113 wxDateTime *result;
21114 PyObject * obj0 = 0 ;
21115 char *kwnames[] = {
21116 (char *) "self", NULL
21117 };
21118
21119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
21120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21121 if (SWIG_arg_fail(1)) SWIG_fail;
21122 {
21123 PyThreadState* __tstate = wxPyBeginAllowThreads();
21124 {
21125 wxDateTime &_result_ref = (arg1)->ResetTime();
21126 result = (wxDateTime *) &_result_ref;
21127 }
21128
21129 wxPyEndAllowThreads(__tstate);
21130 if (PyErr_Occurred()) SWIG_fail;
21131 }
21132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21133 return resultobj;
21134 fail:
21135 return NULL;
21136 }
21137
21138
21139 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21140 PyObject *resultobj = NULL;
21141 wxDateTime *arg1 = (wxDateTime *) 0 ;
21142 int arg2 ;
21143 wxDateTime *result;
21144 PyObject * obj0 = 0 ;
21145 PyObject * obj1 = 0 ;
21146 char *kwnames[] = {
21147 (char *) "self",(char *) "year", NULL
21148 };
21149
21150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
21151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21152 if (SWIG_arg_fail(1)) SWIG_fail;
21153 {
21154 arg2 = static_cast<int >(SWIG_As_int(obj1));
21155 if (SWIG_arg_fail(2)) SWIG_fail;
21156 }
21157 {
21158 PyThreadState* __tstate = wxPyBeginAllowThreads();
21159 {
21160 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
21161 result = (wxDateTime *) &_result_ref;
21162 }
21163
21164 wxPyEndAllowThreads(__tstate);
21165 if (PyErr_Occurred()) SWIG_fail;
21166 }
21167 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21168 return resultobj;
21169 fail:
21170 return NULL;
21171 }
21172
21173
21174 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21175 PyObject *resultobj = NULL;
21176 wxDateTime *arg1 = (wxDateTime *) 0 ;
21177 wxDateTime::Month arg2 ;
21178 wxDateTime *result;
21179 PyObject * obj0 = 0 ;
21180 PyObject * obj1 = 0 ;
21181 char *kwnames[] = {
21182 (char *) "self",(char *) "month", NULL
21183 };
21184
21185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
21186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21187 if (SWIG_arg_fail(1)) SWIG_fail;
21188 {
21189 arg2 = static_cast<wxDateTime::Month >(SWIG_As_int(obj1));
21190 if (SWIG_arg_fail(2)) SWIG_fail;
21191 }
21192 {
21193 PyThreadState* __tstate = wxPyBeginAllowThreads();
21194 {
21195 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
21196 result = (wxDateTime *) &_result_ref;
21197 }
21198
21199 wxPyEndAllowThreads(__tstate);
21200 if (PyErr_Occurred()) SWIG_fail;
21201 }
21202 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21203 return resultobj;
21204 fail:
21205 return NULL;
21206 }
21207
21208
21209 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21210 PyObject *resultobj = NULL;
21211 wxDateTime *arg1 = (wxDateTime *) 0 ;
21212 int arg2 ;
21213 wxDateTime *result;
21214 PyObject * obj0 = 0 ;
21215 PyObject * obj1 = 0 ;
21216 char *kwnames[] = {
21217 (char *) "self",(char *) "day", NULL
21218 };
21219
21220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
21221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21222 if (SWIG_arg_fail(1)) SWIG_fail;
21223 {
21224 arg2 = static_cast<int >(SWIG_As_int(obj1));
21225 if (SWIG_arg_fail(2)) SWIG_fail;
21226 }
21227 {
21228 PyThreadState* __tstate = wxPyBeginAllowThreads();
21229 {
21230 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
21231 result = (wxDateTime *) &_result_ref;
21232 }
21233
21234 wxPyEndAllowThreads(__tstate);
21235 if (PyErr_Occurred()) SWIG_fail;
21236 }
21237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21238 return resultobj;
21239 fail:
21240 return NULL;
21241 }
21242
21243
21244 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21245 PyObject *resultobj = NULL;
21246 wxDateTime *arg1 = (wxDateTime *) 0 ;
21247 int arg2 ;
21248 wxDateTime *result;
21249 PyObject * obj0 = 0 ;
21250 PyObject * obj1 = 0 ;
21251 char *kwnames[] = {
21252 (char *) "self",(char *) "hour", NULL
21253 };
21254
21255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
21256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21257 if (SWIG_arg_fail(1)) SWIG_fail;
21258 {
21259 arg2 = static_cast<int >(SWIG_As_int(obj1));
21260 if (SWIG_arg_fail(2)) SWIG_fail;
21261 }
21262 {
21263 PyThreadState* __tstate = wxPyBeginAllowThreads();
21264 {
21265 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
21266 result = (wxDateTime *) &_result_ref;
21267 }
21268
21269 wxPyEndAllowThreads(__tstate);
21270 if (PyErr_Occurred()) SWIG_fail;
21271 }
21272 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21273 return resultobj;
21274 fail:
21275 return NULL;
21276 }
21277
21278
21279 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21280 PyObject *resultobj = NULL;
21281 wxDateTime *arg1 = (wxDateTime *) 0 ;
21282 int arg2 ;
21283 wxDateTime *result;
21284 PyObject * obj0 = 0 ;
21285 PyObject * obj1 = 0 ;
21286 char *kwnames[] = {
21287 (char *) "self",(char *) "minute", NULL
21288 };
21289
21290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
21291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21292 if (SWIG_arg_fail(1)) SWIG_fail;
21293 {
21294 arg2 = static_cast<int >(SWIG_As_int(obj1));
21295 if (SWIG_arg_fail(2)) SWIG_fail;
21296 }
21297 {
21298 PyThreadState* __tstate = wxPyBeginAllowThreads();
21299 {
21300 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
21301 result = (wxDateTime *) &_result_ref;
21302 }
21303
21304 wxPyEndAllowThreads(__tstate);
21305 if (PyErr_Occurred()) SWIG_fail;
21306 }
21307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21308 return resultobj;
21309 fail:
21310 return NULL;
21311 }
21312
21313
21314 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21315 PyObject *resultobj = NULL;
21316 wxDateTime *arg1 = (wxDateTime *) 0 ;
21317 int arg2 ;
21318 wxDateTime *result;
21319 PyObject * obj0 = 0 ;
21320 PyObject * obj1 = 0 ;
21321 char *kwnames[] = {
21322 (char *) "self",(char *) "second", NULL
21323 };
21324
21325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
21326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21327 if (SWIG_arg_fail(1)) SWIG_fail;
21328 {
21329 arg2 = static_cast<int >(SWIG_As_int(obj1));
21330 if (SWIG_arg_fail(2)) SWIG_fail;
21331 }
21332 {
21333 PyThreadState* __tstate = wxPyBeginAllowThreads();
21334 {
21335 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
21336 result = (wxDateTime *) &_result_ref;
21337 }
21338
21339 wxPyEndAllowThreads(__tstate);
21340 if (PyErr_Occurred()) SWIG_fail;
21341 }
21342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21343 return resultobj;
21344 fail:
21345 return NULL;
21346 }
21347
21348
21349 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21350 PyObject *resultobj = NULL;
21351 wxDateTime *arg1 = (wxDateTime *) 0 ;
21352 int arg2 ;
21353 wxDateTime *result;
21354 PyObject * obj0 = 0 ;
21355 PyObject * obj1 = 0 ;
21356 char *kwnames[] = {
21357 (char *) "self",(char *) "millisecond", NULL
21358 };
21359
21360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21362 if (SWIG_arg_fail(1)) SWIG_fail;
21363 {
21364 arg2 = static_cast<int >(SWIG_As_int(obj1));
21365 if (SWIG_arg_fail(2)) SWIG_fail;
21366 }
21367 {
21368 PyThreadState* __tstate = wxPyBeginAllowThreads();
21369 {
21370 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
21371 result = (wxDateTime *) &_result_ref;
21372 }
21373
21374 wxPyEndAllowThreads(__tstate);
21375 if (PyErr_Occurred()) SWIG_fail;
21376 }
21377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21378 return resultobj;
21379 fail:
21380 return NULL;
21381 }
21382
21383
21384 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21385 PyObject *resultobj = NULL;
21386 wxDateTime *arg1 = (wxDateTime *) 0 ;
21387 wxDateTime::WeekDay arg2 ;
21388 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21389 wxDateTime *result;
21390 PyObject * obj0 = 0 ;
21391 PyObject * obj1 = 0 ;
21392 PyObject * obj2 = 0 ;
21393 char *kwnames[] = {
21394 (char *) "self",(char *) "weekday",(char *) "flags", NULL
21395 };
21396
21397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
21398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21399 if (SWIG_arg_fail(1)) SWIG_fail;
21400 {
21401 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21402 if (SWIG_arg_fail(2)) SWIG_fail;
21403 }
21404 if (obj2) {
21405 {
21406 arg3 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj2));
21407 if (SWIG_arg_fail(3)) SWIG_fail;
21408 }
21409 }
21410 {
21411 PyThreadState* __tstate = wxPyBeginAllowThreads();
21412 {
21413 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
21414 result = (wxDateTime *) &_result_ref;
21415 }
21416
21417 wxPyEndAllowThreads(__tstate);
21418 if (PyErr_Occurred()) SWIG_fail;
21419 }
21420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21421 return resultobj;
21422 fail:
21423 return NULL;
21424 }
21425
21426
21427 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21428 PyObject *resultobj = NULL;
21429 wxDateTime *arg1 = (wxDateTime *) 0 ;
21430 wxDateTime::WeekDay arg2 ;
21431 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21432 wxDateTime result;
21433 PyObject * obj0 = 0 ;
21434 PyObject * obj1 = 0 ;
21435 PyObject * obj2 = 0 ;
21436 char *kwnames[] = {
21437 (char *) "self",(char *) "weekday",(char *) "flags", NULL
21438 };
21439
21440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
21441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21442 if (SWIG_arg_fail(1)) SWIG_fail;
21443 {
21444 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21445 if (SWIG_arg_fail(2)) SWIG_fail;
21446 }
21447 if (obj2) {
21448 {
21449 arg3 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj2));
21450 if (SWIG_arg_fail(3)) SWIG_fail;
21451 }
21452 }
21453 {
21454 PyThreadState* __tstate = wxPyBeginAllowThreads();
21455 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
21456
21457 wxPyEndAllowThreads(__tstate);
21458 if (PyErr_Occurred()) SWIG_fail;
21459 }
21460 {
21461 wxDateTime * resultptr;
21462 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21463 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21464 }
21465 return resultobj;
21466 fail:
21467 return NULL;
21468 }
21469
21470
21471 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21472 PyObject *resultobj = NULL;
21473 wxDateTime *arg1 = (wxDateTime *) 0 ;
21474 wxDateTime::WeekDay arg2 ;
21475 wxDateTime *result;
21476 PyObject * obj0 = 0 ;
21477 PyObject * obj1 = 0 ;
21478 char *kwnames[] = {
21479 (char *) "self",(char *) "weekday", NULL
21480 };
21481
21482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
21483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21484 if (SWIG_arg_fail(1)) SWIG_fail;
21485 {
21486 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21487 if (SWIG_arg_fail(2)) SWIG_fail;
21488 }
21489 {
21490 PyThreadState* __tstate = wxPyBeginAllowThreads();
21491 {
21492 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
21493 result = (wxDateTime *) &_result_ref;
21494 }
21495
21496 wxPyEndAllowThreads(__tstate);
21497 if (PyErr_Occurred()) SWIG_fail;
21498 }
21499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21500 return resultobj;
21501 fail:
21502 return NULL;
21503 }
21504
21505
21506 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21507 PyObject *resultobj = NULL;
21508 wxDateTime *arg1 = (wxDateTime *) 0 ;
21509 wxDateTime::WeekDay arg2 ;
21510 wxDateTime result;
21511 PyObject * obj0 = 0 ;
21512 PyObject * obj1 = 0 ;
21513 char *kwnames[] = {
21514 (char *) "self",(char *) "weekday", NULL
21515 };
21516
21517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
21518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21519 if (SWIG_arg_fail(1)) SWIG_fail;
21520 {
21521 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21522 if (SWIG_arg_fail(2)) SWIG_fail;
21523 }
21524 {
21525 PyThreadState* __tstate = wxPyBeginAllowThreads();
21526 result = (arg1)->GetNextWeekDay(arg2);
21527
21528 wxPyEndAllowThreads(__tstate);
21529 if (PyErr_Occurred()) SWIG_fail;
21530 }
21531 {
21532 wxDateTime * resultptr;
21533 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21534 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21535 }
21536 return resultobj;
21537 fail:
21538 return NULL;
21539 }
21540
21541
21542 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21543 PyObject *resultobj = NULL;
21544 wxDateTime *arg1 = (wxDateTime *) 0 ;
21545 wxDateTime::WeekDay arg2 ;
21546 wxDateTime *result;
21547 PyObject * obj0 = 0 ;
21548 PyObject * obj1 = 0 ;
21549 char *kwnames[] = {
21550 (char *) "self",(char *) "weekday", NULL
21551 };
21552
21553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
21554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21555 if (SWIG_arg_fail(1)) SWIG_fail;
21556 {
21557 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21558 if (SWIG_arg_fail(2)) SWIG_fail;
21559 }
21560 {
21561 PyThreadState* __tstate = wxPyBeginAllowThreads();
21562 {
21563 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
21564 result = (wxDateTime *) &_result_ref;
21565 }
21566
21567 wxPyEndAllowThreads(__tstate);
21568 if (PyErr_Occurred()) SWIG_fail;
21569 }
21570 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21571 return resultobj;
21572 fail:
21573 return NULL;
21574 }
21575
21576
21577 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21578 PyObject *resultobj = NULL;
21579 wxDateTime *arg1 = (wxDateTime *) 0 ;
21580 wxDateTime::WeekDay arg2 ;
21581 wxDateTime result;
21582 PyObject * obj0 = 0 ;
21583 PyObject * obj1 = 0 ;
21584 char *kwnames[] = {
21585 (char *) "self",(char *) "weekday", NULL
21586 };
21587
21588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
21589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21590 if (SWIG_arg_fail(1)) SWIG_fail;
21591 {
21592 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21593 if (SWIG_arg_fail(2)) SWIG_fail;
21594 }
21595 {
21596 PyThreadState* __tstate = wxPyBeginAllowThreads();
21597 result = (arg1)->GetPrevWeekDay(arg2);
21598
21599 wxPyEndAllowThreads(__tstate);
21600 if (PyErr_Occurred()) SWIG_fail;
21601 }
21602 {
21603 wxDateTime * resultptr;
21604 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21605 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21606 }
21607 return resultobj;
21608 fail:
21609 return NULL;
21610 }
21611
21612
21613 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21614 PyObject *resultobj = NULL;
21615 wxDateTime *arg1 = (wxDateTime *) 0 ;
21616 wxDateTime::WeekDay arg2 ;
21617 int arg3 = (int) 1 ;
21618 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21619 int arg5 = (int) wxDateTime::Inv_Year ;
21620 bool result;
21621 PyObject * obj0 = 0 ;
21622 PyObject * obj1 = 0 ;
21623 PyObject * obj2 = 0 ;
21624 PyObject * obj3 = 0 ;
21625 PyObject * obj4 = 0 ;
21626 char *kwnames[] = {
21627 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
21628 };
21629
21630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21632 if (SWIG_arg_fail(1)) SWIG_fail;
21633 {
21634 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21635 if (SWIG_arg_fail(2)) SWIG_fail;
21636 }
21637 if (obj2) {
21638 {
21639 arg3 = static_cast<int >(SWIG_As_int(obj2));
21640 if (SWIG_arg_fail(3)) SWIG_fail;
21641 }
21642 }
21643 if (obj3) {
21644 {
21645 arg4 = static_cast<wxDateTime::Month >(SWIG_As_int(obj3));
21646 if (SWIG_arg_fail(4)) SWIG_fail;
21647 }
21648 }
21649 if (obj4) {
21650 {
21651 arg5 = static_cast<int >(SWIG_As_int(obj4));
21652 if (SWIG_arg_fail(5)) SWIG_fail;
21653 }
21654 }
21655 {
21656 PyThreadState* __tstate = wxPyBeginAllowThreads();
21657 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
21658
21659 wxPyEndAllowThreads(__tstate);
21660 if (PyErr_Occurred()) SWIG_fail;
21661 }
21662 {
21663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21664 }
21665 return resultobj;
21666 fail:
21667 return NULL;
21668 }
21669
21670
21671 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21672 PyObject *resultobj = NULL;
21673 wxDateTime *arg1 = (wxDateTime *) 0 ;
21674 wxDateTime::WeekDay arg2 ;
21675 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21676 int arg4 = (int) wxDateTime::Inv_Year ;
21677 bool result;
21678 PyObject * obj0 = 0 ;
21679 PyObject * obj1 = 0 ;
21680 PyObject * obj2 = 0 ;
21681 PyObject * obj3 = 0 ;
21682 char *kwnames[] = {
21683 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
21684 };
21685
21686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21688 if (SWIG_arg_fail(1)) SWIG_fail;
21689 {
21690 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21691 if (SWIG_arg_fail(2)) SWIG_fail;
21692 }
21693 if (obj2) {
21694 {
21695 arg3 = static_cast<wxDateTime::Month >(SWIG_As_int(obj2));
21696 if (SWIG_arg_fail(3)) SWIG_fail;
21697 }
21698 }
21699 if (obj3) {
21700 {
21701 arg4 = static_cast<int >(SWIG_As_int(obj3));
21702 if (SWIG_arg_fail(4)) SWIG_fail;
21703 }
21704 }
21705 {
21706 PyThreadState* __tstate = wxPyBeginAllowThreads();
21707 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
21708
21709 wxPyEndAllowThreads(__tstate);
21710 if (PyErr_Occurred()) SWIG_fail;
21711 }
21712 {
21713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21714 }
21715 return resultobj;
21716 fail:
21717 return NULL;
21718 }
21719
21720
21721 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21722 PyObject *resultobj = NULL;
21723 wxDateTime *arg1 = (wxDateTime *) 0 ;
21724 wxDateTime::WeekDay arg2 ;
21725 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21726 int arg4 = (int) wxDateTime::Inv_Year ;
21727 wxDateTime result;
21728 PyObject * obj0 = 0 ;
21729 PyObject * obj1 = 0 ;
21730 PyObject * obj2 = 0 ;
21731 PyObject * obj3 = 0 ;
21732 char *kwnames[] = {
21733 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
21734 };
21735
21736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21738 if (SWIG_arg_fail(1)) SWIG_fail;
21739 {
21740 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21741 if (SWIG_arg_fail(2)) SWIG_fail;
21742 }
21743 if (obj2) {
21744 {
21745 arg3 = static_cast<wxDateTime::Month >(SWIG_As_int(obj2));
21746 if (SWIG_arg_fail(3)) SWIG_fail;
21747 }
21748 }
21749 if (obj3) {
21750 {
21751 arg4 = static_cast<int >(SWIG_As_int(obj3));
21752 if (SWIG_arg_fail(4)) SWIG_fail;
21753 }
21754 }
21755 {
21756 PyThreadState* __tstate = wxPyBeginAllowThreads();
21757 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
21758
21759 wxPyEndAllowThreads(__tstate);
21760 if (PyErr_Occurred()) SWIG_fail;
21761 }
21762 {
21763 wxDateTime * resultptr;
21764 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21765 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21766 }
21767 return resultobj;
21768 fail:
21769 return NULL;
21770 }
21771
21772
21773 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21774 PyObject *resultobj = NULL;
21775 wxDateTime *arg1 = (wxDateTime *) 0 ;
21776 int arg2 ;
21777 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21778 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21779 bool result;
21780 PyObject * obj0 = 0 ;
21781 PyObject * obj1 = 0 ;
21782 PyObject * obj2 = 0 ;
21783 PyObject * obj3 = 0 ;
21784 char *kwnames[] = {
21785 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
21786 };
21787
21788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21790 if (SWIG_arg_fail(1)) SWIG_fail;
21791 {
21792 arg2 = static_cast<int >(SWIG_As_int(obj1));
21793 if (SWIG_arg_fail(2)) SWIG_fail;
21794 }
21795 if (obj2) {
21796 {
21797 arg3 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj2));
21798 if (SWIG_arg_fail(3)) SWIG_fail;
21799 }
21800 }
21801 if (obj3) {
21802 {
21803 arg4 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj3));
21804 if (SWIG_arg_fail(4)) SWIG_fail;
21805 }
21806 }
21807 {
21808 PyThreadState* __tstate = wxPyBeginAllowThreads();
21809 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
21810
21811 wxPyEndAllowThreads(__tstate);
21812 if (PyErr_Occurred()) SWIG_fail;
21813 }
21814 {
21815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21816 }
21817 return resultobj;
21818 fail:
21819 return NULL;
21820 }
21821
21822
21823 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21824 PyObject *resultobj = NULL;
21825 wxDateTime *arg1 = (wxDateTime *) 0 ;
21826 int arg2 ;
21827 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21828 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21829 wxDateTime result;
21830 PyObject * obj0 = 0 ;
21831 PyObject * obj1 = 0 ;
21832 PyObject * obj2 = 0 ;
21833 PyObject * obj3 = 0 ;
21834 char *kwnames[] = {
21835 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
21836 };
21837
21838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21840 if (SWIG_arg_fail(1)) SWIG_fail;
21841 {
21842 arg2 = static_cast<int >(SWIG_As_int(obj1));
21843 if (SWIG_arg_fail(2)) SWIG_fail;
21844 }
21845 if (obj2) {
21846 {
21847 arg3 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj2));
21848 if (SWIG_arg_fail(3)) SWIG_fail;
21849 }
21850 }
21851 if (obj3) {
21852 {
21853 arg4 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj3));
21854 if (SWIG_arg_fail(4)) SWIG_fail;
21855 }
21856 }
21857 {
21858 PyThreadState* __tstate = wxPyBeginAllowThreads();
21859 result = (arg1)->GetWeek(arg2,arg3,arg4);
21860
21861 wxPyEndAllowThreads(__tstate);
21862 if (PyErr_Occurred()) SWIG_fail;
21863 }
21864 {
21865 wxDateTime * resultptr;
21866 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21867 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21868 }
21869 return resultobj;
21870 fail:
21871 return NULL;
21872 }
21873
21874
21875 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21876 PyObject *resultobj = NULL;
21877 int arg1 ;
21878 int arg2 ;
21879 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21880 wxDateTime result;
21881 PyObject * obj0 = 0 ;
21882 PyObject * obj1 = 0 ;
21883 PyObject * obj2 = 0 ;
21884 char *kwnames[] = {
21885 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
21886 };
21887
21888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21889 {
21890 arg1 = static_cast<int >(SWIG_As_int(obj0));
21891 if (SWIG_arg_fail(1)) SWIG_fail;
21892 }
21893 {
21894 arg2 = static_cast<int >(SWIG_As_int(obj1));
21895 if (SWIG_arg_fail(2)) SWIG_fail;
21896 }
21897 if (obj2) {
21898 {
21899 arg3 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj2));
21900 if (SWIG_arg_fail(3)) SWIG_fail;
21901 }
21902 }
21903 {
21904 PyThreadState* __tstate = wxPyBeginAllowThreads();
21905 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
21906
21907 wxPyEndAllowThreads(__tstate);
21908 if (PyErr_Occurred()) SWIG_fail;
21909 }
21910 {
21911 wxDateTime * resultptr;
21912 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21913 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21914 }
21915 return resultobj;
21916 fail:
21917 return NULL;
21918 }
21919
21920
21921 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21922 PyObject *resultobj = NULL;
21923 wxDateTime *arg1 = (wxDateTime *) 0 ;
21924 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21925 int arg3 = (int) wxDateTime::Inv_Year ;
21926 wxDateTime *result;
21927 PyObject * obj0 = 0 ;
21928 PyObject * obj1 = 0 ;
21929 PyObject * obj2 = 0 ;
21930 char *kwnames[] = {
21931 (char *) "self",(char *) "month",(char *) "year", NULL
21932 };
21933
21934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21936 if (SWIG_arg_fail(1)) SWIG_fail;
21937 if (obj1) {
21938 {
21939 arg2 = static_cast<wxDateTime::Month >(SWIG_As_int(obj1));
21940 if (SWIG_arg_fail(2)) SWIG_fail;
21941 }
21942 }
21943 if (obj2) {
21944 {
21945 arg3 = static_cast<int >(SWIG_As_int(obj2));
21946 if (SWIG_arg_fail(3)) SWIG_fail;
21947 }
21948 }
21949 {
21950 PyThreadState* __tstate = wxPyBeginAllowThreads();
21951 {
21952 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
21953 result = (wxDateTime *) &_result_ref;
21954 }
21955
21956 wxPyEndAllowThreads(__tstate);
21957 if (PyErr_Occurred()) SWIG_fail;
21958 }
21959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21960 return resultobj;
21961 fail:
21962 return NULL;
21963 }
21964
21965
21966 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21967 PyObject *resultobj = NULL;
21968 wxDateTime *arg1 = (wxDateTime *) 0 ;
21969 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21970 int arg3 = (int) wxDateTime::Inv_Year ;
21971 wxDateTime result;
21972 PyObject * obj0 = 0 ;
21973 PyObject * obj1 = 0 ;
21974 PyObject * obj2 = 0 ;
21975 char *kwnames[] = {
21976 (char *) "self",(char *) "month",(char *) "year", NULL
21977 };
21978
21979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21981 if (SWIG_arg_fail(1)) SWIG_fail;
21982 if (obj1) {
21983 {
21984 arg2 = static_cast<wxDateTime::Month >(SWIG_As_int(obj1));
21985 if (SWIG_arg_fail(2)) SWIG_fail;
21986 }
21987 }
21988 if (obj2) {
21989 {
21990 arg3 = static_cast<int >(SWIG_As_int(obj2));
21991 if (SWIG_arg_fail(3)) SWIG_fail;
21992 }
21993 }
21994 {
21995 PyThreadState* __tstate = wxPyBeginAllowThreads();
21996 result = (arg1)->GetLastMonthDay(arg2,arg3);
21997
21998 wxPyEndAllowThreads(__tstate);
21999 if (PyErr_Occurred()) SWIG_fail;
22000 }
22001 {
22002 wxDateTime * resultptr;
22003 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22004 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22005 }
22006 return resultobj;
22007 fail:
22008 return NULL;
22009 }
22010
22011
22012 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
22013 PyObject *resultobj = NULL;
22014 wxDateTime *arg1 = (wxDateTime *) 0 ;
22015 int arg2 ;
22016 wxDateTime *result;
22017 PyObject * obj0 = 0 ;
22018 PyObject * obj1 = 0 ;
22019 char *kwnames[] = {
22020 (char *) "self",(char *) "yday", NULL
22021 };
22022
22023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
22024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22025 if (SWIG_arg_fail(1)) SWIG_fail;
22026 {
22027 arg2 = static_cast<int >(SWIG_As_int(obj1));
22028 if (SWIG_arg_fail(2)) SWIG_fail;
22029 }
22030 {
22031 PyThreadState* __tstate = wxPyBeginAllowThreads();
22032 {
22033 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
22034 result = (wxDateTime *) &_result_ref;
22035 }
22036
22037 wxPyEndAllowThreads(__tstate);
22038 if (PyErr_Occurred()) SWIG_fail;
22039 }
22040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22041 return resultobj;
22042 fail:
22043 return NULL;
22044 }
22045
22046
22047 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
22048 PyObject *resultobj = NULL;
22049 wxDateTime *arg1 = (wxDateTime *) 0 ;
22050 int arg2 ;
22051 wxDateTime result;
22052 PyObject * obj0 = 0 ;
22053 PyObject * obj1 = 0 ;
22054 char *kwnames[] = {
22055 (char *) "self",(char *) "yday", NULL
22056 };
22057
22058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
22059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22060 if (SWIG_arg_fail(1)) SWIG_fail;
22061 {
22062 arg2 = static_cast<int >(SWIG_As_int(obj1));
22063 if (SWIG_arg_fail(2)) SWIG_fail;
22064 }
22065 {
22066 PyThreadState* __tstate = wxPyBeginAllowThreads();
22067 result = (arg1)->GetYearDay(arg2);
22068
22069 wxPyEndAllowThreads(__tstate);
22070 if (PyErr_Occurred()) SWIG_fail;
22071 }
22072 {
22073 wxDateTime * resultptr;
22074 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22075 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22076 }
22077 return resultobj;
22078 fail:
22079 return NULL;
22080 }
22081
22082
22083 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
22084 PyObject *resultobj = NULL;
22085 wxDateTime *arg1 = (wxDateTime *) 0 ;
22086 double result;
22087 PyObject * obj0 = 0 ;
22088 char *kwnames[] = {
22089 (char *) "self", NULL
22090 };
22091
22092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
22093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22094 if (SWIG_arg_fail(1)) SWIG_fail;
22095 {
22096 PyThreadState* __tstate = wxPyBeginAllowThreads();
22097 result = (double)(arg1)->GetJulianDayNumber();
22098
22099 wxPyEndAllowThreads(__tstate);
22100 if (PyErr_Occurred()) SWIG_fail;
22101 }
22102 {
22103 resultobj = SWIG_From_double(static_cast<double >(result));
22104 }
22105 return resultobj;
22106 fail:
22107 return NULL;
22108 }
22109
22110
22111 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
22112 PyObject *resultobj = NULL;
22113 wxDateTime *arg1 = (wxDateTime *) 0 ;
22114 double result;
22115 PyObject * obj0 = 0 ;
22116 char *kwnames[] = {
22117 (char *) "self", NULL
22118 };
22119
22120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
22121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22122 if (SWIG_arg_fail(1)) SWIG_fail;
22123 {
22124 PyThreadState* __tstate = wxPyBeginAllowThreads();
22125 result = (double)(arg1)->GetJDN();
22126
22127 wxPyEndAllowThreads(__tstate);
22128 if (PyErr_Occurred()) SWIG_fail;
22129 }
22130 {
22131 resultobj = SWIG_From_double(static_cast<double >(result));
22132 }
22133 return resultobj;
22134 fail:
22135 return NULL;
22136 }
22137
22138
22139 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
22140 PyObject *resultobj = NULL;
22141 wxDateTime *arg1 = (wxDateTime *) 0 ;
22142 double result;
22143 PyObject * obj0 = 0 ;
22144 char *kwnames[] = {
22145 (char *) "self", NULL
22146 };
22147
22148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
22149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22150 if (SWIG_arg_fail(1)) SWIG_fail;
22151 {
22152 PyThreadState* __tstate = wxPyBeginAllowThreads();
22153 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
22154
22155 wxPyEndAllowThreads(__tstate);
22156 if (PyErr_Occurred()) SWIG_fail;
22157 }
22158 {
22159 resultobj = SWIG_From_double(static_cast<double >(result));
22160 }
22161 return resultobj;
22162 fail:
22163 return NULL;
22164 }
22165
22166
22167 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
22168 PyObject *resultobj = NULL;
22169 wxDateTime *arg1 = (wxDateTime *) 0 ;
22170 double result;
22171 PyObject * obj0 = 0 ;
22172 char *kwnames[] = {
22173 (char *) "self", NULL
22174 };
22175
22176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
22177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22178 if (SWIG_arg_fail(1)) SWIG_fail;
22179 {
22180 PyThreadState* __tstate = wxPyBeginAllowThreads();
22181 result = (double)(arg1)->GetMJD();
22182
22183 wxPyEndAllowThreads(__tstate);
22184 if (PyErr_Occurred()) SWIG_fail;
22185 }
22186 {
22187 resultobj = SWIG_From_double(static_cast<double >(result));
22188 }
22189 return resultobj;
22190 fail:
22191 return NULL;
22192 }
22193
22194
22195 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
22196 PyObject *resultobj = NULL;
22197 wxDateTime *arg1 = (wxDateTime *) 0 ;
22198 double result;
22199 PyObject * obj0 = 0 ;
22200 char *kwnames[] = {
22201 (char *) "self", NULL
22202 };
22203
22204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
22205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22206 if (SWIG_arg_fail(1)) SWIG_fail;
22207 {
22208 PyThreadState* __tstate = wxPyBeginAllowThreads();
22209 result = (double)(arg1)->GetRataDie();
22210
22211 wxPyEndAllowThreads(__tstate);
22212 if (PyErr_Occurred()) SWIG_fail;
22213 }
22214 {
22215 resultobj = SWIG_From_double(static_cast<double >(result));
22216 }
22217 return resultobj;
22218 fail:
22219 return NULL;
22220 }
22221
22222
22223 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
22224 PyObject *resultobj = NULL;
22225 wxDateTime *arg1 = (wxDateTime *) 0 ;
22226 wxDateTime::TimeZone *arg2 = 0 ;
22227 bool arg3 = (bool) false ;
22228 wxDateTime result;
22229 bool temp2 = false ;
22230 PyObject * obj0 = 0 ;
22231 PyObject * obj1 = 0 ;
22232 PyObject * obj2 = 0 ;
22233 char *kwnames[] = {
22234 (char *) "self",(char *) "tz",(char *) "noDST", NULL
22235 };
22236
22237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
22238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22239 if (SWIG_arg_fail(1)) SWIG_fail;
22240 {
22241 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22242 temp2 = true;
22243 }
22244 if (obj2) {
22245 {
22246 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
22247 if (SWIG_arg_fail(3)) SWIG_fail;
22248 }
22249 }
22250 {
22251 PyThreadState* __tstate = wxPyBeginAllowThreads();
22252 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
22253
22254 wxPyEndAllowThreads(__tstate);
22255 if (PyErr_Occurred()) SWIG_fail;
22256 }
22257 {
22258 wxDateTime * resultptr;
22259 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22260 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22261 }
22262 {
22263 if (temp2) delete arg2;
22264 }
22265 return resultobj;
22266 fail:
22267 {
22268 if (temp2) delete arg2;
22269 }
22270 return NULL;
22271 }
22272
22273
22274 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
22275 PyObject *resultobj = NULL;
22276 wxDateTime *arg1 = (wxDateTime *) 0 ;
22277 wxDateTime::TimeZone *arg2 = 0 ;
22278 bool arg3 = (bool) false ;
22279 wxDateTime *result;
22280 bool temp2 = false ;
22281 PyObject * obj0 = 0 ;
22282 PyObject * obj1 = 0 ;
22283 PyObject * obj2 = 0 ;
22284 char *kwnames[] = {
22285 (char *) "self",(char *) "tz",(char *) "noDST", NULL
22286 };
22287
22288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
22289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22290 if (SWIG_arg_fail(1)) SWIG_fail;
22291 {
22292 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22293 temp2 = true;
22294 }
22295 if (obj2) {
22296 {
22297 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
22298 if (SWIG_arg_fail(3)) SWIG_fail;
22299 }
22300 }
22301 {
22302 PyThreadState* __tstate = wxPyBeginAllowThreads();
22303 {
22304 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
22305 result = (wxDateTime *) &_result_ref;
22306 }
22307
22308 wxPyEndAllowThreads(__tstate);
22309 if (PyErr_Occurred()) SWIG_fail;
22310 }
22311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22312 {
22313 if (temp2) delete arg2;
22314 }
22315 return resultobj;
22316 fail:
22317 {
22318 if (temp2) delete arg2;
22319 }
22320 return NULL;
22321 }
22322
22323
22324 static PyObject *_wrap_DateTime_FromTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
22325 PyObject *resultobj = NULL;
22326 wxDateTime *arg1 = (wxDateTime *) 0 ;
22327 wxDateTime::TimeZone *arg2 = 0 ;
22328 bool arg3 = (bool) false ;
22329 wxDateTime result;
22330 bool temp2 = false ;
22331 PyObject * obj0 = 0 ;
22332 PyObject * obj1 = 0 ;
22333 PyObject * obj2 = 0 ;
22334 char *kwnames[] = {
22335 (char *) "self",(char *) "tz",(char *) "noDST", NULL
22336 };
22337
22338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
22339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22340 if (SWIG_arg_fail(1)) SWIG_fail;
22341 {
22342 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22343 temp2 = true;
22344 }
22345 if (obj2) {
22346 {
22347 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
22348 if (SWIG_arg_fail(3)) SWIG_fail;
22349 }
22350 }
22351 {
22352 PyThreadState* __tstate = wxPyBeginAllowThreads();
22353 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
22354
22355 wxPyEndAllowThreads(__tstate);
22356 if (PyErr_Occurred()) SWIG_fail;
22357 }
22358 {
22359 wxDateTime * resultptr;
22360 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22361 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22362 }
22363 {
22364 if (temp2) delete arg2;
22365 }
22366 return resultobj;
22367 fail:
22368 {
22369 if (temp2) delete arg2;
22370 }
22371 return NULL;
22372 }
22373
22374
22375 static PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
22376 PyObject *resultobj = NULL;
22377 wxDateTime *arg1 = (wxDateTime *) 0 ;
22378 wxDateTime::TimeZone *arg2 = 0 ;
22379 bool arg3 = (bool) false ;
22380 wxDateTime *result;
22381 bool temp2 = false ;
22382 PyObject * obj0 = 0 ;
22383 PyObject * obj1 = 0 ;
22384 PyObject * obj2 = 0 ;
22385 char *kwnames[] = {
22386 (char *) "self",(char *) "tz",(char *) "noDST", NULL
22387 };
22388
22389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
22390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22391 if (SWIG_arg_fail(1)) SWIG_fail;
22392 {
22393 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22394 temp2 = true;
22395 }
22396 if (obj2) {
22397 {
22398 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
22399 if (SWIG_arg_fail(3)) SWIG_fail;
22400 }
22401 }
22402 {
22403 PyThreadState* __tstate = wxPyBeginAllowThreads();
22404 {
22405 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
22406 result = (wxDateTime *) &_result_ref;
22407 }
22408
22409 wxPyEndAllowThreads(__tstate);
22410 if (PyErr_Occurred()) SWIG_fail;
22411 }
22412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22413 {
22414 if (temp2) delete arg2;
22415 }
22416 return resultobj;
22417 fail:
22418 {
22419 if (temp2) delete arg2;
22420 }
22421 return NULL;
22422 }
22423
22424
22425 static PyObject *_wrap_DateTime_ToUTC(PyObject *, PyObject *args, PyObject *kwargs) {
22426 PyObject *resultobj = NULL;
22427 wxDateTime *arg1 = (wxDateTime *) 0 ;
22428 bool arg2 = (bool) false ;
22429 wxDateTime result;
22430 PyObject * obj0 = 0 ;
22431 PyObject * obj1 = 0 ;
22432 char *kwnames[] = {
22433 (char *) "self",(char *) "noDST", NULL
22434 };
22435
22436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) goto fail;
22437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22438 if (SWIG_arg_fail(1)) SWIG_fail;
22439 if (obj1) {
22440 {
22441 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22442 if (SWIG_arg_fail(2)) SWIG_fail;
22443 }
22444 }
22445 {
22446 PyThreadState* __tstate = wxPyBeginAllowThreads();
22447 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
22448
22449 wxPyEndAllowThreads(__tstate);
22450 if (PyErr_Occurred()) SWIG_fail;
22451 }
22452 {
22453 wxDateTime * resultptr;
22454 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22455 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22456 }
22457 return resultobj;
22458 fail:
22459 return NULL;
22460 }
22461
22462
22463 static PyObject *_wrap_DateTime_MakeUTC(PyObject *, PyObject *args, PyObject *kwargs) {
22464 PyObject *resultobj = NULL;
22465 wxDateTime *arg1 = (wxDateTime *) 0 ;
22466 bool arg2 = (bool) false ;
22467 wxDateTime *result;
22468 PyObject * obj0 = 0 ;
22469 PyObject * obj1 = 0 ;
22470 char *kwnames[] = {
22471 (char *) "self",(char *) "noDST", NULL
22472 };
22473
22474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) goto fail;
22475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22476 if (SWIG_arg_fail(1)) SWIG_fail;
22477 if (obj1) {
22478 {
22479 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22480 if (SWIG_arg_fail(2)) SWIG_fail;
22481 }
22482 }
22483 {
22484 PyThreadState* __tstate = wxPyBeginAllowThreads();
22485 {
22486 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
22487 result = (wxDateTime *) &_result_ref;
22488 }
22489
22490 wxPyEndAllowThreads(__tstate);
22491 if (PyErr_Occurred()) SWIG_fail;
22492 }
22493 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22494 return resultobj;
22495 fail:
22496 return NULL;
22497 }
22498
22499
22500 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
22501 PyObject *resultobj = NULL;
22502 wxDateTime *arg1 = (wxDateTime *) 0 ;
22503 bool arg2 = (bool) false ;
22504 wxDateTime result;
22505 PyObject * obj0 = 0 ;
22506 PyObject * obj1 = 0 ;
22507 char *kwnames[] = {
22508 (char *) "self",(char *) "noDST", NULL
22509 };
22510
22511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
22512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22513 if (SWIG_arg_fail(1)) SWIG_fail;
22514 if (obj1) {
22515 {
22516 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22517 if (SWIG_arg_fail(2)) SWIG_fail;
22518 }
22519 }
22520 {
22521 PyThreadState* __tstate = wxPyBeginAllowThreads();
22522 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
22523
22524 wxPyEndAllowThreads(__tstate);
22525 if (PyErr_Occurred()) SWIG_fail;
22526 }
22527 {
22528 wxDateTime * resultptr;
22529 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22530 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22531 }
22532 return resultobj;
22533 fail:
22534 return NULL;
22535 }
22536
22537
22538 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
22539 PyObject *resultobj = NULL;
22540 wxDateTime *arg1 = (wxDateTime *) 0 ;
22541 bool arg2 = (bool) false ;
22542 wxDateTime *result;
22543 PyObject * obj0 = 0 ;
22544 PyObject * obj1 = 0 ;
22545 char *kwnames[] = {
22546 (char *) "self",(char *) "noDST", NULL
22547 };
22548
22549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
22550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22551 if (SWIG_arg_fail(1)) SWIG_fail;
22552 if (obj1) {
22553 {
22554 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22555 if (SWIG_arg_fail(2)) SWIG_fail;
22556 }
22557 }
22558 {
22559 PyThreadState* __tstate = wxPyBeginAllowThreads();
22560 {
22561 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
22562 result = (wxDateTime *) &_result_ref;
22563 }
22564
22565 wxPyEndAllowThreads(__tstate);
22566 if (PyErr_Occurred()) SWIG_fail;
22567 }
22568 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22569 return resultobj;
22570 fail:
22571 return NULL;
22572 }
22573
22574
22575 static PyObject *_wrap_DateTime_FromUTC(PyObject *, PyObject *args, PyObject *kwargs) {
22576 PyObject *resultobj = NULL;
22577 wxDateTime *arg1 = (wxDateTime *) 0 ;
22578 bool arg2 = (bool) false ;
22579 wxDateTime result;
22580 PyObject * obj0 = 0 ;
22581 PyObject * obj1 = 0 ;
22582 char *kwnames[] = {
22583 (char *) "self",(char *) "noDST", NULL
22584 };
22585
22586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) goto fail;
22587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22588 if (SWIG_arg_fail(1)) SWIG_fail;
22589 if (obj1) {
22590 {
22591 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22592 if (SWIG_arg_fail(2)) SWIG_fail;
22593 }
22594 }
22595 {
22596 PyThreadState* __tstate = wxPyBeginAllowThreads();
22597 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
22598
22599 wxPyEndAllowThreads(__tstate);
22600 if (PyErr_Occurred()) SWIG_fail;
22601 }
22602 {
22603 wxDateTime * resultptr;
22604 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22605 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22606 }
22607 return resultobj;
22608 fail:
22609 return NULL;
22610 }
22611
22612
22613 static PyObject *_wrap_DateTime_MakeFromUTC(PyObject *, PyObject *args, PyObject *kwargs) {
22614 PyObject *resultobj = NULL;
22615 wxDateTime *arg1 = (wxDateTime *) 0 ;
22616 bool arg2 = (bool) false ;
22617 wxDateTime *result;
22618 PyObject * obj0 = 0 ;
22619 PyObject * obj1 = 0 ;
22620 char *kwnames[] = {
22621 (char *) "self",(char *) "noDST", NULL
22622 };
22623
22624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) goto fail;
22625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22626 if (SWIG_arg_fail(1)) SWIG_fail;
22627 if (obj1) {
22628 {
22629 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22630 if (SWIG_arg_fail(2)) SWIG_fail;
22631 }
22632 }
22633 {
22634 PyThreadState* __tstate = wxPyBeginAllowThreads();
22635 {
22636 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
22637 result = (wxDateTime *) &_result_ref;
22638 }
22639
22640 wxPyEndAllowThreads(__tstate);
22641 if (PyErr_Occurred()) SWIG_fail;
22642 }
22643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22644 return resultobj;
22645 fail:
22646 return NULL;
22647 }
22648
22649
22650 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
22651 PyObject *resultobj = NULL;
22652 wxDateTime *arg1 = (wxDateTime *) 0 ;
22653 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22654 int result;
22655 PyObject * obj0 = 0 ;
22656 PyObject * obj1 = 0 ;
22657 char *kwnames[] = {
22658 (char *) "self",(char *) "country", NULL
22659 };
22660
22661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
22662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22663 if (SWIG_arg_fail(1)) SWIG_fail;
22664 if (obj1) {
22665 {
22666 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
22667 if (SWIG_arg_fail(2)) SWIG_fail;
22668 }
22669 }
22670 {
22671 PyThreadState* __tstate = wxPyBeginAllowThreads();
22672 result = (int)(arg1)->IsDST(arg2);
22673
22674 wxPyEndAllowThreads(__tstate);
22675 if (PyErr_Occurred()) SWIG_fail;
22676 }
22677 {
22678 resultobj = SWIG_From_int(static_cast<int >(result));
22679 }
22680 return resultobj;
22681 fail:
22682 return NULL;
22683 }
22684
22685
22686 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
22687 PyObject *resultobj = NULL;
22688 wxDateTime *arg1 = (wxDateTime *) 0 ;
22689 bool result;
22690 PyObject * obj0 = 0 ;
22691 char *kwnames[] = {
22692 (char *) "self", NULL
22693 };
22694
22695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
22696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22697 if (SWIG_arg_fail(1)) SWIG_fail;
22698 {
22699 PyThreadState* __tstate = wxPyBeginAllowThreads();
22700 result = (bool)((wxDateTime const *)arg1)->IsValid();
22701
22702 wxPyEndAllowThreads(__tstate);
22703 if (PyErr_Occurred()) SWIG_fail;
22704 }
22705 {
22706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22707 }
22708 return resultobj;
22709 fail:
22710 return NULL;
22711 }
22712
22713
22714 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
22715 PyObject *resultobj = NULL;
22716 wxDateTime *arg1 = (wxDateTime *) 0 ;
22717 time_t result;
22718 PyObject * obj0 = 0 ;
22719 char *kwnames[] = {
22720 (char *) "self", NULL
22721 };
22722
22723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
22724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22725 if (SWIG_arg_fail(1)) SWIG_fail;
22726 {
22727 PyThreadState* __tstate = wxPyBeginAllowThreads();
22728 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
22729
22730 wxPyEndAllowThreads(__tstate);
22731 if (PyErr_Occurred()) SWIG_fail;
22732 }
22733 {
22734 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
22735 }
22736 return resultobj;
22737 fail:
22738 return NULL;
22739 }
22740
22741
22742 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
22743 PyObject *resultobj = NULL;
22744 wxDateTime *arg1 = (wxDateTime *) 0 ;
22745 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22746 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22747 int result;
22748 bool temp2 = false ;
22749 PyObject * obj0 = 0 ;
22750 PyObject * obj1 = 0 ;
22751 char *kwnames[] = {
22752 (char *) "self",(char *) "tz", NULL
22753 };
22754
22755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
22756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22757 if (SWIG_arg_fail(1)) SWIG_fail;
22758 if (obj1) {
22759 {
22760 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22761 temp2 = true;
22762 }
22763 }
22764 {
22765 PyThreadState* __tstate = wxPyBeginAllowThreads();
22766 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
22767
22768 wxPyEndAllowThreads(__tstate);
22769 if (PyErr_Occurred()) SWIG_fail;
22770 }
22771 {
22772 resultobj = SWIG_From_int(static_cast<int >(result));
22773 }
22774 {
22775 if (temp2) delete arg2;
22776 }
22777 return resultobj;
22778 fail:
22779 {
22780 if (temp2) delete arg2;
22781 }
22782 return NULL;
22783 }
22784
22785
22786 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
22787 PyObject *resultobj = NULL;
22788 wxDateTime *arg1 = (wxDateTime *) 0 ;
22789 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22790 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22791 wxDateTime::Month result;
22792 bool temp2 = false ;
22793 PyObject * obj0 = 0 ;
22794 PyObject * obj1 = 0 ;
22795 char *kwnames[] = {
22796 (char *) "self",(char *) "tz", NULL
22797 };
22798
22799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
22800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22801 if (SWIG_arg_fail(1)) SWIG_fail;
22802 if (obj1) {
22803 {
22804 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22805 temp2 = true;
22806 }
22807 }
22808 {
22809 PyThreadState* __tstate = wxPyBeginAllowThreads();
22810 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
22811
22812 wxPyEndAllowThreads(__tstate);
22813 if (PyErr_Occurred()) SWIG_fail;
22814 }
22815 resultobj = SWIG_From_int((result));
22816 {
22817 if (temp2) delete arg2;
22818 }
22819 return resultobj;
22820 fail:
22821 {
22822 if (temp2) delete arg2;
22823 }
22824 return NULL;
22825 }
22826
22827
22828 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
22829 PyObject *resultobj = NULL;
22830 wxDateTime *arg1 = (wxDateTime *) 0 ;
22831 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22832 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22833 int result;
22834 bool temp2 = false ;
22835 PyObject * obj0 = 0 ;
22836 PyObject * obj1 = 0 ;
22837 char *kwnames[] = {
22838 (char *) "self",(char *) "tz", NULL
22839 };
22840
22841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
22842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22843 if (SWIG_arg_fail(1)) SWIG_fail;
22844 if (obj1) {
22845 {
22846 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22847 temp2 = true;
22848 }
22849 }
22850 {
22851 PyThreadState* __tstate = wxPyBeginAllowThreads();
22852 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
22853
22854 wxPyEndAllowThreads(__tstate);
22855 if (PyErr_Occurred()) SWIG_fail;
22856 }
22857 {
22858 resultobj = SWIG_From_int(static_cast<int >(result));
22859 }
22860 {
22861 if (temp2) delete arg2;
22862 }
22863 return resultobj;
22864 fail:
22865 {
22866 if (temp2) delete arg2;
22867 }
22868 return NULL;
22869 }
22870
22871
22872 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
22873 PyObject *resultobj = NULL;
22874 wxDateTime *arg1 = (wxDateTime *) 0 ;
22875 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22876 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22877 wxDateTime::WeekDay result;
22878 bool temp2 = false ;
22879 PyObject * obj0 = 0 ;
22880 PyObject * obj1 = 0 ;
22881 char *kwnames[] = {
22882 (char *) "self",(char *) "tz", NULL
22883 };
22884
22885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
22886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22887 if (SWIG_arg_fail(1)) SWIG_fail;
22888 if (obj1) {
22889 {
22890 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22891 temp2 = true;
22892 }
22893 }
22894 {
22895 PyThreadState* __tstate = wxPyBeginAllowThreads();
22896 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
22897
22898 wxPyEndAllowThreads(__tstate);
22899 if (PyErr_Occurred()) SWIG_fail;
22900 }
22901 resultobj = SWIG_From_int((result));
22902 {
22903 if (temp2) delete arg2;
22904 }
22905 return resultobj;
22906 fail:
22907 {
22908 if (temp2) delete arg2;
22909 }
22910 return NULL;
22911 }
22912
22913
22914 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
22915 PyObject *resultobj = NULL;
22916 wxDateTime *arg1 = (wxDateTime *) 0 ;
22917 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22918 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22919 int result;
22920 bool temp2 = false ;
22921 PyObject * obj0 = 0 ;
22922 PyObject * obj1 = 0 ;
22923 char *kwnames[] = {
22924 (char *) "self",(char *) "tz", NULL
22925 };
22926
22927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
22928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22929 if (SWIG_arg_fail(1)) SWIG_fail;
22930 if (obj1) {
22931 {
22932 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22933 temp2 = true;
22934 }
22935 }
22936 {
22937 PyThreadState* __tstate = wxPyBeginAllowThreads();
22938 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
22939
22940 wxPyEndAllowThreads(__tstate);
22941 if (PyErr_Occurred()) SWIG_fail;
22942 }
22943 {
22944 resultobj = SWIG_From_int(static_cast<int >(result));
22945 }
22946 {
22947 if (temp2) delete arg2;
22948 }
22949 return resultobj;
22950 fail:
22951 {
22952 if (temp2) delete arg2;
22953 }
22954 return NULL;
22955 }
22956
22957
22958 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
22959 PyObject *resultobj = NULL;
22960 wxDateTime *arg1 = (wxDateTime *) 0 ;
22961 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22962 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22963 int result;
22964 bool temp2 = false ;
22965 PyObject * obj0 = 0 ;
22966 PyObject * obj1 = 0 ;
22967 char *kwnames[] = {
22968 (char *) "self",(char *) "tz", NULL
22969 };
22970
22971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
22972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22973 if (SWIG_arg_fail(1)) SWIG_fail;
22974 if (obj1) {
22975 {
22976 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22977 temp2 = true;
22978 }
22979 }
22980 {
22981 PyThreadState* __tstate = wxPyBeginAllowThreads();
22982 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
22983
22984 wxPyEndAllowThreads(__tstate);
22985 if (PyErr_Occurred()) SWIG_fail;
22986 }
22987 {
22988 resultobj = SWIG_From_int(static_cast<int >(result));
22989 }
22990 {
22991 if (temp2) delete arg2;
22992 }
22993 return resultobj;
22994 fail:
22995 {
22996 if (temp2) delete arg2;
22997 }
22998 return NULL;
22999 }
23000
23001
23002 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
23003 PyObject *resultobj = NULL;
23004 wxDateTime *arg1 = (wxDateTime *) 0 ;
23005 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
23006 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
23007 int result;
23008 bool temp2 = false ;
23009 PyObject * obj0 = 0 ;
23010 PyObject * obj1 = 0 ;
23011 char *kwnames[] = {
23012 (char *) "self",(char *) "tz", NULL
23013 };
23014
23015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
23016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23017 if (SWIG_arg_fail(1)) SWIG_fail;
23018 if (obj1) {
23019 {
23020 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
23021 temp2 = true;
23022 }
23023 }
23024 {
23025 PyThreadState* __tstate = wxPyBeginAllowThreads();
23026 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
23027
23028 wxPyEndAllowThreads(__tstate);
23029 if (PyErr_Occurred()) SWIG_fail;
23030 }
23031 {
23032 resultobj = SWIG_From_int(static_cast<int >(result));
23033 }
23034 {
23035 if (temp2) delete arg2;
23036 }
23037 return resultobj;
23038 fail:
23039 {
23040 if (temp2) delete arg2;
23041 }
23042 return NULL;
23043 }
23044
23045
23046 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
23047 PyObject *resultobj = NULL;
23048 wxDateTime *arg1 = (wxDateTime *) 0 ;
23049 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
23050 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
23051 int result;
23052 bool temp2 = false ;
23053 PyObject * obj0 = 0 ;
23054 PyObject * obj1 = 0 ;
23055 char *kwnames[] = {
23056 (char *) "self",(char *) "tz", NULL
23057 };
23058
23059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
23060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23061 if (SWIG_arg_fail(1)) SWIG_fail;
23062 if (obj1) {
23063 {
23064 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
23065 temp2 = true;
23066 }
23067 }
23068 {
23069 PyThreadState* __tstate = wxPyBeginAllowThreads();
23070 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
23071
23072 wxPyEndAllowThreads(__tstate);
23073 if (PyErr_Occurred()) SWIG_fail;
23074 }
23075 {
23076 resultobj = SWIG_From_int(static_cast<int >(result));
23077 }
23078 {
23079 if (temp2) delete arg2;
23080 }
23081 return resultobj;
23082 fail:
23083 {
23084 if (temp2) delete arg2;
23085 }
23086 return NULL;
23087 }
23088
23089
23090 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
23091 PyObject *resultobj = NULL;
23092 wxDateTime *arg1 = (wxDateTime *) 0 ;
23093 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
23094 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
23095 int result;
23096 bool temp2 = false ;
23097 PyObject * obj0 = 0 ;
23098 PyObject * obj1 = 0 ;
23099 char *kwnames[] = {
23100 (char *) "self",(char *) "tz", NULL
23101 };
23102
23103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
23104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23105 if (SWIG_arg_fail(1)) SWIG_fail;
23106 if (obj1) {
23107 {
23108 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
23109 temp2 = true;
23110 }
23111 }
23112 {
23113 PyThreadState* __tstate = wxPyBeginAllowThreads();
23114 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
23115
23116 wxPyEndAllowThreads(__tstate);
23117 if (PyErr_Occurred()) SWIG_fail;
23118 }
23119 {
23120 resultobj = SWIG_From_int(static_cast<int >(result));
23121 }
23122 {
23123 if (temp2) delete arg2;
23124 }
23125 return resultobj;
23126 fail:
23127 {
23128 if (temp2) delete arg2;
23129 }
23130 return NULL;
23131 }
23132
23133
23134 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
23135 PyObject *resultobj = NULL;
23136 wxDateTime *arg1 = (wxDateTime *) 0 ;
23137 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23138 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23139 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23140 int result;
23141 bool temp3 = false ;
23142 PyObject * obj0 = 0 ;
23143 PyObject * obj1 = 0 ;
23144 PyObject * obj2 = 0 ;
23145 char *kwnames[] = {
23146 (char *) "self",(char *) "flags",(char *) "tz", NULL
23147 };
23148
23149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
23150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23151 if (SWIG_arg_fail(1)) SWIG_fail;
23152 if (obj1) {
23153 {
23154 arg2 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj1));
23155 if (SWIG_arg_fail(2)) SWIG_fail;
23156 }
23157 }
23158 if (obj2) {
23159 {
23160 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23161 temp3 = true;
23162 }
23163 }
23164 {
23165 PyThreadState* __tstate = wxPyBeginAllowThreads();
23166 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
23167
23168 wxPyEndAllowThreads(__tstate);
23169 if (PyErr_Occurred()) SWIG_fail;
23170 }
23171 {
23172 resultobj = SWIG_From_int(static_cast<int >(result));
23173 }
23174 {
23175 if (temp3) delete arg3;
23176 }
23177 return resultobj;
23178 fail:
23179 {
23180 if (temp3) delete arg3;
23181 }
23182 return NULL;
23183 }
23184
23185
23186 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
23187 PyObject *resultobj = NULL;
23188 wxDateTime *arg1 = (wxDateTime *) 0 ;
23189 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23190 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23191 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23192 int result;
23193 bool temp3 = false ;
23194 PyObject * obj0 = 0 ;
23195 PyObject * obj1 = 0 ;
23196 PyObject * obj2 = 0 ;
23197 char *kwnames[] = {
23198 (char *) "self",(char *) "flags",(char *) "tz", NULL
23199 };
23200
23201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
23202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23203 if (SWIG_arg_fail(1)) SWIG_fail;
23204 if (obj1) {
23205 {
23206 arg2 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj1));
23207 if (SWIG_arg_fail(2)) SWIG_fail;
23208 }
23209 }
23210 if (obj2) {
23211 {
23212 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23213 temp3 = true;
23214 }
23215 }
23216 {
23217 PyThreadState* __tstate = wxPyBeginAllowThreads();
23218 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
23219
23220 wxPyEndAllowThreads(__tstate);
23221 if (PyErr_Occurred()) SWIG_fail;
23222 }
23223 {
23224 resultobj = SWIG_From_int(static_cast<int >(result));
23225 }
23226 {
23227 if (temp3) delete arg3;
23228 }
23229 return resultobj;
23230 fail:
23231 {
23232 if (temp3) delete arg3;
23233 }
23234 return NULL;
23235 }
23236
23237
23238 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
23239 PyObject *resultobj = NULL;
23240 wxDateTime *arg1 = (wxDateTime *) 0 ;
23241 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23242 bool result;
23243 PyObject * obj0 = 0 ;
23244 PyObject * obj1 = 0 ;
23245 char *kwnames[] = {
23246 (char *) "self",(char *) "country", NULL
23247 };
23248
23249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
23250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23251 if (SWIG_arg_fail(1)) SWIG_fail;
23252 if (obj1) {
23253 {
23254 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
23255 if (SWIG_arg_fail(2)) SWIG_fail;
23256 }
23257 }
23258 {
23259 PyThreadState* __tstate = wxPyBeginAllowThreads();
23260 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
23261
23262 wxPyEndAllowThreads(__tstate);
23263 if (PyErr_Occurred()) SWIG_fail;
23264 }
23265 {
23266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23267 }
23268 return resultobj;
23269 fail:
23270 return NULL;
23271 }
23272
23273
23274 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
23275 PyObject *resultobj = NULL;
23276 wxDateTime *arg1 = (wxDateTime *) 0 ;
23277 wxDateTime *arg2 = 0 ;
23278 bool result;
23279 PyObject * obj0 = 0 ;
23280 PyObject * obj1 = 0 ;
23281 char *kwnames[] = {
23282 (char *) "self",(char *) "datetime", NULL
23283 };
23284
23285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
23286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23287 if (SWIG_arg_fail(1)) SWIG_fail;
23288 {
23289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23290 if (SWIG_arg_fail(2)) SWIG_fail;
23291 if (arg2 == NULL) {
23292 SWIG_null_ref("wxDateTime");
23293 }
23294 if (SWIG_arg_fail(2)) SWIG_fail;
23295 }
23296 {
23297 PyThreadState* __tstate = wxPyBeginAllowThreads();
23298 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
23299
23300 wxPyEndAllowThreads(__tstate);
23301 if (PyErr_Occurred()) SWIG_fail;
23302 }
23303 {
23304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23305 }
23306 return resultobj;
23307 fail:
23308 return NULL;
23309 }
23310
23311
23312 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
23313 PyObject *resultobj = NULL;
23314 wxDateTime *arg1 = (wxDateTime *) 0 ;
23315 wxDateTime *arg2 = 0 ;
23316 bool result;
23317 PyObject * obj0 = 0 ;
23318 PyObject * obj1 = 0 ;
23319 char *kwnames[] = {
23320 (char *) "self",(char *) "datetime", NULL
23321 };
23322
23323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
23324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23325 if (SWIG_arg_fail(1)) SWIG_fail;
23326 {
23327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23328 if (SWIG_arg_fail(2)) SWIG_fail;
23329 if (arg2 == NULL) {
23330 SWIG_null_ref("wxDateTime");
23331 }
23332 if (SWIG_arg_fail(2)) SWIG_fail;
23333 }
23334 {
23335 PyThreadState* __tstate = wxPyBeginAllowThreads();
23336 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
23337
23338 wxPyEndAllowThreads(__tstate);
23339 if (PyErr_Occurred()) SWIG_fail;
23340 }
23341 {
23342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23343 }
23344 return resultobj;
23345 fail:
23346 return NULL;
23347 }
23348
23349
23350 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
23351 PyObject *resultobj = NULL;
23352 wxDateTime *arg1 = (wxDateTime *) 0 ;
23353 wxDateTime *arg2 = 0 ;
23354 bool result;
23355 PyObject * obj0 = 0 ;
23356 PyObject * obj1 = 0 ;
23357 char *kwnames[] = {
23358 (char *) "self",(char *) "datetime", NULL
23359 };
23360
23361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
23362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23363 if (SWIG_arg_fail(1)) SWIG_fail;
23364 {
23365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23366 if (SWIG_arg_fail(2)) SWIG_fail;
23367 if (arg2 == NULL) {
23368 SWIG_null_ref("wxDateTime");
23369 }
23370 if (SWIG_arg_fail(2)) SWIG_fail;
23371 }
23372 {
23373 PyThreadState* __tstate = wxPyBeginAllowThreads();
23374 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
23375
23376 wxPyEndAllowThreads(__tstate);
23377 if (PyErr_Occurred()) SWIG_fail;
23378 }
23379 {
23380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23381 }
23382 return resultobj;
23383 fail:
23384 return NULL;
23385 }
23386
23387
23388 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
23389 PyObject *resultobj = NULL;
23390 wxDateTime *arg1 = (wxDateTime *) 0 ;
23391 wxDateTime *arg2 = 0 ;
23392 wxDateTime *arg3 = 0 ;
23393 bool result;
23394 PyObject * obj0 = 0 ;
23395 PyObject * obj1 = 0 ;
23396 PyObject * obj2 = 0 ;
23397 char *kwnames[] = {
23398 (char *) "self",(char *) "t1",(char *) "t2", NULL
23399 };
23400
23401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
23402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23403 if (SWIG_arg_fail(1)) SWIG_fail;
23404 {
23405 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23406 if (SWIG_arg_fail(2)) SWIG_fail;
23407 if (arg2 == NULL) {
23408 SWIG_null_ref("wxDateTime");
23409 }
23410 if (SWIG_arg_fail(2)) SWIG_fail;
23411 }
23412 {
23413 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23414 if (SWIG_arg_fail(3)) SWIG_fail;
23415 if (arg3 == NULL) {
23416 SWIG_null_ref("wxDateTime");
23417 }
23418 if (SWIG_arg_fail(3)) SWIG_fail;
23419 }
23420 {
23421 PyThreadState* __tstate = wxPyBeginAllowThreads();
23422 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
23423
23424 wxPyEndAllowThreads(__tstate);
23425 if (PyErr_Occurred()) SWIG_fail;
23426 }
23427 {
23428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23429 }
23430 return resultobj;
23431 fail:
23432 return NULL;
23433 }
23434
23435
23436 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
23437 PyObject *resultobj = NULL;
23438 wxDateTime *arg1 = (wxDateTime *) 0 ;
23439 wxDateTime *arg2 = 0 ;
23440 wxDateTime *arg3 = 0 ;
23441 bool result;
23442 PyObject * obj0 = 0 ;
23443 PyObject * obj1 = 0 ;
23444 PyObject * obj2 = 0 ;
23445 char *kwnames[] = {
23446 (char *) "self",(char *) "t1",(char *) "t2", NULL
23447 };
23448
23449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
23450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23451 if (SWIG_arg_fail(1)) SWIG_fail;
23452 {
23453 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23454 if (SWIG_arg_fail(2)) SWIG_fail;
23455 if (arg2 == NULL) {
23456 SWIG_null_ref("wxDateTime");
23457 }
23458 if (SWIG_arg_fail(2)) SWIG_fail;
23459 }
23460 {
23461 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23462 if (SWIG_arg_fail(3)) SWIG_fail;
23463 if (arg3 == NULL) {
23464 SWIG_null_ref("wxDateTime");
23465 }
23466 if (SWIG_arg_fail(3)) SWIG_fail;
23467 }
23468 {
23469 PyThreadState* __tstate = wxPyBeginAllowThreads();
23470 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
23471
23472 wxPyEndAllowThreads(__tstate);
23473 if (PyErr_Occurred()) SWIG_fail;
23474 }
23475 {
23476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23477 }
23478 return resultobj;
23479 fail:
23480 return NULL;
23481 }
23482
23483
23484 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
23485 PyObject *resultobj = NULL;
23486 wxDateTime *arg1 = (wxDateTime *) 0 ;
23487 wxDateTime *arg2 = 0 ;
23488 bool result;
23489 PyObject * obj0 = 0 ;
23490 PyObject * obj1 = 0 ;
23491 char *kwnames[] = {
23492 (char *) "self",(char *) "dt", NULL
23493 };
23494
23495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
23496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23497 if (SWIG_arg_fail(1)) SWIG_fail;
23498 {
23499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23500 if (SWIG_arg_fail(2)) SWIG_fail;
23501 if (arg2 == NULL) {
23502 SWIG_null_ref("wxDateTime");
23503 }
23504 if (SWIG_arg_fail(2)) SWIG_fail;
23505 }
23506 {
23507 PyThreadState* __tstate = wxPyBeginAllowThreads();
23508 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
23509
23510 wxPyEndAllowThreads(__tstate);
23511 if (PyErr_Occurred()) SWIG_fail;
23512 }
23513 {
23514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23515 }
23516 return resultobj;
23517 fail:
23518 return NULL;
23519 }
23520
23521
23522 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
23523 PyObject *resultobj = NULL;
23524 wxDateTime *arg1 = (wxDateTime *) 0 ;
23525 wxDateTime *arg2 = 0 ;
23526 bool result;
23527 PyObject * obj0 = 0 ;
23528 PyObject * obj1 = 0 ;
23529 char *kwnames[] = {
23530 (char *) "self",(char *) "dt", NULL
23531 };
23532
23533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
23534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23535 if (SWIG_arg_fail(1)) SWIG_fail;
23536 {
23537 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23538 if (SWIG_arg_fail(2)) SWIG_fail;
23539 if (arg2 == NULL) {
23540 SWIG_null_ref("wxDateTime");
23541 }
23542 if (SWIG_arg_fail(2)) SWIG_fail;
23543 }
23544 {
23545 PyThreadState* __tstate = wxPyBeginAllowThreads();
23546 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
23547
23548 wxPyEndAllowThreads(__tstate);
23549 if (PyErr_Occurred()) SWIG_fail;
23550 }
23551 {
23552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23553 }
23554 return resultobj;
23555 fail:
23556 return NULL;
23557 }
23558
23559
23560 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
23561 PyObject *resultobj = NULL;
23562 wxDateTime *arg1 = (wxDateTime *) 0 ;
23563 wxDateTime *arg2 = 0 ;
23564 wxTimeSpan *arg3 = 0 ;
23565 bool result;
23566 PyObject * obj0 = 0 ;
23567 PyObject * obj1 = 0 ;
23568 PyObject * obj2 = 0 ;
23569 char *kwnames[] = {
23570 (char *) "self",(char *) "dt",(char *) "ts", NULL
23571 };
23572
23573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
23574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23575 if (SWIG_arg_fail(1)) SWIG_fail;
23576 {
23577 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23578 if (SWIG_arg_fail(2)) SWIG_fail;
23579 if (arg2 == NULL) {
23580 SWIG_null_ref("wxDateTime");
23581 }
23582 if (SWIG_arg_fail(2)) SWIG_fail;
23583 }
23584 {
23585 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23586 if (SWIG_arg_fail(3)) SWIG_fail;
23587 if (arg3 == NULL) {
23588 SWIG_null_ref("wxTimeSpan");
23589 }
23590 if (SWIG_arg_fail(3)) SWIG_fail;
23591 }
23592 {
23593 PyThreadState* __tstate = wxPyBeginAllowThreads();
23594 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
23595
23596 wxPyEndAllowThreads(__tstate);
23597 if (PyErr_Occurred()) SWIG_fail;
23598 }
23599 {
23600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23601 }
23602 return resultobj;
23603 fail:
23604 return NULL;
23605 }
23606
23607
23608 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
23609 PyObject *resultobj = NULL;
23610 wxDateTime *arg1 = (wxDateTime *) 0 ;
23611 wxTimeSpan *arg2 = 0 ;
23612 wxDateTime *result;
23613 PyObject * obj0 = 0 ;
23614 PyObject * obj1 = 0 ;
23615 char *kwnames[] = {
23616 (char *) "self",(char *) "diff", NULL
23617 };
23618
23619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
23620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23621 if (SWIG_arg_fail(1)) SWIG_fail;
23622 {
23623 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23624 if (SWIG_arg_fail(2)) SWIG_fail;
23625 if (arg2 == NULL) {
23626 SWIG_null_ref("wxTimeSpan");
23627 }
23628 if (SWIG_arg_fail(2)) SWIG_fail;
23629 }
23630 {
23631 PyThreadState* __tstate = wxPyBeginAllowThreads();
23632 {
23633 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
23634 result = (wxDateTime *) &_result_ref;
23635 }
23636
23637 wxPyEndAllowThreads(__tstate);
23638 if (PyErr_Occurred()) SWIG_fail;
23639 }
23640 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23641 return resultobj;
23642 fail:
23643 return NULL;
23644 }
23645
23646
23647 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
23648 PyObject *resultobj = NULL;
23649 wxDateTime *arg1 = (wxDateTime *) 0 ;
23650 wxDateSpan *arg2 = 0 ;
23651 wxDateTime *result;
23652 PyObject * obj0 = 0 ;
23653 PyObject * obj1 = 0 ;
23654 char *kwnames[] = {
23655 (char *) "self",(char *) "diff", NULL
23656 };
23657
23658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
23659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23660 if (SWIG_arg_fail(1)) SWIG_fail;
23661 {
23662 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23663 if (SWIG_arg_fail(2)) SWIG_fail;
23664 if (arg2 == NULL) {
23665 SWIG_null_ref("wxDateSpan");
23666 }
23667 if (SWIG_arg_fail(2)) SWIG_fail;
23668 }
23669 {
23670 PyThreadState* __tstate = wxPyBeginAllowThreads();
23671 {
23672 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
23673 result = (wxDateTime *) &_result_ref;
23674 }
23675
23676 wxPyEndAllowThreads(__tstate);
23677 if (PyErr_Occurred()) SWIG_fail;
23678 }
23679 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
23687 PyObject *resultobj = NULL;
23688 wxDateTime *arg1 = (wxDateTime *) 0 ;
23689 wxTimeSpan *arg2 = 0 ;
23690 wxDateTime *result;
23691 PyObject * obj0 = 0 ;
23692 PyObject * obj1 = 0 ;
23693 char *kwnames[] = {
23694 (char *) "self",(char *) "diff", NULL
23695 };
23696
23697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
23698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23699 if (SWIG_arg_fail(1)) SWIG_fail;
23700 {
23701 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23702 if (SWIG_arg_fail(2)) SWIG_fail;
23703 if (arg2 == NULL) {
23704 SWIG_null_ref("wxTimeSpan");
23705 }
23706 if (SWIG_arg_fail(2)) SWIG_fail;
23707 }
23708 {
23709 PyThreadState* __tstate = wxPyBeginAllowThreads();
23710 {
23711 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
23712 result = (wxDateTime *) &_result_ref;
23713 }
23714
23715 wxPyEndAllowThreads(__tstate);
23716 if (PyErr_Occurred()) SWIG_fail;
23717 }
23718 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23719 return resultobj;
23720 fail:
23721 return NULL;
23722 }
23723
23724
23725 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
23726 PyObject *resultobj = NULL;
23727 wxDateTime *arg1 = (wxDateTime *) 0 ;
23728 wxDateSpan *arg2 = 0 ;
23729 wxDateTime *result;
23730 PyObject * obj0 = 0 ;
23731 PyObject * obj1 = 0 ;
23732 char *kwnames[] = {
23733 (char *) "self",(char *) "diff", NULL
23734 };
23735
23736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
23737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23738 if (SWIG_arg_fail(1)) SWIG_fail;
23739 {
23740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23741 if (SWIG_arg_fail(2)) SWIG_fail;
23742 if (arg2 == NULL) {
23743 SWIG_null_ref("wxDateSpan");
23744 }
23745 if (SWIG_arg_fail(2)) SWIG_fail;
23746 }
23747 {
23748 PyThreadState* __tstate = wxPyBeginAllowThreads();
23749 {
23750 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
23751 result = (wxDateTime *) &_result_ref;
23752 }
23753
23754 wxPyEndAllowThreads(__tstate);
23755 if (PyErr_Occurred()) SWIG_fail;
23756 }
23757 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23758 return resultobj;
23759 fail:
23760 return NULL;
23761 }
23762
23763
23764 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
23765 PyObject *resultobj = NULL;
23766 wxDateTime *arg1 = (wxDateTime *) 0 ;
23767 wxDateTime *arg2 = 0 ;
23768 wxTimeSpan result;
23769 PyObject * obj0 = 0 ;
23770 PyObject * obj1 = 0 ;
23771 char *kwnames[] = {
23772 (char *) "self",(char *) "dt", NULL
23773 };
23774
23775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
23776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23777 if (SWIG_arg_fail(1)) SWIG_fail;
23778 {
23779 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23780 if (SWIG_arg_fail(2)) SWIG_fail;
23781 if (arg2 == NULL) {
23782 SWIG_null_ref("wxDateTime");
23783 }
23784 if (SWIG_arg_fail(2)) SWIG_fail;
23785 }
23786 {
23787 PyThreadState* __tstate = wxPyBeginAllowThreads();
23788 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
23789
23790 wxPyEndAllowThreads(__tstate);
23791 if (PyErr_Occurred()) SWIG_fail;
23792 }
23793 {
23794 wxTimeSpan * resultptr;
23795 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
23796 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23797 }
23798 return resultobj;
23799 fail:
23800 return NULL;
23801 }
23802
23803
23804 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
23805 PyObject *resultobj = NULL;
23806 wxDateTime *arg1 = (wxDateTime *) 0 ;
23807 wxTimeSpan *arg2 = 0 ;
23808 wxDateTime *result;
23809 PyObject * obj0 = 0 ;
23810 PyObject * obj1 = 0 ;
23811
23812 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
23813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23814 if (SWIG_arg_fail(1)) SWIG_fail;
23815 {
23816 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23817 if (SWIG_arg_fail(2)) SWIG_fail;
23818 if (arg2 == NULL) {
23819 SWIG_null_ref("wxTimeSpan");
23820 }
23821 if (SWIG_arg_fail(2)) SWIG_fail;
23822 }
23823 {
23824 PyThreadState* __tstate = wxPyBeginAllowThreads();
23825 {
23826 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
23827 result = (wxDateTime *) &_result_ref;
23828 }
23829
23830 wxPyEndAllowThreads(__tstate);
23831 if (PyErr_Occurred()) SWIG_fail;
23832 }
23833 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
23834 return resultobj;
23835 fail:
23836 return NULL;
23837 }
23838
23839
23840 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
23841 PyObject *resultobj = NULL;
23842 wxDateTime *arg1 = (wxDateTime *) 0 ;
23843 wxDateSpan *arg2 = 0 ;
23844 wxDateTime *result;
23845 PyObject * obj0 = 0 ;
23846 PyObject * obj1 = 0 ;
23847
23848 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
23849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23850 if (SWIG_arg_fail(1)) SWIG_fail;
23851 {
23852 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23853 if (SWIG_arg_fail(2)) SWIG_fail;
23854 if (arg2 == NULL) {
23855 SWIG_null_ref("wxDateSpan");
23856 }
23857 if (SWIG_arg_fail(2)) SWIG_fail;
23858 }
23859 {
23860 PyThreadState* __tstate = wxPyBeginAllowThreads();
23861 {
23862 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
23863 result = (wxDateTime *) &_result_ref;
23864 }
23865
23866 wxPyEndAllowThreads(__tstate);
23867 if (PyErr_Occurred()) SWIG_fail;
23868 }
23869 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
23870 return resultobj;
23871 fail:
23872 return NULL;
23873 }
23874
23875
23876 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
23877 int argc;
23878 PyObject *argv[3];
23879 int ii;
23880
23881 argc = PyObject_Length(args);
23882 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23883 argv[ii] = PyTuple_GetItem(args,ii);
23884 }
23885 if (argc == 2) {
23886 int _v;
23887 {
23888 void *ptr;
23889 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23890 _v = 0;
23891 PyErr_Clear();
23892 } else {
23893 _v = 1;
23894 }
23895 }
23896 if (_v) {
23897 {
23898 void *ptr = 0;
23899 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23900 _v = 0;
23901 PyErr_Clear();
23902 } else {
23903 _v = (ptr != 0);
23904 }
23905 }
23906 if (_v) {
23907 return _wrap_DateTime___iadd____SWIG_0(self,args);
23908 }
23909 }
23910 }
23911 if (argc == 2) {
23912 int _v;
23913 {
23914 void *ptr;
23915 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23916 _v = 0;
23917 PyErr_Clear();
23918 } else {
23919 _v = 1;
23920 }
23921 }
23922 if (_v) {
23923 {
23924 void *ptr = 0;
23925 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23926 _v = 0;
23927 PyErr_Clear();
23928 } else {
23929 _v = (ptr != 0);
23930 }
23931 }
23932 if (_v) {
23933 return _wrap_DateTime___iadd____SWIG_1(self,args);
23934 }
23935 }
23936 }
23937
23938 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
23939 return NULL;
23940 }
23941
23942
23943 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
23944 PyObject *resultobj = NULL;
23945 wxDateTime *arg1 = (wxDateTime *) 0 ;
23946 wxTimeSpan *arg2 = 0 ;
23947 wxDateTime *result;
23948 PyObject * obj0 = 0 ;
23949 PyObject * obj1 = 0 ;
23950
23951 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
23952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23953 if (SWIG_arg_fail(1)) SWIG_fail;
23954 {
23955 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23956 if (SWIG_arg_fail(2)) SWIG_fail;
23957 if (arg2 == NULL) {
23958 SWIG_null_ref("wxTimeSpan");
23959 }
23960 if (SWIG_arg_fail(2)) SWIG_fail;
23961 }
23962 {
23963 PyThreadState* __tstate = wxPyBeginAllowThreads();
23964 {
23965 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
23966 result = (wxDateTime *) &_result_ref;
23967 }
23968
23969 wxPyEndAllowThreads(__tstate);
23970 if (PyErr_Occurred()) SWIG_fail;
23971 }
23972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
23973 return resultobj;
23974 fail:
23975 return NULL;
23976 }
23977
23978
23979 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
23980 PyObject *resultobj = NULL;
23981 wxDateTime *arg1 = (wxDateTime *) 0 ;
23982 wxDateSpan *arg2 = 0 ;
23983 wxDateTime *result;
23984 PyObject * obj0 = 0 ;
23985 PyObject * obj1 = 0 ;
23986
23987 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
23988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23989 if (SWIG_arg_fail(1)) SWIG_fail;
23990 {
23991 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23992 if (SWIG_arg_fail(2)) SWIG_fail;
23993 if (arg2 == NULL) {
23994 SWIG_null_ref("wxDateSpan");
23995 }
23996 if (SWIG_arg_fail(2)) SWIG_fail;
23997 }
23998 {
23999 PyThreadState* __tstate = wxPyBeginAllowThreads();
24000 {
24001 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
24002 result = (wxDateTime *) &_result_ref;
24003 }
24004
24005 wxPyEndAllowThreads(__tstate);
24006 if (PyErr_Occurred()) SWIG_fail;
24007 }
24008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
24009 return resultobj;
24010 fail:
24011 return NULL;
24012 }
24013
24014
24015 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
24016 int argc;
24017 PyObject *argv[3];
24018 int ii;
24019
24020 argc = PyObject_Length(args);
24021 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
24022 argv[ii] = PyTuple_GetItem(args,ii);
24023 }
24024 if (argc == 2) {
24025 int _v;
24026 {
24027 void *ptr;
24028 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24029 _v = 0;
24030 PyErr_Clear();
24031 } else {
24032 _v = 1;
24033 }
24034 }
24035 if (_v) {
24036 {
24037 void *ptr = 0;
24038 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
24039 _v = 0;
24040 PyErr_Clear();
24041 } else {
24042 _v = (ptr != 0);
24043 }
24044 }
24045 if (_v) {
24046 return _wrap_DateTime___isub____SWIG_0(self,args);
24047 }
24048 }
24049 }
24050 if (argc == 2) {
24051 int _v;
24052 {
24053 void *ptr;
24054 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24055 _v = 0;
24056 PyErr_Clear();
24057 } else {
24058 _v = 1;
24059 }
24060 }
24061 if (_v) {
24062 {
24063 void *ptr = 0;
24064 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
24065 _v = 0;
24066 PyErr_Clear();
24067 } else {
24068 _v = (ptr != 0);
24069 }
24070 }
24071 if (_v) {
24072 return _wrap_DateTime___isub____SWIG_1(self,args);
24073 }
24074 }
24075 }
24076
24077 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
24078 return NULL;
24079 }
24080
24081
24082 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
24083 PyObject *resultobj = NULL;
24084 wxDateTime *arg1 = (wxDateTime *) 0 ;
24085 wxTimeSpan *arg2 = 0 ;
24086 wxDateTime result;
24087 PyObject * obj0 = 0 ;
24088 PyObject * obj1 = 0 ;
24089
24090 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
24091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24092 if (SWIG_arg_fail(1)) SWIG_fail;
24093 {
24094 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24095 if (SWIG_arg_fail(2)) SWIG_fail;
24096 if (arg2 == NULL) {
24097 SWIG_null_ref("wxTimeSpan");
24098 }
24099 if (SWIG_arg_fail(2)) SWIG_fail;
24100 }
24101 {
24102 PyThreadState* __tstate = wxPyBeginAllowThreads();
24103 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
24104
24105 wxPyEndAllowThreads(__tstate);
24106 if (PyErr_Occurred()) SWIG_fail;
24107 }
24108 {
24109 wxDateTime * resultptr;
24110 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
24111 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
24112 }
24113 return resultobj;
24114 fail:
24115 return NULL;
24116 }
24117
24118
24119 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
24120 PyObject *resultobj = NULL;
24121 wxDateTime *arg1 = (wxDateTime *) 0 ;
24122 wxDateSpan *arg2 = 0 ;
24123 wxDateTime result;
24124 PyObject * obj0 = 0 ;
24125 PyObject * obj1 = 0 ;
24126
24127 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
24128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24129 if (SWIG_arg_fail(1)) SWIG_fail;
24130 {
24131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
24132 if (SWIG_arg_fail(2)) SWIG_fail;
24133 if (arg2 == NULL) {
24134 SWIG_null_ref("wxDateSpan");
24135 }
24136 if (SWIG_arg_fail(2)) SWIG_fail;
24137 }
24138 {
24139 PyThreadState* __tstate = wxPyBeginAllowThreads();
24140 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
24141
24142 wxPyEndAllowThreads(__tstate);
24143 if (PyErr_Occurred()) SWIG_fail;
24144 }
24145 {
24146 wxDateTime * resultptr;
24147 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
24148 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
24149 }
24150 return resultobj;
24151 fail:
24152 return NULL;
24153 }
24154
24155
24156 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
24157 int argc;
24158 PyObject *argv[3];
24159 int ii;
24160
24161 argc = PyObject_Length(args);
24162 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
24163 argv[ii] = PyTuple_GetItem(args,ii);
24164 }
24165 if (argc == 2) {
24166 int _v;
24167 {
24168 void *ptr;
24169 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24170 _v = 0;
24171 PyErr_Clear();
24172 } else {
24173 _v = 1;
24174 }
24175 }
24176 if (_v) {
24177 {
24178 void *ptr = 0;
24179 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
24180 _v = 0;
24181 PyErr_Clear();
24182 } else {
24183 _v = (ptr != 0);
24184 }
24185 }
24186 if (_v) {
24187 return _wrap_DateTime___add____SWIG_0(self,args);
24188 }
24189 }
24190 }
24191 if (argc == 2) {
24192 int _v;
24193 {
24194 void *ptr;
24195 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24196 _v = 0;
24197 PyErr_Clear();
24198 } else {
24199 _v = 1;
24200 }
24201 }
24202 if (_v) {
24203 {
24204 void *ptr = 0;
24205 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
24206 _v = 0;
24207 PyErr_Clear();
24208 } else {
24209 _v = (ptr != 0);
24210 }
24211 }
24212 if (_v) {
24213 return _wrap_DateTime___add____SWIG_1(self,args);
24214 }
24215 }
24216 }
24217
24218 Py_INCREF(Py_NotImplemented);
24219 return Py_NotImplemented;
24220 }
24221
24222
24223 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
24224 PyObject *resultobj = NULL;
24225 wxDateTime *arg1 = (wxDateTime *) 0 ;
24226 wxDateTime *arg2 = 0 ;
24227 wxTimeSpan result;
24228 PyObject * obj0 = 0 ;
24229 PyObject * obj1 = 0 ;
24230
24231 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
24232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24233 if (SWIG_arg_fail(1)) SWIG_fail;
24234 {
24235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24236 if (SWIG_arg_fail(2)) SWIG_fail;
24237 if (arg2 == NULL) {
24238 SWIG_null_ref("wxDateTime");
24239 }
24240 if (SWIG_arg_fail(2)) SWIG_fail;
24241 }
24242 {
24243 PyThreadState* __tstate = wxPyBeginAllowThreads();
24244 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
24245
24246 wxPyEndAllowThreads(__tstate);
24247 if (PyErr_Occurred()) SWIG_fail;
24248 }
24249 {
24250 wxTimeSpan * resultptr;
24251 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
24252 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24253 }
24254 return resultobj;
24255 fail:
24256 return NULL;
24257 }
24258
24259
24260 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
24261 PyObject *resultobj = NULL;
24262 wxDateTime *arg1 = (wxDateTime *) 0 ;
24263 wxTimeSpan *arg2 = 0 ;
24264 wxDateTime result;
24265 PyObject * obj0 = 0 ;
24266 PyObject * obj1 = 0 ;
24267
24268 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
24269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24270 if (SWIG_arg_fail(1)) SWIG_fail;
24271 {
24272 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24273 if (SWIG_arg_fail(2)) SWIG_fail;
24274 if (arg2 == NULL) {
24275 SWIG_null_ref("wxTimeSpan");
24276 }
24277 if (SWIG_arg_fail(2)) SWIG_fail;
24278 }
24279 {
24280 PyThreadState* __tstate = wxPyBeginAllowThreads();
24281 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
24282
24283 wxPyEndAllowThreads(__tstate);
24284 if (PyErr_Occurred()) SWIG_fail;
24285 }
24286 {
24287 wxDateTime * resultptr;
24288 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
24289 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
24290 }
24291 return resultobj;
24292 fail:
24293 return NULL;
24294 }
24295
24296
24297 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
24298 PyObject *resultobj = NULL;
24299 wxDateTime *arg1 = (wxDateTime *) 0 ;
24300 wxDateSpan *arg2 = 0 ;
24301 wxDateTime result;
24302 PyObject * obj0 = 0 ;
24303 PyObject * obj1 = 0 ;
24304
24305 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
24306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24307 if (SWIG_arg_fail(1)) SWIG_fail;
24308 {
24309 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
24310 if (SWIG_arg_fail(2)) SWIG_fail;
24311 if (arg2 == NULL) {
24312 SWIG_null_ref("wxDateSpan");
24313 }
24314 if (SWIG_arg_fail(2)) SWIG_fail;
24315 }
24316 {
24317 PyThreadState* __tstate = wxPyBeginAllowThreads();
24318 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
24319
24320 wxPyEndAllowThreads(__tstate);
24321 if (PyErr_Occurred()) SWIG_fail;
24322 }
24323 {
24324 wxDateTime * resultptr;
24325 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
24326 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
24327 }
24328 return resultobj;
24329 fail:
24330 return NULL;
24331 }
24332
24333
24334 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
24335 int argc;
24336 PyObject *argv[3];
24337 int ii;
24338
24339 argc = PyObject_Length(args);
24340 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
24341 argv[ii] = PyTuple_GetItem(args,ii);
24342 }
24343 if (argc == 2) {
24344 int _v;
24345 {
24346 void *ptr;
24347 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24348 _v = 0;
24349 PyErr_Clear();
24350 } else {
24351 _v = 1;
24352 }
24353 }
24354 if (_v) {
24355 {
24356 void *ptr = 0;
24357 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24358 _v = 0;
24359 PyErr_Clear();
24360 } else {
24361 _v = (ptr != 0);
24362 }
24363 }
24364 if (_v) {
24365 return _wrap_DateTime___sub____SWIG_0(self,args);
24366 }
24367 }
24368 }
24369 if (argc == 2) {
24370 int _v;
24371 {
24372 void *ptr;
24373 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24374 _v = 0;
24375 PyErr_Clear();
24376 } else {
24377 _v = 1;
24378 }
24379 }
24380 if (_v) {
24381 {
24382 void *ptr = 0;
24383 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
24384 _v = 0;
24385 PyErr_Clear();
24386 } else {
24387 _v = (ptr != 0);
24388 }
24389 }
24390 if (_v) {
24391 return _wrap_DateTime___sub____SWIG_1(self,args);
24392 }
24393 }
24394 }
24395 if (argc == 2) {
24396 int _v;
24397 {
24398 void *ptr;
24399 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24400 _v = 0;
24401 PyErr_Clear();
24402 } else {
24403 _v = 1;
24404 }
24405 }
24406 if (_v) {
24407 {
24408 void *ptr = 0;
24409 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
24410 _v = 0;
24411 PyErr_Clear();
24412 } else {
24413 _v = (ptr != 0);
24414 }
24415 }
24416 if (_v) {
24417 return _wrap_DateTime___sub____SWIG_2(self,args);
24418 }
24419 }
24420 }
24421
24422 Py_INCREF(Py_NotImplemented);
24423 return Py_NotImplemented;
24424 }
24425
24426
24427 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24428 PyObject *resultobj = NULL;
24429 wxDateTime *arg1 = (wxDateTime *) 0 ;
24430 wxDateTime *arg2 = (wxDateTime *) 0 ;
24431 bool result;
24432 PyObject * obj0 = 0 ;
24433 PyObject * obj1 = 0 ;
24434 char *kwnames[] = {
24435 (char *) "self",(char *) "other", NULL
24436 };
24437
24438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
24439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24440 if (SWIG_arg_fail(1)) SWIG_fail;
24441 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24442 if (SWIG_arg_fail(2)) SWIG_fail;
24443 {
24444 PyThreadState* __tstate = wxPyBeginAllowThreads();
24445 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
24446
24447 wxPyEndAllowThreads(__tstate);
24448 if (PyErr_Occurred()) SWIG_fail;
24449 }
24450 {
24451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24452 }
24453 return resultobj;
24454 fail:
24455 return NULL;
24456 }
24457
24458
24459 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24460 PyObject *resultobj = NULL;
24461 wxDateTime *arg1 = (wxDateTime *) 0 ;
24462 wxDateTime *arg2 = (wxDateTime *) 0 ;
24463 bool result;
24464 PyObject * obj0 = 0 ;
24465 PyObject * obj1 = 0 ;
24466 char *kwnames[] = {
24467 (char *) "self",(char *) "other", NULL
24468 };
24469
24470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
24471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24472 if (SWIG_arg_fail(1)) SWIG_fail;
24473 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24474 if (SWIG_arg_fail(2)) SWIG_fail;
24475 {
24476 PyThreadState* __tstate = wxPyBeginAllowThreads();
24477 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
24478
24479 wxPyEndAllowThreads(__tstate);
24480 if (PyErr_Occurred()) SWIG_fail;
24481 }
24482 {
24483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24484 }
24485 return resultobj;
24486 fail:
24487 return NULL;
24488 }
24489
24490
24491 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24492 PyObject *resultobj = NULL;
24493 wxDateTime *arg1 = (wxDateTime *) 0 ;
24494 wxDateTime *arg2 = (wxDateTime *) 0 ;
24495 bool result;
24496 PyObject * obj0 = 0 ;
24497 PyObject * obj1 = 0 ;
24498 char *kwnames[] = {
24499 (char *) "self",(char *) "other", NULL
24500 };
24501
24502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
24503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24504 if (SWIG_arg_fail(1)) SWIG_fail;
24505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24506 if (SWIG_arg_fail(2)) SWIG_fail;
24507 {
24508 PyThreadState* __tstate = wxPyBeginAllowThreads();
24509 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
24510
24511 wxPyEndAllowThreads(__tstate);
24512 if (PyErr_Occurred()) SWIG_fail;
24513 }
24514 {
24515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24516 }
24517 return resultobj;
24518 fail:
24519 return NULL;
24520 }
24521
24522
24523 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24524 PyObject *resultobj = NULL;
24525 wxDateTime *arg1 = (wxDateTime *) 0 ;
24526 wxDateTime *arg2 = (wxDateTime *) 0 ;
24527 bool result;
24528 PyObject * obj0 = 0 ;
24529 PyObject * obj1 = 0 ;
24530 char *kwnames[] = {
24531 (char *) "self",(char *) "other", NULL
24532 };
24533
24534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
24535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24536 if (SWIG_arg_fail(1)) SWIG_fail;
24537 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24538 if (SWIG_arg_fail(2)) SWIG_fail;
24539 {
24540 PyThreadState* __tstate = wxPyBeginAllowThreads();
24541 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
24542
24543 wxPyEndAllowThreads(__tstate);
24544 if (PyErr_Occurred()) SWIG_fail;
24545 }
24546 {
24547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24548 }
24549 return resultobj;
24550 fail:
24551 return NULL;
24552 }
24553
24554
24555 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24556 PyObject *resultobj = NULL;
24557 wxDateTime *arg1 = (wxDateTime *) 0 ;
24558 wxDateTime *arg2 = (wxDateTime *) 0 ;
24559 bool result;
24560 PyObject * obj0 = 0 ;
24561 PyObject * obj1 = 0 ;
24562 char *kwnames[] = {
24563 (char *) "self",(char *) "other", NULL
24564 };
24565
24566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
24567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24568 if (SWIG_arg_fail(1)) SWIG_fail;
24569 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24570 if (SWIG_arg_fail(2)) SWIG_fail;
24571 {
24572 PyThreadState* __tstate = wxPyBeginAllowThreads();
24573 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
24574
24575 wxPyEndAllowThreads(__tstate);
24576 if (PyErr_Occurred()) SWIG_fail;
24577 }
24578 {
24579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24580 }
24581 return resultobj;
24582 fail:
24583 return NULL;
24584 }
24585
24586
24587 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24588 PyObject *resultobj = NULL;
24589 wxDateTime *arg1 = (wxDateTime *) 0 ;
24590 wxDateTime *arg2 = (wxDateTime *) 0 ;
24591 bool result;
24592 PyObject * obj0 = 0 ;
24593 PyObject * obj1 = 0 ;
24594 char *kwnames[] = {
24595 (char *) "self",(char *) "other", NULL
24596 };
24597
24598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
24599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24600 if (SWIG_arg_fail(1)) SWIG_fail;
24601 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24602 if (SWIG_arg_fail(2)) SWIG_fail;
24603 {
24604 PyThreadState* __tstate = wxPyBeginAllowThreads();
24605 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
24606
24607 wxPyEndAllowThreads(__tstate);
24608 if (PyErr_Occurred()) SWIG_fail;
24609 }
24610 {
24611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24612 }
24613 return resultobj;
24614 fail:
24615 return NULL;
24616 }
24617
24618
24619 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
24620 PyObject *resultobj = NULL;
24621 wxDateTime *arg1 = (wxDateTime *) 0 ;
24622 wxString *arg2 = 0 ;
24623 int result;
24624 bool temp2 = false ;
24625 PyObject * obj0 = 0 ;
24626 PyObject * obj1 = 0 ;
24627 char *kwnames[] = {
24628 (char *) "self",(char *) "date", NULL
24629 };
24630
24631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
24632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24633 if (SWIG_arg_fail(1)) SWIG_fail;
24634 {
24635 arg2 = wxString_in_helper(obj1);
24636 if (arg2 == NULL) SWIG_fail;
24637 temp2 = true;
24638 }
24639 {
24640 PyThreadState* __tstate = wxPyBeginAllowThreads();
24641 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
24642
24643 wxPyEndAllowThreads(__tstate);
24644 if (PyErr_Occurred()) SWIG_fail;
24645 }
24646 {
24647 resultobj = SWIG_From_int(static_cast<int >(result));
24648 }
24649 {
24650 if (temp2)
24651 delete arg2;
24652 }
24653 return resultobj;
24654 fail:
24655 {
24656 if (temp2)
24657 delete arg2;
24658 }
24659 return NULL;
24660 }
24661
24662
24663 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
24664 PyObject *resultobj = NULL;
24665 wxDateTime *arg1 = (wxDateTime *) 0 ;
24666 wxString *arg2 = 0 ;
24667 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
24668 wxString *arg3 = (wxString *) &arg3_defvalue ;
24669 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
24670 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
24671 int result;
24672 bool temp2 = false ;
24673 bool temp3 = false ;
24674 PyObject * obj0 = 0 ;
24675 PyObject * obj1 = 0 ;
24676 PyObject * obj2 = 0 ;
24677 PyObject * obj3 = 0 ;
24678 char *kwnames[] = {
24679 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
24680 };
24681
24682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24684 if (SWIG_arg_fail(1)) SWIG_fail;
24685 {
24686 arg2 = wxString_in_helper(obj1);
24687 if (arg2 == NULL) SWIG_fail;
24688 temp2 = true;
24689 }
24690 if (obj2) {
24691 {
24692 arg3 = wxString_in_helper(obj2);
24693 if (arg3 == NULL) SWIG_fail;
24694 temp3 = true;
24695 }
24696 }
24697 if (obj3) {
24698 {
24699 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24700 if (SWIG_arg_fail(4)) SWIG_fail;
24701 if (arg4 == NULL) {
24702 SWIG_null_ref("wxDateTime");
24703 }
24704 if (SWIG_arg_fail(4)) SWIG_fail;
24705 }
24706 }
24707 {
24708 PyThreadState* __tstate = wxPyBeginAllowThreads();
24709 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
24710
24711 wxPyEndAllowThreads(__tstate);
24712 if (PyErr_Occurred()) SWIG_fail;
24713 }
24714 {
24715 resultobj = SWIG_From_int(static_cast<int >(result));
24716 }
24717 {
24718 if (temp2)
24719 delete arg2;
24720 }
24721 {
24722 if (temp3)
24723 delete arg3;
24724 }
24725 return resultobj;
24726 fail:
24727 {
24728 if (temp2)
24729 delete arg2;
24730 }
24731 {
24732 if (temp3)
24733 delete arg3;
24734 }
24735 return NULL;
24736 }
24737
24738
24739 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
24740 PyObject *resultobj = NULL;
24741 wxDateTime *arg1 = (wxDateTime *) 0 ;
24742 wxString *arg2 = 0 ;
24743 int result;
24744 bool temp2 = false ;
24745 PyObject * obj0 = 0 ;
24746 PyObject * obj1 = 0 ;
24747 char *kwnames[] = {
24748 (char *) "self",(char *) "datetime", NULL
24749 };
24750
24751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
24752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24753 if (SWIG_arg_fail(1)) SWIG_fail;
24754 {
24755 arg2 = wxString_in_helper(obj1);
24756 if (arg2 == NULL) SWIG_fail;
24757 temp2 = true;
24758 }
24759 {
24760 PyThreadState* __tstate = wxPyBeginAllowThreads();
24761 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
24762
24763 wxPyEndAllowThreads(__tstate);
24764 if (PyErr_Occurred()) SWIG_fail;
24765 }
24766 {
24767 resultobj = SWIG_From_int(static_cast<int >(result));
24768 }
24769 {
24770 if (temp2)
24771 delete arg2;
24772 }
24773 return resultobj;
24774 fail:
24775 {
24776 if (temp2)
24777 delete arg2;
24778 }
24779 return NULL;
24780 }
24781
24782
24783 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
24784 PyObject *resultobj = NULL;
24785 wxDateTime *arg1 = (wxDateTime *) 0 ;
24786 wxString *arg2 = 0 ;
24787 int result;
24788 bool temp2 = false ;
24789 PyObject * obj0 = 0 ;
24790 PyObject * obj1 = 0 ;
24791 char *kwnames[] = {
24792 (char *) "self",(char *) "date", NULL
24793 };
24794
24795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
24796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24797 if (SWIG_arg_fail(1)) SWIG_fail;
24798 {
24799 arg2 = wxString_in_helper(obj1);
24800 if (arg2 == NULL) SWIG_fail;
24801 temp2 = true;
24802 }
24803 {
24804 PyThreadState* __tstate = wxPyBeginAllowThreads();
24805 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
24806
24807 wxPyEndAllowThreads(__tstate);
24808 if (PyErr_Occurred()) SWIG_fail;
24809 }
24810 {
24811 resultobj = SWIG_From_int(static_cast<int >(result));
24812 }
24813 {
24814 if (temp2)
24815 delete arg2;
24816 }
24817 return resultobj;
24818 fail:
24819 {
24820 if (temp2)
24821 delete arg2;
24822 }
24823 return NULL;
24824 }
24825
24826
24827 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
24828 PyObject *resultobj = NULL;
24829 wxDateTime *arg1 = (wxDateTime *) 0 ;
24830 wxString *arg2 = 0 ;
24831 int result;
24832 bool temp2 = false ;
24833 PyObject * obj0 = 0 ;
24834 PyObject * obj1 = 0 ;
24835 char *kwnames[] = {
24836 (char *) "self",(char *) "time", NULL
24837 };
24838
24839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
24840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24841 if (SWIG_arg_fail(1)) SWIG_fail;
24842 {
24843 arg2 = wxString_in_helper(obj1);
24844 if (arg2 == NULL) SWIG_fail;
24845 temp2 = true;
24846 }
24847 {
24848 PyThreadState* __tstate = wxPyBeginAllowThreads();
24849 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
24850
24851 wxPyEndAllowThreads(__tstate);
24852 if (PyErr_Occurred()) SWIG_fail;
24853 }
24854 {
24855 resultobj = SWIG_From_int(static_cast<int >(result));
24856 }
24857 {
24858 if (temp2)
24859 delete arg2;
24860 }
24861 return resultobj;
24862 fail:
24863 {
24864 if (temp2)
24865 delete arg2;
24866 }
24867 return NULL;
24868 }
24869
24870
24871 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
24872 PyObject *resultobj = NULL;
24873 wxDateTime *arg1 = (wxDateTime *) 0 ;
24874 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
24875 wxString *arg2 = (wxString *) &arg2_defvalue ;
24876 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
24877 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
24878 wxString result;
24879 bool temp2 = false ;
24880 bool temp3 = false ;
24881 PyObject * obj0 = 0 ;
24882 PyObject * obj1 = 0 ;
24883 PyObject * obj2 = 0 ;
24884 char *kwnames[] = {
24885 (char *) "self",(char *) "format",(char *) "tz", NULL
24886 };
24887
24888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
24889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24890 if (SWIG_arg_fail(1)) SWIG_fail;
24891 if (obj1) {
24892 {
24893 arg2 = wxString_in_helper(obj1);
24894 if (arg2 == NULL) SWIG_fail;
24895 temp2 = true;
24896 }
24897 }
24898 if (obj2) {
24899 {
24900 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
24901 temp3 = true;
24902 }
24903 }
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
24907
24908 wxPyEndAllowThreads(__tstate);
24909 if (PyErr_Occurred()) SWIG_fail;
24910 }
24911 {
24912 #if wxUSE_UNICODE
24913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24914 #else
24915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24916 #endif
24917 }
24918 {
24919 if (temp2)
24920 delete arg2;
24921 }
24922 {
24923 if (temp3) delete arg3;
24924 }
24925 return resultobj;
24926 fail:
24927 {
24928 if (temp2)
24929 delete arg2;
24930 }
24931 {
24932 if (temp3) delete arg3;
24933 }
24934 return NULL;
24935 }
24936
24937
24938 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
24939 PyObject *resultobj = NULL;
24940 wxDateTime *arg1 = (wxDateTime *) 0 ;
24941 wxString result;
24942 PyObject * obj0 = 0 ;
24943 char *kwnames[] = {
24944 (char *) "self", NULL
24945 };
24946
24947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
24948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24949 if (SWIG_arg_fail(1)) SWIG_fail;
24950 {
24951 PyThreadState* __tstate = wxPyBeginAllowThreads();
24952 result = ((wxDateTime const *)arg1)->FormatDate();
24953
24954 wxPyEndAllowThreads(__tstate);
24955 if (PyErr_Occurred()) SWIG_fail;
24956 }
24957 {
24958 #if wxUSE_UNICODE
24959 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24960 #else
24961 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24962 #endif
24963 }
24964 return resultobj;
24965 fail:
24966 return NULL;
24967 }
24968
24969
24970 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
24971 PyObject *resultobj = NULL;
24972 wxDateTime *arg1 = (wxDateTime *) 0 ;
24973 wxString result;
24974 PyObject * obj0 = 0 ;
24975 char *kwnames[] = {
24976 (char *) "self", NULL
24977 };
24978
24979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
24980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24981 if (SWIG_arg_fail(1)) SWIG_fail;
24982 {
24983 PyThreadState* __tstate = wxPyBeginAllowThreads();
24984 result = ((wxDateTime const *)arg1)->FormatTime();
24985
24986 wxPyEndAllowThreads(__tstate);
24987 if (PyErr_Occurred()) SWIG_fail;
24988 }
24989 {
24990 #if wxUSE_UNICODE
24991 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24992 #else
24993 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24994 #endif
24995 }
24996 return resultobj;
24997 fail:
24998 return NULL;
24999 }
25000
25001
25002 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
25003 PyObject *resultobj = NULL;
25004 wxDateTime *arg1 = (wxDateTime *) 0 ;
25005 wxString result;
25006 PyObject * obj0 = 0 ;
25007 char *kwnames[] = {
25008 (char *) "self", NULL
25009 };
25010
25011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
25012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
25013 if (SWIG_arg_fail(1)) SWIG_fail;
25014 {
25015 PyThreadState* __tstate = wxPyBeginAllowThreads();
25016 result = ((wxDateTime const *)arg1)->FormatISODate();
25017
25018 wxPyEndAllowThreads(__tstate);
25019 if (PyErr_Occurred()) SWIG_fail;
25020 }
25021 {
25022 #if wxUSE_UNICODE
25023 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25024 #else
25025 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25026 #endif
25027 }
25028 return resultobj;
25029 fail:
25030 return NULL;
25031 }
25032
25033
25034 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
25035 PyObject *resultobj = NULL;
25036 wxDateTime *arg1 = (wxDateTime *) 0 ;
25037 wxString result;
25038 PyObject * obj0 = 0 ;
25039 char *kwnames[] = {
25040 (char *) "self", NULL
25041 };
25042
25043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
25044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
25045 if (SWIG_arg_fail(1)) SWIG_fail;
25046 {
25047 PyThreadState* __tstate = wxPyBeginAllowThreads();
25048 result = ((wxDateTime const *)arg1)->FormatISOTime();
25049
25050 wxPyEndAllowThreads(__tstate);
25051 if (PyErr_Occurred()) SWIG_fail;
25052 }
25053 {
25054 #if wxUSE_UNICODE
25055 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25056 #else
25057 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25058 #endif
25059 }
25060 return resultobj;
25061 fail:
25062 return NULL;
25063 }
25064
25065
25066 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
25067 PyObject *obj;
25068 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25069 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
25070 Py_INCREF(obj);
25071 return Py_BuildValue((char *)"");
25072 }
25073 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
25074 PyObject *resultobj = NULL;
25075 long arg1 ;
25076 wxTimeSpan result;
25077 PyObject * obj0 = 0 ;
25078 char *kwnames[] = {
25079 (char *) "sec", NULL
25080 };
25081
25082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
25083 {
25084 arg1 = static_cast<long >(SWIG_As_long(obj0));
25085 if (SWIG_arg_fail(1)) SWIG_fail;
25086 }
25087 {
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 result = wxTimeSpan::Seconds(arg1);
25090
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 {
25095 wxTimeSpan * resultptr;
25096 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25097 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25098 }
25099 return resultobj;
25100 fail:
25101 return NULL;
25102 }
25103
25104
25105 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
25106 PyObject *resultobj = NULL;
25107 wxTimeSpan result;
25108 char *kwnames[] = {
25109 NULL
25110 };
25111
25112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
25113 {
25114 PyThreadState* __tstate = wxPyBeginAllowThreads();
25115 result = wxTimeSpan::Second();
25116
25117 wxPyEndAllowThreads(__tstate);
25118 if (PyErr_Occurred()) SWIG_fail;
25119 }
25120 {
25121 wxTimeSpan * resultptr;
25122 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25123 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25124 }
25125 return resultobj;
25126 fail:
25127 return NULL;
25128 }
25129
25130
25131 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
25132 PyObject *resultobj = NULL;
25133 long arg1 ;
25134 wxTimeSpan result;
25135 PyObject * obj0 = 0 ;
25136 char *kwnames[] = {
25137 (char *) "min", NULL
25138 };
25139
25140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
25141 {
25142 arg1 = static_cast<long >(SWIG_As_long(obj0));
25143 if (SWIG_arg_fail(1)) SWIG_fail;
25144 }
25145 {
25146 PyThreadState* __tstate = wxPyBeginAllowThreads();
25147 result = wxTimeSpan::Minutes(arg1);
25148
25149 wxPyEndAllowThreads(__tstate);
25150 if (PyErr_Occurred()) SWIG_fail;
25151 }
25152 {
25153 wxTimeSpan * resultptr;
25154 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25155 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25156 }
25157 return resultobj;
25158 fail:
25159 return NULL;
25160 }
25161
25162
25163 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
25164 PyObject *resultobj = NULL;
25165 wxTimeSpan result;
25166 char *kwnames[] = {
25167 NULL
25168 };
25169
25170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
25171 {
25172 PyThreadState* __tstate = wxPyBeginAllowThreads();
25173 result = wxTimeSpan::Minute();
25174
25175 wxPyEndAllowThreads(__tstate);
25176 if (PyErr_Occurred()) SWIG_fail;
25177 }
25178 {
25179 wxTimeSpan * resultptr;
25180 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25181 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25182 }
25183 return resultobj;
25184 fail:
25185 return NULL;
25186 }
25187
25188
25189 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
25190 PyObject *resultobj = NULL;
25191 long arg1 ;
25192 wxTimeSpan result;
25193 PyObject * obj0 = 0 ;
25194 char *kwnames[] = {
25195 (char *) "hours", NULL
25196 };
25197
25198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
25199 {
25200 arg1 = static_cast<long >(SWIG_As_long(obj0));
25201 if (SWIG_arg_fail(1)) SWIG_fail;
25202 }
25203 {
25204 PyThreadState* __tstate = wxPyBeginAllowThreads();
25205 result = wxTimeSpan::Hours(arg1);
25206
25207 wxPyEndAllowThreads(__tstate);
25208 if (PyErr_Occurred()) SWIG_fail;
25209 }
25210 {
25211 wxTimeSpan * resultptr;
25212 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25213 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25214 }
25215 return resultobj;
25216 fail:
25217 return NULL;
25218 }
25219
25220
25221 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
25222 PyObject *resultobj = NULL;
25223 wxTimeSpan result;
25224 char *kwnames[] = {
25225 NULL
25226 };
25227
25228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
25229 {
25230 PyThreadState* __tstate = wxPyBeginAllowThreads();
25231 result = wxTimeSpan::Hour();
25232
25233 wxPyEndAllowThreads(__tstate);
25234 if (PyErr_Occurred()) SWIG_fail;
25235 }
25236 {
25237 wxTimeSpan * resultptr;
25238 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25239 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25240 }
25241 return resultobj;
25242 fail:
25243 return NULL;
25244 }
25245
25246
25247 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25248 PyObject *resultobj = NULL;
25249 long arg1 ;
25250 wxTimeSpan result;
25251 PyObject * obj0 = 0 ;
25252 char *kwnames[] = {
25253 (char *) "days", NULL
25254 };
25255
25256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
25257 {
25258 arg1 = static_cast<long >(SWIG_As_long(obj0));
25259 if (SWIG_arg_fail(1)) SWIG_fail;
25260 }
25261 {
25262 PyThreadState* __tstate = wxPyBeginAllowThreads();
25263 result = wxTimeSpan::Days(arg1);
25264
25265 wxPyEndAllowThreads(__tstate);
25266 if (PyErr_Occurred()) SWIG_fail;
25267 }
25268 {
25269 wxTimeSpan * resultptr;
25270 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25271 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25272 }
25273 return resultobj;
25274 fail:
25275 return NULL;
25276 }
25277
25278
25279 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25280 PyObject *resultobj = NULL;
25281 wxTimeSpan result;
25282 char *kwnames[] = {
25283 NULL
25284 };
25285
25286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
25287 {
25288 PyThreadState* __tstate = wxPyBeginAllowThreads();
25289 result = wxTimeSpan::Day();
25290
25291 wxPyEndAllowThreads(__tstate);
25292 if (PyErr_Occurred()) SWIG_fail;
25293 }
25294 {
25295 wxTimeSpan * resultptr;
25296 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25297 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25298 }
25299 return resultobj;
25300 fail:
25301 return NULL;
25302 }
25303
25304
25305 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25306 PyObject *resultobj = NULL;
25307 long arg1 ;
25308 wxTimeSpan result;
25309 PyObject * obj0 = 0 ;
25310 char *kwnames[] = {
25311 (char *) "days", NULL
25312 };
25313
25314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
25315 {
25316 arg1 = static_cast<long >(SWIG_As_long(obj0));
25317 if (SWIG_arg_fail(1)) SWIG_fail;
25318 }
25319 {
25320 PyThreadState* __tstate = wxPyBeginAllowThreads();
25321 result = wxTimeSpan::Weeks(arg1);
25322
25323 wxPyEndAllowThreads(__tstate);
25324 if (PyErr_Occurred()) SWIG_fail;
25325 }
25326 {
25327 wxTimeSpan * resultptr;
25328 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25329 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25330 }
25331 return resultobj;
25332 fail:
25333 return NULL;
25334 }
25335
25336
25337 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25338 PyObject *resultobj = NULL;
25339 wxTimeSpan result;
25340 char *kwnames[] = {
25341 NULL
25342 };
25343
25344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
25345 {
25346 PyThreadState* __tstate = wxPyBeginAllowThreads();
25347 result = wxTimeSpan::Week();
25348
25349 wxPyEndAllowThreads(__tstate);
25350 if (PyErr_Occurred()) SWIG_fail;
25351 }
25352 {
25353 wxTimeSpan * resultptr;
25354 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25355 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25356 }
25357 return resultobj;
25358 fail:
25359 return NULL;
25360 }
25361
25362
25363 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25364 PyObject *resultobj = NULL;
25365 long arg1 = (long) 0 ;
25366 long arg2 = (long) 0 ;
25367 long arg3 = (long) 0 ;
25368 long arg4 = (long) 0 ;
25369 wxTimeSpan *result;
25370 PyObject * obj0 = 0 ;
25371 PyObject * obj1 = 0 ;
25372 PyObject * obj2 = 0 ;
25373 PyObject * obj3 = 0 ;
25374 char *kwnames[] = {
25375 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
25376 };
25377
25378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25379 if (obj0) {
25380 {
25381 arg1 = static_cast<long >(SWIG_As_long(obj0));
25382 if (SWIG_arg_fail(1)) SWIG_fail;
25383 }
25384 }
25385 if (obj1) {
25386 {
25387 arg2 = static_cast<long >(SWIG_As_long(obj1));
25388 if (SWIG_arg_fail(2)) SWIG_fail;
25389 }
25390 }
25391 if (obj2) {
25392 {
25393 arg3 = static_cast<long >(SWIG_As_long(obj2));
25394 if (SWIG_arg_fail(3)) SWIG_fail;
25395 }
25396 }
25397 if (obj3) {
25398 {
25399 arg4 = static_cast<long >(SWIG_As_long(obj3));
25400 if (SWIG_arg_fail(4)) SWIG_fail;
25401 }
25402 }
25403 {
25404 PyThreadState* __tstate = wxPyBeginAllowThreads();
25405 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
25406
25407 wxPyEndAllowThreads(__tstate);
25408 if (PyErr_Occurred()) SWIG_fail;
25409 }
25410 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
25411 return resultobj;
25412 fail:
25413 return NULL;
25414 }
25415
25416
25417 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25418 PyObject *resultobj = NULL;
25419 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25420 PyObject * obj0 = 0 ;
25421 char *kwnames[] = {
25422 (char *) "self", NULL
25423 };
25424
25425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
25426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25427 if (SWIG_arg_fail(1)) SWIG_fail;
25428 {
25429 PyThreadState* __tstate = wxPyBeginAllowThreads();
25430 delete arg1;
25431
25432 wxPyEndAllowThreads(__tstate);
25433 if (PyErr_Occurred()) SWIG_fail;
25434 }
25435 Py_INCREF(Py_None); resultobj = Py_None;
25436 return resultobj;
25437 fail:
25438 return NULL;
25439 }
25440
25441
25442 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25443 PyObject *resultobj = NULL;
25444 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25445 wxTimeSpan *arg2 = 0 ;
25446 wxTimeSpan *result;
25447 PyObject * obj0 = 0 ;
25448 PyObject * obj1 = 0 ;
25449 char *kwnames[] = {
25450 (char *) "self",(char *) "diff", NULL
25451 };
25452
25453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25455 if (SWIG_arg_fail(1)) SWIG_fail;
25456 {
25457 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25458 if (SWIG_arg_fail(2)) SWIG_fail;
25459 if (arg2 == NULL) {
25460 SWIG_null_ref("wxTimeSpan");
25461 }
25462 if (SWIG_arg_fail(2)) SWIG_fail;
25463 }
25464 {
25465 PyThreadState* __tstate = wxPyBeginAllowThreads();
25466 {
25467 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25468 result = (wxTimeSpan *) &_result_ref;
25469 }
25470
25471 wxPyEndAllowThreads(__tstate);
25472 if (PyErr_Occurred()) SWIG_fail;
25473 }
25474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25475 return resultobj;
25476 fail:
25477 return NULL;
25478 }
25479
25480
25481 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25482 PyObject *resultobj = NULL;
25483 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25484 wxTimeSpan *arg2 = 0 ;
25485 wxTimeSpan *result;
25486 PyObject * obj0 = 0 ;
25487 PyObject * obj1 = 0 ;
25488 char *kwnames[] = {
25489 (char *) "self",(char *) "diff", NULL
25490 };
25491
25492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25494 if (SWIG_arg_fail(1)) SWIG_fail;
25495 {
25496 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25497 if (SWIG_arg_fail(2)) SWIG_fail;
25498 if (arg2 == NULL) {
25499 SWIG_null_ref("wxTimeSpan");
25500 }
25501 if (SWIG_arg_fail(2)) SWIG_fail;
25502 }
25503 {
25504 PyThreadState* __tstate = wxPyBeginAllowThreads();
25505 {
25506 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
25507 result = (wxTimeSpan *) &_result_ref;
25508 }
25509
25510 wxPyEndAllowThreads(__tstate);
25511 if (PyErr_Occurred()) SWIG_fail;
25512 }
25513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25514 return resultobj;
25515 fail:
25516 return NULL;
25517 }
25518
25519
25520 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25521 PyObject *resultobj = NULL;
25522 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25523 int arg2 ;
25524 wxTimeSpan *result;
25525 PyObject * obj0 = 0 ;
25526 PyObject * obj1 = 0 ;
25527 char *kwnames[] = {
25528 (char *) "self",(char *) "n", NULL
25529 };
25530
25531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25533 if (SWIG_arg_fail(1)) SWIG_fail;
25534 {
25535 arg2 = static_cast<int >(SWIG_As_int(obj1));
25536 if (SWIG_arg_fail(2)) SWIG_fail;
25537 }
25538 {
25539 PyThreadState* __tstate = wxPyBeginAllowThreads();
25540 {
25541 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
25542 result = (wxTimeSpan *) &_result_ref;
25543 }
25544
25545 wxPyEndAllowThreads(__tstate);
25546 if (PyErr_Occurred()) SWIG_fail;
25547 }
25548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25549 return resultobj;
25550 fail:
25551 return NULL;
25552 }
25553
25554
25555 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25556 PyObject *resultobj = NULL;
25557 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25558 wxTimeSpan *result;
25559 PyObject * obj0 = 0 ;
25560 char *kwnames[] = {
25561 (char *) "self", NULL
25562 };
25563
25564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
25565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25566 if (SWIG_arg_fail(1)) SWIG_fail;
25567 {
25568 PyThreadState* __tstate = wxPyBeginAllowThreads();
25569 {
25570 wxTimeSpan &_result_ref = (arg1)->Neg();
25571 result = (wxTimeSpan *) &_result_ref;
25572 }
25573
25574 wxPyEndAllowThreads(__tstate);
25575 if (PyErr_Occurred()) SWIG_fail;
25576 }
25577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25578 return resultobj;
25579 fail:
25580 return NULL;
25581 }
25582
25583
25584 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
25585 PyObject *resultobj = NULL;
25586 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25587 wxTimeSpan result;
25588 PyObject * obj0 = 0 ;
25589 char *kwnames[] = {
25590 (char *) "self", NULL
25591 };
25592
25593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
25594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25595 if (SWIG_arg_fail(1)) SWIG_fail;
25596 {
25597 PyThreadState* __tstate = wxPyBeginAllowThreads();
25598 result = ((wxTimeSpan const *)arg1)->Abs();
25599
25600 wxPyEndAllowThreads(__tstate);
25601 if (PyErr_Occurred()) SWIG_fail;
25602 }
25603 {
25604 wxTimeSpan * resultptr;
25605 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25606 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25607 }
25608 return resultobj;
25609 fail:
25610 return NULL;
25611 }
25612
25613
25614 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25615 PyObject *resultobj = NULL;
25616 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25617 wxTimeSpan *arg2 = 0 ;
25618 wxTimeSpan *result;
25619 PyObject * obj0 = 0 ;
25620 PyObject * obj1 = 0 ;
25621 char *kwnames[] = {
25622 (char *) "self",(char *) "diff", NULL
25623 };
25624
25625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25627 if (SWIG_arg_fail(1)) SWIG_fail;
25628 {
25629 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25630 if (SWIG_arg_fail(2)) SWIG_fail;
25631 if (arg2 == NULL) {
25632 SWIG_null_ref("wxTimeSpan");
25633 }
25634 if (SWIG_arg_fail(2)) SWIG_fail;
25635 }
25636 {
25637 PyThreadState* __tstate = wxPyBeginAllowThreads();
25638 {
25639 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
25640 result = (wxTimeSpan *) &_result_ref;
25641 }
25642
25643 wxPyEndAllowThreads(__tstate);
25644 if (PyErr_Occurred()) SWIG_fail;
25645 }
25646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
25647 return resultobj;
25648 fail:
25649 return NULL;
25650 }
25651
25652
25653 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25654 PyObject *resultobj = NULL;
25655 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25656 wxTimeSpan *arg2 = 0 ;
25657 wxTimeSpan *result;
25658 PyObject * obj0 = 0 ;
25659 PyObject * obj1 = 0 ;
25660 char *kwnames[] = {
25661 (char *) "self",(char *) "diff", NULL
25662 };
25663
25664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25666 if (SWIG_arg_fail(1)) SWIG_fail;
25667 {
25668 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25669 if (SWIG_arg_fail(2)) SWIG_fail;
25670 if (arg2 == NULL) {
25671 SWIG_null_ref("wxTimeSpan");
25672 }
25673 if (SWIG_arg_fail(2)) SWIG_fail;
25674 }
25675 {
25676 PyThreadState* __tstate = wxPyBeginAllowThreads();
25677 {
25678 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
25679 result = (wxTimeSpan *) &_result_ref;
25680 }
25681
25682 wxPyEndAllowThreads(__tstate);
25683 if (PyErr_Occurred()) SWIG_fail;
25684 }
25685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
25686 return resultobj;
25687 fail:
25688 return NULL;
25689 }
25690
25691
25692 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
25693 PyObject *resultobj = NULL;
25694 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25695 int arg2 ;
25696 wxTimeSpan *result;
25697 PyObject * obj0 = 0 ;
25698 PyObject * obj1 = 0 ;
25699 char *kwnames[] = {
25700 (char *) "self",(char *) "n", NULL
25701 };
25702
25703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
25704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25705 if (SWIG_arg_fail(1)) SWIG_fail;
25706 {
25707 arg2 = static_cast<int >(SWIG_As_int(obj1));
25708 if (SWIG_arg_fail(2)) SWIG_fail;
25709 }
25710 {
25711 PyThreadState* __tstate = wxPyBeginAllowThreads();
25712 {
25713 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
25714 result = (wxTimeSpan *) &_result_ref;
25715 }
25716
25717 wxPyEndAllowThreads(__tstate);
25718 if (PyErr_Occurred()) SWIG_fail;
25719 }
25720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
25721 return resultobj;
25722 fail:
25723 return NULL;
25724 }
25725
25726
25727 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25728 PyObject *resultobj = NULL;
25729 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25730 wxTimeSpan *result;
25731 PyObject * obj0 = 0 ;
25732 char *kwnames[] = {
25733 (char *) "self", NULL
25734 };
25735
25736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
25737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25738 if (SWIG_arg_fail(1)) SWIG_fail;
25739 {
25740 PyThreadState* __tstate = wxPyBeginAllowThreads();
25741 {
25742 wxTimeSpan &_result_ref = (arg1)->operator -();
25743 result = (wxTimeSpan *) &_result_ref;
25744 }
25745
25746 wxPyEndAllowThreads(__tstate);
25747 if (PyErr_Occurred()) SWIG_fail;
25748 }
25749 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25750 return resultobj;
25751 fail:
25752 return NULL;
25753 }
25754
25755
25756 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
25757 PyObject *resultobj = NULL;
25758 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25759 wxTimeSpan *arg2 = 0 ;
25760 wxTimeSpan result;
25761 PyObject * obj0 = 0 ;
25762 PyObject * obj1 = 0 ;
25763 char *kwnames[] = {
25764 (char *) "self",(char *) "other", NULL
25765 };
25766
25767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
25768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25769 if (SWIG_arg_fail(1)) SWIG_fail;
25770 {
25771 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25772 if (SWIG_arg_fail(2)) SWIG_fail;
25773 if (arg2 == NULL) {
25774 SWIG_null_ref("wxTimeSpan");
25775 }
25776 if (SWIG_arg_fail(2)) SWIG_fail;
25777 }
25778 {
25779 PyThreadState* __tstate = wxPyBeginAllowThreads();
25780 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
25781
25782 wxPyEndAllowThreads(__tstate);
25783 if (PyErr_Occurred()) SWIG_fail;
25784 }
25785 {
25786 wxTimeSpan * resultptr;
25787 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25788 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25789 }
25790 return resultobj;
25791 fail:
25792 return NULL;
25793 }
25794
25795
25796 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
25797 PyObject *resultobj = NULL;
25798 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25799 wxTimeSpan *arg2 = 0 ;
25800 wxTimeSpan result;
25801 PyObject * obj0 = 0 ;
25802 PyObject * obj1 = 0 ;
25803 char *kwnames[] = {
25804 (char *) "self",(char *) "other", NULL
25805 };
25806
25807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
25808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25809 if (SWIG_arg_fail(1)) SWIG_fail;
25810 {
25811 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25812 if (SWIG_arg_fail(2)) SWIG_fail;
25813 if (arg2 == NULL) {
25814 SWIG_null_ref("wxTimeSpan");
25815 }
25816 if (SWIG_arg_fail(2)) SWIG_fail;
25817 }
25818 {
25819 PyThreadState* __tstate = wxPyBeginAllowThreads();
25820 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
25821
25822 wxPyEndAllowThreads(__tstate);
25823 if (PyErr_Occurred()) SWIG_fail;
25824 }
25825 {
25826 wxTimeSpan * resultptr;
25827 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25828 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25829 }
25830 return resultobj;
25831 fail:
25832 return NULL;
25833 }
25834
25835
25836 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
25837 PyObject *resultobj = NULL;
25838 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25839 int arg2 ;
25840 wxTimeSpan result;
25841 PyObject * obj0 = 0 ;
25842 PyObject * obj1 = 0 ;
25843 char *kwnames[] = {
25844 (char *) "self",(char *) "n", NULL
25845 };
25846
25847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
25848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25849 if (SWIG_arg_fail(1)) SWIG_fail;
25850 {
25851 arg2 = static_cast<int >(SWIG_As_int(obj1));
25852 if (SWIG_arg_fail(2)) SWIG_fail;
25853 }
25854 {
25855 PyThreadState* __tstate = wxPyBeginAllowThreads();
25856 result = wxTimeSpan___mul__(arg1,arg2);
25857
25858 wxPyEndAllowThreads(__tstate);
25859 if (PyErr_Occurred()) SWIG_fail;
25860 }
25861 {
25862 wxTimeSpan * resultptr;
25863 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25864 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25865 }
25866 return resultobj;
25867 fail:
25868 return NULL;
25869 }
25870
25871
25872 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
25873 PyObject *resultobj = NULL;
25874 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25875 int arg2 ;
25876 wxTimeSpan result;
25877 PyObject * obj0 = 0 ;
25878 PyObject * obj1 = 0 ;
25879 char *kwnames[] = {
25880 (char *) "self",(char *) "n", NULL
25881 };
25882
25883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
25884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25885 if (SWIG_arg_fail(1)) SWIG_fail;
25886 {
25887 arg2 = static_cast<int >(SWIG_As_int(obj1));
25888 if (SWIG_arg_fail(2)) SWIG_fail;
25889 }
25890 {
25891 PyThreadState* __tstate = wxPyBeginAllowThreads();
25892 result = wxTimeSpan___rmul__(arg1,arg2);
25893
25894 wxPyEndAllowThreads(__tstate);
25895 if (PyErr_Occurred()) SWIG_fail;
25896 }
25897 {
25898 wxTimeSpan * resultptr;
25899 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25900 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25901 }
25902 return resultobj;
25903 fail:
25904 return NULL;
25905 }
25906
25907
25908 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
25909 PyObject *resultobj = NULL;
25910 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25911 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25912 bool result;
25913 PyObject * obj0 = 0 ;
25914 PyObject * obj1 = 0 ;
25915 char *kwnames[] = {
25916 (char *) "self",(char *) "other", NULL
25917 };
25918
25919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
25920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25921 if (SWIG_arg_fail(1)) SWIG_fail;
25922 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25923 if (SWIG_arg_fail(2)) SWIG_fail;
25924 {
25925 PyThreadState* __tstate = wxPyBeginAllowThreads();
25926 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
25927
25928 wxPyEndAllowThreads(__tstate);
25929 if (PyErr_Occurred()) SWIG_fail;
25930 }
25931 {
25932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25933 }
25934 return resultobj;
25935 fail:
25936 return NULL;
25937 }
25938
25939
25940 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
25941 PyObject *resultobj = NULL;
25942 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25943 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25944 bool result;
25945 PyObject * obj0 = 0 ;
25946 PyObject * obj1 = 0 ;
25947 char *kwnames[] = {
25948 (char *) "self",(char *) "other", NULL
25949 };
25950
25951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
25952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25953 if (SWIG_arg_fail(1)) SWIG_fail;
25954 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25955 if (SWIG_arg_fail(2)) SWIG_fail;
25956 {
25957 PyThreadState* __tstate = wxPyBeginAllowThreads();
25958 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
25959
25960 wxPyEndAllowThreads(__tstate);
25961 if (PyErr_Occurred()) SWIG_fail;
25962 }
25963 {
25964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25965 }
25966 return resultobj;
25967 fail:
25968 return NULL;
25969 }
25970
25971
25972 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
25973 PyObject *resultobj = NULL;
25974 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25975 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25976 bool result;
25977 PyObject * obj0 = 0 ;
25978 PyObject * obj1 = 0 ;
25979 char *kwnames[] = {
25980 (char *) "self",(char *) "other", NULL
25981 };
25982
25983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
25984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25985 if (SWIG_arg_fail(1)) SWIG_fail;
25986 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25987 if (SWIG_arg_fail(2)) SWIG_fail;
25988 {
25989 PyThreadState* __tstate = wxPyBeginAllowThreads();
25990 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
25991
25992 wxPyEndAllowThreads(__tstate);
25993 if (PyErr_Occurred()) SWIG_fail;
25994 }
25995 {
25996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25997 }
25998 return resultobj;
25999 fail:
26000 return NULL;
26001 }
26002
26003
26004 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
26005 PyObject *resultobj = NULL;
26006 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26007 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
26008 bool result;
26009 PyObject * obj0 = 0 ;
26010 PyObject * obj1 = 0 ;
26011 char *kwnames[] = {
26012 (char *) "self",(char *) "other", NULL
26013 };
26014
26015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
26016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26017 if (SWIG_arg_fail(1)) SWIG_fail;
26018 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26019 if (SWIG_arg_fail(2)) SWIG_fail;
26020 {
26021 PyThreadState* __tstate = wxPyBeginAllowThreads();
26022 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
26023
26024 wxPyEndAllowThreads(__tstate);
26025 if (PyErr_Occurred()) SWIG_fail;
26026 }
26027 {
26028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26029 }
26030 return resultobj;
26031 fail:
26032 return NULL;
26033 }
26034
26035
26036 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26037 PyObject *resultobj = NULL;
26038 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26039 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
26040 bool result;
26041 PyObject * obj0 = 0 ;
26042 PyObject * obj1 = 0 ;
26043 char *kwnames[] = {
26044 (char *) "self",(char *) "other", NULL
26045 };
26046
26047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26049 if (SWIG_arg_fail(1)) SWIG_fail;
26050 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26051 if (SWIG_arg_fail(2)) SWIG_fail;
26052 {
26053 PyThreadState* __tstate = wxPyBeginAllowThreads();
26054 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
26055
26056 wxPyEndAllowThreads(__tstate);
26057 if (PyErr_Occurred()) SWIG_fail;
26058 }
26059 {
26060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26061 }
26062 return resultobj;
26063 fail:
26064 return NULL;
26065 }
26066
26067
26068 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26069 PyObject *resultobj = NULL;
26070 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26071 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
26072 bool result;
26073 PyObject * obj0 = 0 ;
26074 PyObject * obj1 = 0 ;
26075 char *kwnames[] = {
26076 (char *) "self",(char *) "other", NULL
26077 };
26078
26079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26081 if (SWIG_arg_fail(1)) SWIG_fail;
26082 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26083 if (SWIG_arg_fail(2)) SWIG_fail;
26084 {
26085 PyThreadState* __tstate = wxPyBeginAllowThreads();
26086 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
26087
26088 wxPyEndAllowThreads(__tstate);
26089 if (PyErr_Occurred()) SWIG_fail;
26090 }
26091 {
26092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26093 }
26094 return resultobj;
26095 fail:
26096 return NULL;
26097 }
26098
26099
26100 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
26101 PyObject *resultobj = NULL;
26102 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26103 bool result;
26104 PyObject * obj0 = 0 ;
26105 char *kwnames[] = {
26106 (char *) "self", NULL
26107 };
26108
26109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
26110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26111 if (SWIG_arg_fail(1)) SWIG_fail;
26112 {
26113 PyThreadState* __tstate = wxPyBeginAllowThreads();
26114 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
26115
26116 wxPyEndAllowThreads(__tstate);
26117 if (PyErr_Occurred()) SWIG_fail;
26118 }
26119 {
26120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26121 }
26122 return resultobj;
26123 fail:
26124 return NULL;
26125 }
26126
26127
26128 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
26129 PyObject *resultobj = NULL;
26130 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26131 bool result;
26132 PyObject * obj0 = 0 ;
26133 char *kwnames[] = {
26134 (char *) "self", NULL
26135 };
26136
26137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
26138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26139 if (SWIG_arg_fail(1)) SWIG_fail;
26140 {
26141 PyThreadState* __tstate = wxPyBeginAllowThreads();
26142 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
26143
26144 wxPyEndAllowThreads(__tstate);
26145 if (PyErr_Occurred()) SWIG_fail;
26146 }
26147 {
26148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26149 }
26150 return resultobj;
26151 fail:
26152 return NULL;
26153 }
26154
26155
26156 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
26157 PyObject *resultobj = NULL;
26158 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26159 bool result;
26160 PyObject * obj0 = 0 ;
26161 char *kwnames[] = {
26162 (char *) "self", NULL
26163 };
26164
26165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
26166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26167 if (SWIG_arg_fail(1)) SWIG_fail;
26168 {
26169 PyThreadState* __tstate = wxPyBeginAllowThreads();
26170 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
26171
26172 wxPyEndAllowThreads(__tstate);
26173 if (PyErr_Occurred()) SWIG_fail;
26174 }
26175 {
26176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26177 }
26178 return resultobj;
26179 fail:
26180 return NULL;
26181 }
26182
26183
26184 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
26185 PyObject *resultobj = NULL;
26186 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26187 wxTimeSpan *arg2 = 0 ;
26188 bool result;
26189 PyObject * obj0 = 0 ;
26190 PyObject * obj1 = 0 ;
26191 char *kwnames[] = {
26192 (char *) "self",(char *) "ts", NULL
26193 };
26194
26195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
26196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26197 if (SWIG_arg_fail(1)) SWIG_fail;
26198 {
26199 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26200 if (SWIG_arg_fail(2)) SWIG_fail;
26201 if (arg2 == NULL) {
26202 SWIG_null_ref("wxTimeSpan");
26203 }
26204 if (SWIG_arg_fail(2)) SWIG_fail;
26205 }
26206 {
26207 PyThreadState* __tstate = wxPyBeginAllowThreads();
26208 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
26209
26210 wxPyEndAllowThreads(__tstate);
26211 if (PyErr_Occurred()) SWIG_fail;
26212 }
26213 {
26214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26215 }
26216 return resultobj;
26217 fail:
26218 return NULL;
26219 }
26220
26221
26222 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
26223 PyObject *resultobj = NULL;
26224 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26225 wxTimeSpan *arg2 = 0 ;
26226 bool result;
26227 PyObject * obj0 = 0 ;
26228 PyObject * obj1 = 0 ;
26229 char *kwnames[] = {
26230 (char *) "self",(char *) "ts", NULL
26231 };
26232
26233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
26234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26235 if (SWIG_arg_fail(1)) SWIG_fail;
26236 {
26237 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26238 if (SWIG_arg_fail(2)) SWIG_fail;
26239 if (arg2 == NULL) {
26240 SWIG_null_ref("wxTimeSpan");
26241 }
26242 if (SWIG_arg_fail(2)) SWIG_fail;
26243 }
26244 {
26245 PyThreadState* __tstate = wxPyBeginAllowThreads();
26246 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
26247
26248 wxPyEndAllowThreads(__tstate);
26249 if (PyErr_Occurred()) SWIG_fail;
26250 }
26251 {
26252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26253 }
26254 return resultobj;
26255 fail:
26256 return NULL;
26257 }
26258
26259
26260 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
26261 PyObject *resultobj = NULL;
26262 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26263 wxTimeSpan *arg2 = 0 ;
26264 bool result;
26265 PyObject * obj0 = 0 ;
26266 PyObject * obj1 = 0 ;
26267 char *kwnames[] = {
26268 (char *) "self",(char *) "t", NULL
26269 };
26270
26271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
26272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26273 if (SWIG_arg_fail(1)) SWIG_fail;
26274 {
26275 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26276 if (SWIG_arg_fail(2)) SWIG_fail;
26277 if (arg2 == NULL) {
26278 SWIG_null_ref("wxTimeSpan");
26279 }
26280 if (SWIG_arg_fail(2)) SWIG_fail;
26281 }
26282 {
26283 PyThreadState* __tstate = wxPyBeginAllowThreads();
26284 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
26285
26286 wxPyEndAllowThreads(__tstate);
26287 if (PyErr_Occurred()) SWIG_fail;
26288 }
26289 {
26290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26291 }
26292 return resultobj;
26293 fail:
26294 return NULL;
26295 }
26296
26297
26298 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
26299 PyObject *resultobj = NULL;
26300 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26301 int result;
26302 PyObject * obj0 = 0 ;
26303 char *kwnames[] = {
26304 (char *) "self", NULL
26305 };
26306
26307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
26308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26309 if (SWIG_arg_fail(1)) SWIG_fail;
26310 {
26311 PyThreadState* __tstate = wxPyBeginAllowThreads();
26312 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
26313
26314 wxPyEndAllowThreads(__tstate);
26315 if (PyErr_Occurred()) SWIG_fail;
26316 }
26317 {
26318 resultobj = SWIG_From_int(static_cast<int >(result));
26319 }
26320 return resultobj;
26321 fail:
26322 return NULL;
26323 }
26324
26325
26326 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
26327 PyObject *resultobj = NULL;
26328 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26329 int result;
26330 PyObject * obj0 = 0 ;
26331 char *kwnames[] = {
26332 (char *) "self", NULL
26333 };
26334
26335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
26336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26337 if (SWIG_arg_fail(1)) SWIG_fail;
26338 {
26339 PyThreadState* __tstate = wxPyBeginAllowThreads();
26340 result = (int)((wxTimeSpan const *)arg1)->GetDays();
26341
26342 wxPyEndAllowThreads(__tstate);
26343 if (PyErr_Occurred()) SWIG_fail;
26344 }
26345 {
26346 resultobj = SWIG_From_int(static_cast<int >(result));
26347 }
26348 return resultobj;
26349 fail:
26350 return NULL;
26351 }
26352
26353
26354 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
26355 PyObject *resultobj = NULL;
26356 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26357 int result;
26358 PyObject * obj0 = 0 ;
26359 char *kwnames[] = {
26360 (char *) "self", NULL
26361 };
26362
26363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
26364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26365 if (SWIG_arg_fail(1)) SWIG_fail;
26366 {
26367 PyThreadState* __tstate = wxPyBeginAllowThreads();
26368 result = (int)((wxTimeSpan const *)arg1)->GetHours();
26369
26370 wxPyEndAllowThreads(__tstate);
26371 if (PyErr_Occurred()) SWIG_fail;
26372 }
26373 {
26374 resultobj = SWIG_From_int(static_cast<int >(result));
26375 }
26376 return resultobj;
26377 fail:
26378 return NULL;
26379 }
26380
26381
26382 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
26383 PyObject *resultobj = NULL;
26384 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26385 int result;
26386 PyObject * obj0 = 0 ;
26387 char *kwnames[] = {
26388 (char *) "self", NULL
26389 };
26390
26391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
26392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26393 if (SWIG_arg_fail(1)) SWIG_fail;
26394 {
26395 PyThreadState* __tstate = wxPyBeginAllowThreads();
26396 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
26397
26398 wxPyEndAllowThreads(__tstate);
26399 if (PyErr_Occurred()) SWIG_fail;
26400 }
26401 {
26402 resultobj = SWIG_From_int(static_cast<int >(result));
26403 }
26404 return resultobj;
26405 fail:
26406 return NULL;
26407 }
26408
26409
26410 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
26411 PyObject *resultobj = NULL;
26412 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26413 wxLongLong result;
26414 PyObject * obj0 = 0 ;
26415 char *kwnames[] = {
26416 (char *) "self", NULL
26417 };
26418
26419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
26420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26421 if (SWIG_arg_fail(1)) SWIG_fail;
26422 {
26423 PyThreadState* __tstate = wxPyBeginAllowThreads();
26424 result = ((wxTimeSpan const *)arg1)->GetSeconds();
26425
26426 wxPyEndAllowThreads(__tstate);
26427 if (PyErr_Occurred()) SWIG_fail;
26428 }
26429 {
26430 PyObject *hi, *lo, *shifter, *shifted;
26431 hi = PyLong_FromLong( (&result)->GetHi() );
26432 lo = PyLong_FromLong( (&result)->GetLo() );
26433 shifter = PyLong_FromLong(32);
26434 shifted = PyNumber_Lshift(hi, shifter);
26435 resultobj = PyNumber_Or(shifted, lo);
26436 Py_DECREF(hi);
26437 Py_DECREF(lo);
26438 Py_DECREF(shifter);
26439 Py_DECREF(shifted);
26440 }
26441 return resultobj;
26442 fail:
26443 return NULL;
26444 }
26445
26446
26447 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
26448 PyObject *resultobj = NULL;
26449 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26450 wxLongLong result;
26451 PyObject * obj0 = 0 ;
26452 char *kwnames[] = {
26453 (char *) "self", NULL
26454 };
26455
26456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
26457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26458 if (SWIG_arg_fail(1)) SWIG_fail;
26459 {
26460 PyThreadState* __tstate = wxPyBeginAllowThreads();
26461 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
26462
26463 wxPyEndAllowThreads(__tstate);
26464 if (PyErr_Occurred()) SWIG_fail;
26465 }
26466 {
26467 PyObject *hi, *lo, *shifter, *shifted;
26468 hi = PyLong_FromLong( (&result)->GetHi() );
26469 lo = PyLong_FromLong( (&result)->GetLo() );
26470 shifter = PyLong_FromLong(32);
26471 shifted = PyNumber_Lshift(hi, shifter);
26472 resultobj = PyNumber_Or(shifted, lo);
26473 Py_DECREF(hi);
26474 Py_DECREF(lo);
26475 Py_DECREF(shifter);
26476 Py_DECREF(shifted);
26477 }
26478 return resultobj;
26479 fail:
26480 return NULL;
26481 }
26482
26483
26484 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
26485 PyObject *resultobj = NULL;
26486 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26487 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
26488 wxString *arg2 = (wxString *) &arg2_defvalue ;
26489 wxString result;
26490 bool temp2 = false ;
26491 PyObject * obj0 = 0 ;
26492 PyObject * obj1 = 0 ;
26493 char *kwnames[] = {
26494 (char *) "self",(char *) "format", NULL
26495 };
26496
26497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
26498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26499 if (SWIG_arg_fail(1)) SWIG_fail;
26500 if (obj1) {
26501 {
26502 arg2 = wxString_in_helper(obj1);
26503 if (arg2 == NULL) SWIG_fail;
26504 temp2 = true;
26505 }
26506 }
26507 {
26508 PyThreadState* __tstate = wxPyBeginAllowThreads();
26509 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
26510
26511 wxPyEndAllowThreads(__tstate);
26512 if (PyErr_Occurred()) SWIG_fail;
26513 }
26514 {
26515 #if wxUSE_UNICODE
26516 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26517 #else
26518 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26519 #endif
26520 }
26521 {
26522 if (temp2)
26523 delete arg2;
26524 }
26525 return resultobj;
26526 fail:
26527 {
26528 if (temp2)
26529 delete arg2;
26530 }
26531 return NULL;
26532 }
26533
26534
26535 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
26536 PyObject *obj;
26537 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26538 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
26539 Py_INCREF(obj);
26540 return Py_BuildValue((char *)"");
26541 }
26542 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
26543 PyObject *resultobj = NULL;
26544 int arg1 = (int) 0 ;
26545 int arg2 = (int) 0 ;
26546 int arg3 = (int) 0 ;
26547 int arg4 = (int) 0 ;
26548 wxDateSpan *result;
26549 PyObject * obj0 = 0 ;
26550 PyObject * obj1 = 0 ;
26551 PyObject * obj2 = 0 ;
26552 PyObject * obj3 = 0 ;
26553 char *kwnames[] = {
26554 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
26555 };
26556
26557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26558 if (obj0) {
26559 {
26560 arg1 = static_cast<int >(SWIG_As_int(obj0));
26561 if (SWIG_arg_fail(1)) SWIG_fail;
26562 }
26563 }
26564 if (obj1) {
26565 {
26566 arg2 = static_cast<int >(SWIG_As_int(obj1));
26567 if (SWIG_arg_fail(2)) SWIG_fail;
26568 }
26569 }
26570 if (obj2) {
26571 {
26572 arg3 = static_cast<int >(SWIG_As_int(obj2));
26573 if (SWIG_arg_fail(3)) SWIG_fail;
26574 }
26575 }
26576 if (obj3) {
26577 {
26578 arg4 = static_cast<int >(SWIG_As_int(obj3));
26579 if (SWIG_arg_fail(4)) SWIG_fail;
26580 }
26581 }
26582 {
26583 PyThreadState* __tstate = wxPyBeginAllowThreads();
26584 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
26585
26586 wxPyEndAllowThreads(__tstate);
26587 if (PyErr_Occurred()) SWIG_fail;
26588 }
26589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26590 return resultobj;
26591 fail:
26592 return NULL;
26593 }
26594
26595
26596 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
26597 PyObject *resultobj = NULL;
26598 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26599 PyObject * obj0 = 0 ;
26600 char *kwnames[] = {
26601 (char *) "self", NULL
26602 };
26603
26604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
26605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26606 if (SWIG_arg_fail(1)) SWIG_fail;
26607 {
26608 PyThreadState* __tstate = wxPyBeginAllowThreads();
26609 delete arg1;
26610
26611 wxPyEndAllowThreads(__tstate);
26612 if (PyErr_Occurred()) SWIG_fail;
26613 }
26614 Py_INCREF(Py_None); resultobj = Py_None;
26615 return resultobj;
26616 fail:
26617 return NULL;
26618 }
26619
26620
26621 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
26622 PyObject *resultobj = NULL;
26623 int arg1 ;
26624 wxDateSpan result;
26625 PyObject * obj0 = 0 ;
26626 char *kwnames[] = {
26627 (char *) "days", NULL
26628 };
26629
26630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
26631 {
26632 arg1 = static_cast<int >(SWIG_As_int(obj0));
26633 if (SWIG_arg_fail(1)) SWIG_fail;
26634 }
26635 {
26636 PyThreadState* __tstate = wxPyBeginAllowThreads();
26637 result = wxDateSpan::Days(arg1);
26638
26639 wxPyEndAllowThreads(__tstate);
26640 if (PyErr_Occurred()) SWIG_fail;
26641 }
26642 {
26643 wxDateSpan * resultptr;
26644 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26645 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26646 }
26647 return resultobj;
26648 fail:
26649 return NULL;
26650 }
26651
26652
26653 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
26654 PyObject *resultobj = NULL;
26655 wxDateSpan result;
26656 char *kwnames[] = {
26657 NULL
26658 };
26659
26660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
26661 {
26662 PyThreadState* __tstate = wxPyBeginAllowThreads();
26663 result = wxDateSpan::Day();
26664
26665 wxPyEndAllowThreads(__tstate);
26666 if (PyErr_Occurred()) SWIG_fail;
26667 }
26668 {
26669 wxDateSpan * resultptr;
26670 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26671 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26672 }
26673 return resultobj;
26674 fail:
26675 return NULL;
26676 }
26677
26678
26679 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
26680 PyObject *resultobj = NULL;
26681 int arg1 ;
26682 wxDateSpan result;
26683 PyObject * obj0 = 0 ;
26684 char *kwnames[] = {
26685 (char *) "weeks", NULL
26686 };
26687
26688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
26689 {
26690 arg1 = static_cast<int >(SWIG_As_int(obj0));
26691 if (SWIG_arg_fail(1)) SWIG_fail;
26692 }
26693 {
26694 PyThreadState* __tstate = wxPyBeginAllowThreads();
26695 result = wxDateSpan::Weeks(arg1);
26696
26697 wxPyEndAllowThreads(__tstate);
26698 if (PyErr_Occurred()) SWIG_fail;
26699 }
26700 {
26701 wxDateSpan * resultptr;
26702 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26703 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26704 }
26705 return resultobj;
26706 fail:
26707 return NULL;
26708 }
26709
26710
26711 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
26712 PyObject *resultobj = NULL;
26713 wxDateSpan result;
26714 char *kwnames[] = {
26715 NULL
26716 };
26717
26718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
26719 {
26720 PyThreadState* __tstate = wxPyBeginAllowThreads();
26721 result = wxDateSpan::Week();
26722
26723 wxPyEndAllowThreads(__tstate);
26724 if (PyErr_Occurred()) SWIG_fail;
26725 }
26726 {
26727 wxDateSpan * resultptr;
26728 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26729 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26730 }
26731 return resultobj;
26732 fail:
26733 return NULL;
26734 }
26735
26736
26737 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
26738 PyObject *resultobj = NULL;
26739 int arg1 ;
26740 wxDateSpan result;
26741 PyObject * obj0 = 0 ;
26742 char *kwnames[] = {
26743 (char *) "mon", NULL
26744 };
26745
26746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
26747 {
26748 arg1 = static_cast<int >(SWIG_As_int(obj0));
26749 if (SWIG_arg_fail(1)) SWIG_fail;
26750 }
26751 {
26752 PyThreadState* __tstate = wxPyBeginAllowThreads();
26753 result = wxDateSpan::Months(arg1);
26754
26755 wxPyEndAllowThreads(__tstate);
26756 if (PyErr_Occurred()) SWIG_fail;
26757 }
26758 {
26759 wxDateSpan * resultptr;
26760 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26761 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26762 }
26763 return resultobj;
26764 fail:
26765 return NULL;
26766 }
26767
26768
26769 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
26770 PyObject *resultobj = NULL;
26771 wxDateSpan result;
26772 char *kwnames[] = {
26773 NULL
26774 };
26775
26776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
26777 {
26778 PyThreadState* __tstate = wxPyBeginAllowThreads();
26779 result = wxDateSpan::Month();
26780
26781 wxPyEndAllowThreads(__tstate);
26782 if (PyErr_Occurred()) SWIG_fail;
26783 }
26784 {
26785 wxDateSpan * resultptr;
26786 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26787 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26788 }
26789 return resultobj;
26790 fail:
26791 return NULL;
26792 }
26793
26794
26795 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
26796 PyObject *resultobj = NULL;
26797 int arg1 ;
26798 wxDateSpan result;
26799 PyObject * obj0 = 0 ;
26800 char *kwnames[] = {
26801 (char *) "years", NULL
26802 };
26803
26804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
26805 {
26806 arg1 = static_cast<int >(SWIG_As_int(obj0));
26807 if (SWIG_arg_fail(1)) SWIG_fail;
26808 }
26809 {
26810 PyThreadState* __tstate = wxPyBeginAllowThreads();
26811 result = wxDateSpan::Years(arg1);
26812
26813 wxPyEndAllowThreads(__tstate);
26814 if (PyErr_Occurred()) SWIG_fail;
26815 }
26816 {
26817 wxDateSpan * resultptr;
26818 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26819 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26820 }
26821 return resultobj;
26822 fail:
26823 return NULL;
26824 }
26825
26826
26827 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
26828 PyObject *resultobj = NULL;
26829 wxDateSpan result;
26830 char *kwnames[] = {
26831 NULL
26832 };
26833
26834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
26835 {
26836 PyThreadState* __tstate = wxPyBeginAllowThreads();
26837 result = wxDateSpan::Year();
26838
26839 wxPyEndAllowThreads(__tstate);
26840 if (PyErr_Occurred()) SWIG_fail;
26841 }
26842 {
26843 wxDateSpan * resultptr;
26844 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26845 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26846 }
26847 return resultobj;
26848 fail:
26849 return NULL;
26850 }
26851
26852
26853 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
26854 PyObject *resultobj = NULL;
26855 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26856 int arg2 ;
26857 wxDateSpan *result;
26858 PyObject * obj0 = 0 ;
26859 PyObject * obj1 = 0 ;
26860 char *kwnames[] = {
26861 (char *) "self",(char *) "n", NULL
26862 };
26863
26864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
26865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26866 if (SWIG_arg_fail(1)) SWIG_fail;
26867 {
26868 arg2 = static_cast<int >(SWIG_As_int(obj1));
26869 if (SWIG_arg_fail(2)) SWIG_fail;
26870 }
26871 {
26872 PyThreadState* __tstate = wxPyBeginAllowThreads();
26873 {
26874 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
26875 result = (wxDateSpan *) &_result_ref;
26876 }
26877
26878 wxPyEndAllowThreads(__tstate);
26879 if (PyErr_Occurred()) SWIG_fail;
26880 }
26881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26882 return resultobj;
26883 fail:
26884 return NULL;
26885 }
26886
26887
26888 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
26889 PyObject *resultobj = NULL;
26890 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26891 int arg2 ;
26892 wxDateSpan *result;
26893 PyObject * obj0 = 0 ;
26894 PyObject * obj1 = 0 ;
26895 char *kwnames[] = {
26896 (char *) "self",(char *) "n", NULL
26897 };
26898
26899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
26900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26901 if (SWIG_arg_fail(1)) SWIG_fail;
26902 {
26903 arg2 = static_cast<int >(SWIG_As_int(obj1));
26904 if (SWIG_arg_fail(2)) SWIG_fail;
26905 }
26906 {
26907 PyThreadState* __tstate = wxPyBeginAllowThreads();
26908 {
26909 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
26910 result = (wxDateSpan *) &_result_ref;
26911 }
26912
26913 wxPyEndAllowThreads(__tstate);
26914 if (PyErr_Occurred()) SWIG_fail;
26915 }
26916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26917 return resultobj;
26918 fail:
26919 return NULL;
26920 }
26921
26922
26923 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
26924 PyObject *resultobj = NULL;
26925 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26926 int arg2 ;
26927 wxDateSpan *result;
26928 PyObject * obj0 = 0 ;
26929 PyObject * obj1 = 0 ;
26930 char *kwnames[] = {
26931 (char *) "self",(char *) "n", NULL
26932 };
26933
26934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
26935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26936 if (SWIG_arg_fail(1)) SWIG_fail;
26937 {
26938 arg2 = static_cast<int >(SWIG_As_int(obj1));
26939 if (SWIG_arg_fail(2)) SWIG_fail;
26940 }
26941 {
26942 PyThreadState* __tstate = wxPyBeginAllowThreads();
26943 {
26944 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
26945 result = (wxDateSpan *) &_result_ref;
26946 }
26947
26948 wxPyEndAllowThreads(__tstate);
26949 if (PyErr_Occurred()) SWIG_fail;
26950 }
26951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26952 return resultobj;
26953 fail:
26954 return NULL;
26955 }
26956
26957
26958 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
26959 PyObject *resultobj = NULL;
26960 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26961 int arg2 ;
26962 wxDateSpan *result;
26963 PyObject * obj0 = 0 ;
26964 PyObject * obj1 = 0 ;
26965 char *kwnames[] = {
26966 (char *) "self",(char *) "n", NULL
26967 };
26968
26969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
26970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26971 if (SWIG_arg_fail(1)) SWIG_fail;
26972 {
26973 arg2 = static_cast<int >(SWIG_As_int(obj1));
26974 if (SWIG_arg_fail(2)) SWIG_fail;
26975 }
26976 {
26977 PyThreadState* __tstate = wxPyBeginAllowThreads();
26978 {
26979 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
26980 result = (wxDateSpan *) &_result_ref;
26981 }
26982
26983 wxPyEndAllowThreads(__tstate);
26984 if (PyErr_Occurred()) SWIG_fail;
26985 }
26986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26987 return resultobj;
26988 fail:
26989 return NULL;
26990 }
26991
26992
26993 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
26994 PyObject *resultobj = NULL;
26995 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26996 int result;
26997 PyObject * obj0 = 0 ;
26998 char *kwnames[] = {
26999 (char *) "self", NULL
27000 };
27001
27002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
27003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27004 if (SWIG_arg_fail(1)) SWIG_fail;
27005 {
27006 PyThreadState* __tstate = wxPyBeginAllowThreads();
27007 result = (int)((wxDateSpan const *)arg1)->GetYears();
27008
27009 wxPyEndAllowThreads(__tstate);
27010 if (PyErr_Occurred()) SWIG_fail;
27011 }
27012 {
27013 resultobj = SWIG_From_int(static_cast<int >(result));
27014 }
27015 return resultobj;
27016 fail:
27017 return NULL;
27018 }
27019
27020
27021 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
27022 PyObject *resultobj = NULL;
27023 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27024 int result;
27025 PyObject * obj0 = 0 ;
27026 char *kwnames[] = {
27027 (char *) "self", NULL
27028 };
27029
27030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
27031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27032 if (SWIG_arg_fail(1)) SWIG_fail;
27033 {
27034 PyThreadState* __tstate = wxPyBeginAllowThreads();
27035 result = (int)((wxDateSpan const *)arg1)->GetMonths();
27036
27037 wxPyEndAllowThreads(__tstate);
27038 if (PyErr_Occurred()) SWIG_fail;
27039 }
27040 {
27041 resultobj = SWIG_From_int(static_cast<int >(result));
27042 }
27043 return resultobj;
27044 fail:
27045 return NULL;
27046 }
27047
27048
27049 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
27050 PyObject *resultobj = NULL;
27051 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27052 int result;
27053 PyObject * obj0 = 0 ;
27054 char *kwnames[] = {
27055 (char *) "self", NULL
27056 };
27057
27058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
27059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27060 if (SWIG_arg_fail(1)) SWIG_fail;
27061 {
27062 PyThreadState* __tstate = wxPyBeginAllowThreads();
27063 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
27064
27065 wxPyEndAllowThreads(__tstate);
27066 if (PyErr_Occurred()) SWIG_fail;
27067 }
27068 {
27069 resultobj = SWIG_From_int(static_cast<int >(result));
27070 }
27071 return resultobj;
27072 fail:
27073 return NULL;
27074 }
27075
27076
27077 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
27078 PyObject *resultobj = NULL;
27079 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27080 int result;
27081 PyObject * obj0 = 0 ;
27082 char *kwnames[] = {
27083 (char *) "self", NULL
27084 };
27085
27086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
27087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27088 if (SWIG_arg_fail(1)) SWIG_fail;
27089 {
27090 PyThreadState* __tstate = wxPyBeginAllowThreads();
27091 result = (int)((wxDateSpan const *)arg1)->GetDays();
27092
27093 wxPyEndAllowThreads(__tstate);
27094 if (PyErr_Occurred()) SWIG_fail;
27095 }
27096 {
27097 resultobj = SWIG_From_int(static_cast<int >(result));
27098 }
27099 return resultobj;
27100 fail:
27101 return NULL;
27102 }
27103
27104
27105 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
27106 PyObject *resultobj = NULL;
27107 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27108 int result;
27109 PyObject * obj0 = 0 ;
27110 char *kwnames[] = {
27111 (char *) "self", NULL
27112 };
27113
27114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
27115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27116 if (SWIG_arg_fail(1)) SWIG_fail;
27117 {
27118 PyThreadState* __tstate = wxPyBeginAllowThreads();
27119 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
27120
27121 wxPyEndAllowThreads(__tstate);
27122 if (PyErr_Occurred()) SWIG_fail;
27123 }
27124 {
27125 resultobj = SWIG_From_int(static_cast<int >(result));
27126 }
27127 return resultobj;
27128 fail:
27129 return NULL;
27130 }
27131
27132
27133 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27134 PyObject *resultobj = NULL;
27135 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27136 wxDateSpan *arg2 = 0 ;
27137 wxDateSpan *result;
27138 PyObject * obj0 = 0 ;
27139 PyObject * obj1 = 0 ;
27140 char *kwnames[] = {
27141 (char *) "self",(char *) "other", NULL
27142 };
27143
27144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
27145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27146 if (SWIG_arg_fail(1)) SWIG_fail;
27147 {
27148 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27149 if (SWIG_arg_fail(2)) SWIG_fail;
27150 if (arg2 == NULL) {
27151 SWIG_null_ref("wxDateSpan");
27152 }
27153 if (SWIG_arg_fail(2)) SWIG_fail;
27154 }
27155 {
27156 PyThreadState* __tstate = wxPyBeginAllowThreads();
27157 {
27158 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27159 result = (wxDateSpan *) &_result_ref;
27160 }
27161
27162 wxPyEndAllowThreads(__tstate);
27163 if (PyErr_Occurred()) SWIG_fail;
27164 }
27165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27166 return resultobj;
27167 fail:
27168 return NULL;
27169 }
27170
27171
27172 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
27173 PyObject *resultobj = NULL;
27174 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27175 wxDateSpan *arg2 = 0 ;
27176 wxDateSpan *result;
27177 PyObject * obj0 = 0 ;
27178 PyObject * obj1 = 0 ;
27179 char *kwnames[] = {
27180 (char *) "self",(char *) "other", NULL
27181 };
27182
27183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
27184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27185 if (SWIG_arg_fail(1)) SWIG_fail;
27186 {
27187 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27188 if (SWIG_arg_fail(2)) SWIG_fail;
27189 if (arg2 == NULL) {
27190 SWIG_null_ref("wxDateSpan");
27191 }
27192 if (SWIG_arg_fail(2)) SWIG_fail;
27193 }
27194 {
27195 PyThreadState* __tstate = wxPyBeginAllowThreads();
27196 {
27197 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27198 result = (wxDateSpan *) &_result_ref;
27199 }
27200
27201 wxPyEndAllowThreads(__tstate);
27202 if (PyErr_Occurred()) SWIG_fail;
27203 }
27204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27205 return resultobj;
27206 fail:
27207 return NULL;
27208 }
27209
27210
27211 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
27212 PyObject *resultobj = NULL;
27213 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27214 wxDateSpan *result;
27215 PyObject * obj0 = 0 ;
27216 char *kwnames[] = {
27217 (char *) "self", NULL
27218 };
27219
27220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
27221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27222 if (SWIG_arg_fail(1)) SWIG_fail;
27223 {
27224 PyThreadState* __tstate = wxPyBeginAllowThreads();
27225 {
27226 wxDateSpan &_result_ref = (arg1)->Neg();
27227 result = (wxDateSpan *) &_result_ref;
27228 }
27229
27230 wxPyEndAllowThreads(__tstate);
27231 if (PyErr_Occurred()) SWIG_fail;
27232 }
27233 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27234 return resultobj;
27235 fail:
27236 return NULL;
27237 }
27238
27239
27240 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
27241 PyObject *resultobj = NULL;
27242 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27243 int arg2 ;
27244 wxDateSpan *result;
27245 PyObject * obj0 = 0 ;
27246 PyObject * obj1 = 0 ;
27247 char *kwnames[] = {
27248 (char *) "self",(char *) "factor", NULL
27249 };
27250
27251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
27252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27253 if (SWIG_arg_fail(1)) SWIG_fail;
27254 {
27255 arg2 = static_cast<int >(SWIG_As_int(obj1));
27256 if (SWIG_arg_fail(2)) SWIG_fail;
27257 }
27258 {
27259 PyThreadState* __tstate = wxPyBeginAllowThreads();
27260 {
27261 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
27262 result = (wxDateSpan *) &_result_ref;
27263 }
27264
27265 wxPyEndAllowThreads(__tstate);
27266 if (PyErr_Occurred()) SWIG_fail;
27267 }
27268 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27269 return resultobj;
27270 fail:
27271 return NULL;
27272 }
27273
27274
27275 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
27276 PyObject *resultobj = NULL;
27277 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27278 wxDateSpan *arg2 = 0 ;
27279 wxDateSpan *result;
27280 PyObject * obj0 = 0 ;
27281 PyObject * obj1 = 0 ;
27282 char *kwnames[] = {
27283 (char *) "self",(char *) "other", NULL
27284 };
27285
27286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
27287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27288 if (SWIG_arg_fail(1)) SWIG_fail;
27289 {
27290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27291 if (SWIG_arg_fail(2)) SWIG_fail;
27292 if (arg2 == NULL) {
27293 SWIG_null_ref("wxDateSpan");
27294 }
27295 if (SWIG_arg_fail(2)) SWIG_fail;
27296 }
27297 {
27298 PyThreadState* __tstate = wxPyBeginAllowThreads();
27299 {
27300 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27301 result = (wxDateSpan *) &_result_ref;
27302 }
27303
27304 wxPyEndAllowThreads(__tstate);
27305 if (PyErr_Occurred()) SWIG_fail;
27306 }
27307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
27308 return resultobj;
27309 fail:
27310 return NULL;
27311 }
27312
27313
27314 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
27315 PyObject *resultobj = NULL;
27316 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27317 wxDateSpan *arg2 = 0 ;
27318 wxDateSpan *result;
27319 PyObject * obj0 = 0 ;
27320 PyObject * obj1 = 0 ;
27321 char *kwnames[] = {
27322 (char *) "self",(char *) "other", NULL
27323 };
27324
27325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
27326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27327 if (SWIG_arg_fail(1)) SWIG_fail;
27328 {
27329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27330 if (SWIG_arg_fail(2)) SWIG_fail;
27331 if (arg2 == NULL) {
27332 SWIG_null_ref("wxDateSpan");
27333 }
27334 if (SWIG_arg_fail(2)) SWIG_fail;
27335 }
27336 {
27337 PyThreadState* __tstate = wxPyBeginAllowThreads();
27338 {
27339 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27340 result = (wxDateSpan *) &_result_ref;
27341 }
27342
27343 wxPyEndAllowThreads(__tstate);
27344 if (PyErr_Occurred()) SWIG_fail;
27345 }
27346 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
27347 return resultobj;
27348 fail:
27349 return NULL;
27350 }
27351
27352
27353 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
27354 PyObject *resultobj = NULL;
27355 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27356 wxDateSpan *result;
27357 PyObject * obj0 = 0 ;
27358 char *kwnames[] = {
27359 (char *) "self", NULL
27360 };
27361
27362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
27363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27364 if (SWIG_arg_fail(1)) SWIG_fail;
27365 {
27366 PyThreadState* __tstate = wxPyBeginAllowThreads();
27367 {
27368 wxDateSpan &_result_ref = (arg1)->operator -();
27369 result = (wxDateSpan *) &_result_ref;
27370 }
27371
27372 wxPyEndAllowThreads(__tstate);
27373 if (PyErr_Occurred()) SWIG_fail;
27374 }
27375 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27376 return resultobj;
27377 fail:
27378 return NULL;
27379 }
27380
27381
27382 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
27383 PyObject *resultobj = NULL;
27384 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27385 int arg2 ;
27386 wxDateSpan *result;
27387 PyObject * obj0 = 0 ;
27388 PyObject * obj1 = 0 ;
27389 char *kwnames[] = {
27390 (char *) "self",(char *) "factor", NULL
27391 };
27392
27393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
27394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27395 if (SWIG_arg_fail(1)) SWIG_fail;
27396 {
27397 arg2 = static_cast<int >(SWIG_As_int(obj1));
27398 if (SWIG_arg_fail(2)) SWIG_fail;
27399 }
27400 {
27401 PyThreadState* __tstate = wxPyBeginAllowThreads();
27402 {
27403 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
27404 result = (wxDateSpan *) &_result_ref;
27405 }
27406
27407 wxPyEndAllowThreads(__tstate);
27408 if (PyErr_Occurred()) SWIG_fail;
27409 }
27410 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
27411 return resultobj;
27412 fail:
27413 return NULL;
27414 }
27415
27416
27417 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
27418 PyObject *resultobj = NULL;
27419 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27420 wxDateSpan *arg2 = 0 ;
27421 wxDateSpan result;
27422 PyObject * obj0 = 0 ;
27423 PyObject * obj1 = 0 ;
27424 char *kwnames[] = {
27425 (char *) "self",(char *) "other", NULL
27426 };
27427
27428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
27429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27430 if (SWIG_arg_fail(1)) SWIG_fail;
27431 {
27432 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27433 if (SWIG_arg_fail(2)) SWIG_fail;
27434 if (arg2 == NULL) {
27435 SWIG_null_ref("wxDateSpan");
27436 }
27437 if (SWIG_arg_fail(2)) SWIG_fail;
27438 }
27439 {
27440 PyThreadState* __tstate = wxPyBeginAllowThreads();
27441 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
27442
27443 wxPyEndAllowThreads(__tstate);
27444 if (PyErr_Occurred()) SWIG_fail;
27445 }
27446 {
27447 wxDateSpan * resultptr;
27448 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
27449 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
27450 }
27451 return resultobj;
27452 fail:
27453 return NULL;
27454 }
27455
27456
27457 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
27458 PyObject *resultobj = NULL;
27459 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27460 wxDateSpan *arg2 = 0 ;
27461 wxDateSpan result;
27462 PyObject * obj0 = 0 ;
27463 PyObject * obj1 = 0 ;
27464 char *kwnames[] = {
27465 (char *) "self",(char *) "other", NULL
27466 };
27467
27468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
27469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27470 if (SWIG_arg_fail(1)) SWIG_fail;
27471 {
27472 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27473 if (SWIG_arg_fail(2)) SWIG_fail;
27474 if (arg2 == NULL) {
27475 SWIG_null_ref("wxDateSpan");
27476 }
27477 if (SWIG_arg_fail(2)) SWIG_fail;
27478 }
27479 {
27480 PyThreadState* __tstate = wxPyBeginAllowThreads();
27481 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
27482
27483 wxPyEndAllowThreads(__tstate);
27484 if (PyErr_Occurred()) SWIG_fail;
27485 }
27486 {
27487 wxDateSpan * resultptr;
27488 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
27489 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
27490 }
27491 return resultobj;
27492 fail:
27493 return NULL;
27494 }
27495
27496
27497 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
27498 PyObject *resultobj = NULL;
27499 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27500 int arg2 ;
27501 wxDateSpan result;
27502 PyObject * obj0 = 0 ;
27503 PyObject * obj1 = 0 ;
27504 char *kwnames[] = {
27505 (char *) "self",(char *) "n", NULL
27506 };
27507
27508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
27509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27510 if (SWIG_arg_fail(1)) SWIG_fail;
27511 {
27512 arg2 = static_cast<int >(SWIG_As_int(obj1));
27513 if (SWIG_arg_fail(2)) SWIG_fail;
27514 }
27515 {
27516 PyThreadState* __tstate = wxPyBeginAllowThreads();
27517 result = wxDateSpan___mul__(arg1,arg2);
27518
27519 wxPyEndAllowThreads(__tstate);
27520 if (PyErr_Occurred()) SWIG_fail;
27521 }
27522 {
27523 wxDateSpan * resultptr;
27524 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
27525 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
27526 }
27527 return resultobj;
27528 fail:
27529 return NULL;
27530 }
27531
27532
27533 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
27534 PyObject *resultobj = NULL;
27535 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27536 int arg2 ;
27537 wxDateSpan result;
27538 PyObject * obj0 = 0 ;
27539 PyObject * obj1 = 0 ;
27540 char *kwnames[] = {
27541 (char *) "self",(char *) "n", NULL
27542 };
27543
27544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
27545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27546 if (SWIG_arg_fail(1)) SWIG_fail;
27547 {
27548 arg2 = static_cast<int >(SWIG_As_int(obj1));
27549 if (SWIG_arg_fail(2)) SWIG_fail;
27550 }
27551 {
27552 PyThreadState* __tstate = wxPyBeginAllowThreads();
27553 result = wxDateSpan___rmul__(arg1,arg2);
27554
27555 wxPyEndAllowThreads(__tstate);
27556 if (PyErr_Occurred()) SWIG_fail;
27557 }
27558 {
27559 wxDateSpan * resultptr;
27560 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
27561 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
27562 }
27563 return resultobj;
27564 fail:
27565 return NULL;
27566 }
27567
27568
27569 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
27570 PyObject *resultobj = NULL;
27571 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27572 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
27573 bool result;
27574 PyObject * obj0 = 0 ;
27575 PyObject * obj1 = 0 ;
27576 char *kwnames[] = {
27577 (char *) "self",(char *) "other", NULL
27578 };
27579
27580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
27581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27582 if (SWIG_arg_fail(1)) SWIG_fail;
27583 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27584 if (SWIG_arg_fail(2)) SWIG_fail;
27585 {
27586 PyThreadState* __tstate = wxPyBeginAllowThreads();
27587 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
27588
27589 wxPyEndAllowThreads(__tstate);
27590 if (PyErr_Occurred()) SWIG_fail;
27591 }
27592 {
27593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27594 }
27595 return resultobj;
27596 fail:
27597 return NULL;
27598 }
27599
27600
27601 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
27602 PyObject *resultobj = NULL;
27603 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27604 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
27605 bool result;
27606 PyObject * obj0 = 0 ;
27607 PyObject * obj1 = 0 ;
27608 char *kwnames[] = {
27609 (char *) "self",(char *) "other", NULL
27610 };
27611
27612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
27613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27614 if (SWIG_arg_fail(1)) SWIG_fail;
27615 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27616 if (SWIG_arg_fail(2)) SWIG_fail;
27617 {
27618 PyThreadState* __tstate = wxPyBeginAllowThreads();
27619 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
27620
27621 wxPyEndAllowThreads(__tstate);
27622 if (PyErr_Occurred()) SWIG_fail;
27623 }
27624 {
27625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27626 }
27627 return resultobj;
27628 fail:
27629 return NULL;
27630 }
27631
27632
27633 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
27634 PyObject *obj;
27635 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27636 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
27637 Py_INCREF(obj);
27638 return Py_BuildValue((char *)"");
27639 }
27640 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
27641 PyObject *resultobj = NULL;
27642 long result;
27643 char *kwnames[] = {
27644 NULL
27645 };
27646
27647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
27648 {
27649 PyThreadState* __tstate = wxPyBeginAllowThreads();
27650 result = (long)wxGetLocalTime();
27651
27652 wxPyEndAllowThreads(__tstate);
27653 if (PyErr_Occurred()) SWIG_fail;
27654 }
27655 {
27656 resultobj = SWIG_From_long(static_cast<long >(result));
27657 }
27658 return resultobj;
27659 fail:
27660 return NULL;
27661 }
27662
27663
27664 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
27665 PyObject *resultobj = NULL;
27666 long result;
27667 char *kwnames[] = {
27668 NULL
27669 };
27670
27671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
27672 {
27673 PyThreadState* __tstate = wxPyBeginAllowThreads();
27674 result = (long)wxGetUTCTime();
27675
27676 wxPyEndAllowThreads(__tstate);
27677 if (PyErr_Occurred()) SWIG_fail;
27678 }
27679 {
27680 resultobj = SWIG_From_long(static_cast<long >(result));
27681 }
27682 return resultobj;
27683 fail:
27684 return NULL;
27685 }
27686
27687
27688 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
27689 PyObject *resultobj = NULL;
27690 long result;
27691 char *kwnames[] = {
27692 NULL
27693 };
27694
27695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
27696 {
27697 PyThreadState* __tstate = wxPyBeginAllowThreads();
27698 result = (long)wxGetCurrentTime();
27699
27700 wxPyEndAllowThreads(__tstate);
27701 if (PyErr_Occurred()) SWIG_fail;
27702 }
27703 {
27704 resultobj = SWIG_From_long(static_cast<long >(result));
27705 }
27706 return resultobj;
27707 fail:
27708 return NULL;
27709 }
27710
27711
27712 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
27713 PyObject *resultobj = NULL;
27714 wxLongLong result;
27715 char *kwnames[] = {
27716 NULL
27717 };
27718
27719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
27720 {
27721 PyThreadState* __tstate = wxPyBeginAllowThreads();
27722 result = wxGetLocalTimeMillis();
27723
27724 wxPyEndAllowThreads(__tstate);
27725 if (PyErr_Occurred()) SWIG_fail;
27726 }
27727 {
27728 PyObject *hi, *lo, *shifter, *shifted;
27729 hi = PyLong_FromLong( (&result)->GetHi() );
27730 lo = PyLong_FromLong( (&result)->GetLo() );
27731 shifter = PyLong_FromLong(32);
27732 shifted = PyNumber_Lshift(hi, shifter);
27733 resultobj = PyNumber_Or(shifted, lo);
27734 Py_DECREF(hi);
27735 Py_DECREF(lo);
27736 Py_DECREF(shifter);
27737 Py_DECREF(shifted);
27738 }
27739 return resultobj;
27740 fail:
27741 return NULL;
27742 }
27743
27744
27745 static int _wrap_DefaultDateTime_set(PyObject *) {
27746 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
27747 return 1;
27748 }
27749
27750
27751 static PyObject *_wrap_DefaultDateTime_get(void) {
27752 PyObject *pyobj = NULL;
27753
27754 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
27755 return pyobj;
27756 }
27757
27758
27759 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27760 PyObject *resultobj = NULL;
27761 wxDataFormatId arg1 ;
27762 wxDataFormat *result;
27763 PyObject * obj0 = 0 ;
27764 char *kwnames[] = {
27765 (char *) "type", NULL
27766 };
27767
27768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
27769 {
27770 arg1 = static_cast<wxDataFormatId >(SWIG_As_int(obj0));
27771 if (SWIG_arg_fail(1)) SWIG_fail;
27772 }
27773 {
27774 PyThreadState* __tstate = wxPyBeginAllowThreads();
27775 result = (wxDataFormat *)new wxDataFormat(arg1);
27776
27777 wxPyEndAllowThreads(__tstate);
27778 if (PyErr_Occurred()) SWIG_fail;
27779 }
27780 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
27781 return resultobj;
27782 fail:
27783 return NULL;
27784 }
27785
27786
27787 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27788 PyObject *resultobj = NULL;
27789 wxString *arg1 = 0 ;
27790 wxDataFormat *result;
27791 bool temp1 = false ;
27792 PyObject * obj0 = 0 ;
27793 char *kwnames[] = {
27794 (char *) "format", NULL
27795 };
27796
27797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
27798 {
27799 arg1 = wxString_in_helper(obj0);
27800 if (arg1 == NULL) SWIG_fail;
27801 temp1 = true;
27802 }
27803 {
27804 PyThreadState* __tstate = wxPyBeginAllowThreads();
27805 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
27806
27807 wxPyEndAllowThreads(__tstate);
27808 if (PyErr_Occurred()) SWIG_fail;
27809 }
27810 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
27811 {
27812 if (temp1)
27813 delete arg1;
27814 }
27815 return resultobj;
27816 fail:
27817 {
27818 if (temp1)
27819 delete arg1;
27820 }
27821 return NULL;
27822 }
27823
27824
27825 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27826 PyObject *resultobj = NULL;
27827 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27828 PyObject * obj0 = 0 ;
27829 char *kwnames[] = {
27830 (char *) "self", NULL
27831 };
27832
27833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
27834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27835 if (SWIG_arg_fail(1)) SWIG_fail;
27836 {
27837 PyThreadState* __tstate = wxPyBeginAllowThreads();
27838 delete arg1;
27839
27840 wxPyEndAllowThreads(__tstate);
27841 if (PyErr_Occurred()) SWIG_fail;
27842 }
27843 Py_INCREF(Py_None); resultobj = Py_None;
27844 return resultobj;
27845 fail:
27846 return NULL;
27847 }
27848
27849
27850 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
27851 PyObject *resultobj = NULL;
27852 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27853 wxDataFormatId arg2 ;
27854 bool result;
27855 PyObject * obj0 = 0 ;
27856 PyObject * obj1 = 0 ;
27857
27858 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
27859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27860 if (SWIG_arg_fail(1)) SWIG_fail;
27861 {
27862 arg2 = static_cast<wxDataFormatId >(SWIG_As_int(obj1));
27863 if (SWIG_arg_fail(2)) SWIG_fail;
27864 }
27865 {
27866 PyThreadState* __tstate = wxPyBeginAllowThreads();
27867 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
27868
27869 wxPyEndAllowThreads(__tstate);
27870 if (PyErr_Occurred()) SWIG_fail;
27871 }
27872 {
27873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27874 }
27875 return resultobj;
27876 fail:
27877 return NULL;
27878 }
27879
27880
27881 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
27882 PyObject *resultobj = NULL;
27883 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27884 wxDataFormatId arg2 ;
27885 bool result;
27886 PyObject * obj0 = 0 ;
27887 PyObject * obj1 = 0 ;
27888
27889 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
27890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27891 if (SWIG_arg_fail(1)) SWIG_fail;
27892 {
27893 arg2 = static_cast<wxDataFormatId >(SWIG_As_int(obj1));
27894 if (SWIG_arg_fail(2)) SWIG_fail;
27895 }
27896 {
27897 PyThreadState* __tstate = wxPyBeginAllowThreads();
27898 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
27899
27900 wxPyEndAllowThreads(__tstate);
27901 if (PyErr_Occurred()) SWIG_fail;
27902 }
27903 {
27904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27905 }
27906 return resultobj;
27907 fail:
27908 return NULL;
27909 }
27910
27911
27912 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
27913 PyObject *resultobj = NULL;
27914 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27915 wxDataFormat *arg2 = 0 ;
27916 bool result;
27917 PyObject * obj0 = 0 ;
27918 PyObject * obj1 = 0 ;
27919
27920 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
27921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27922 if (SWIG_arg_fail(1)) SWIG_fail;
27923 {
27924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27925 if (SWIG_arg_fail(2)) SWIG_fail;
27926 if (arg2 == NULL) {
27927 SWIG_null_ref("wxDataFormat");
27928 }
27929 if (SWIG_arg_fail(2)) SWIG_fail;
27930 }
27931 {
27932 PyThreadState* __tstate = wxPyBeginAllowThreads();
27933 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
27934
27935 wxPyEndAllowThreads(__tstate);
27936 if (PyErr_Occurred()) SWIG_fail;
27937 }
27938 {
27939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27940 }
27941 return resultobj;
27942 fail:
27943 return NULL;
27944 }
27945
27946
27947 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
27948 int argc;
27949 PyObject *argv[3];
27950 int ii;
27951
27952 argc = PyObject_Length(args);
27953 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
27954 argv[ii] = PyTuple_GetItem(args,ii);
27955 }
27956 if (argc == 2) {
27957 int _v;
27958 {
27959 void *ptr;
27960 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27961 _v = 0;
27962 PyErr_Clear();
27963 } else {
27964 _v = 1;
27965 }
27966 }
27967 if (_v) {
27968 {
27969 void *ptr = 0;
27970 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27971 _v = 0;
27972 PyErr_Clear();
27973 } else {
27974 _v = (ptr != 0);
27975 }
27976 }
27977 if (_v) {
27978 return _wrap_DataFormat___eq____SWIG_1(self,args);
27979 }
27980 }
27981 }
27982 if (argc == 2) {
27983 int _v;
27984 {
27985 void *ptr;
27986 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27987 _v = 0;
27988 PyErr_Clear();
27989 } else {
27990 _v = 1;
27991 }
27992 }
27993 if (_v) {
27994 _v = SWIG_Check_int(argv[1]);
27995 if (_v) {
27996 return _wrap_DataFormat___eq____SWIG_0(self,args);
27997 }
27998 }
27999 }
28000
28001 Py_INCREF(Py_NotImplemented);
28002 return Py_NotImplemented;
28003 }
28004
28005
28006 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
28007 PyObject *resultobj = NULL;
28008 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28009 wxDataFormat *arg2 = 0 ;
28010 bool result;
28011 PyObject * obj0 = 0 ;
28012 PyObject * obj1 = 0 ;
28013
28014 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
28015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28016 if (SWIG_arg_fail(1)) SWIG_fail;
28017 {
28018 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28019 if (SWIG_arg_fail(2)) SWIG_fail;
28020 if (arg2 == NULL) {
28021 SWIG_null_ref("wxDataFormat");
28022 }
28023 if (SWIG_arg_fail(2)) SWIG_fail;
28024 }
28025 {
28026 PyThreadState* __tstate = wxPyBeginAllowThreads();
28027 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
28028
28029 wxPyEndAllowThreads(__tstate);
28030 if (PyErr_Occurred()) SWIG_fail;
28031 }
28032 {
28033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28034 }
28035 return resultobj;
28036 fail:
28037 return NULL;
28038 }
28039
28040
28041 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
28042 int argc;
28043 PyObject *argv[3];
28044 int ii;
28045
28046 argc = PyObject_Length(args);
28047 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
28048 argv[ii] = PyTuple_GetItem(args,ii);
28049 }
28050 if (argc == 2) {
28051 int _v;
28052 {
28053 void *ptr;
28054 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28055 _v = 0;
28056 PyErr_Clear();
28057 } else {
28058 _v = 1;
28059 }
28060 }
28061 if (_v) {
28062 {
28063 void *ptr = 0;
28064 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28065 _v = 0;
28066 PyErr_Clear();
28067 } else {
28068 _v = (ptr != 0);
28069 }
28070 }
28071 if (_v) {
28072 return _wrap_DataFormat___ne____SWIG_1(self,args);
28073 }
28074 }
28075 }
28076 if (argc == 2) {
28077 int _v;
28078 {
28079 void *ptr;
28080 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28081 _v = 0;
28082 PyErr_Clear();
28083 } else {
28084 _v = 1;
28085 }
28086 }
28087 if (_v) {
28088 _v = SWIG_Check_int(argv[1]);
28089 if (_v) {
28090 return _wrap_DataFormat___ne____SWIG_0(self,args);
28091 }
28092 }
28093 }
28094
28095 Py_INCREF(Py_NotImplemented);
28096 return Py_NotImplemented;
28097 }
28098
28099
28100 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
28101 PyObject *resultobj = NULL;
28102 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28103 wxDataFormatId arg2 ;
28104 PyObject * obj0 = 0 ;
28105 PyObject * obj1 = 0 ;
28106 char *kwnames[] = {
28107 (char *) "self",(char *) "format", NULL
28108 };
28109
28110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
28111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28112 if (SWIG_arg_fail(1)) SWIG_fail;
28113 {
28114 arg2 = static_cast<wxDataFormatId >(SWIG_As_int(obj1));
28115 if (SWIG_arg_fail(2)) SWIG_fail;
28116 }
28117 {
28118 PyThreadState* __tstate = wxPyBeginAllowThreads();
28119 (arg1)->SetType(arg2);
28120
28121 wxPyEndAllowThreads(__tstate);
28122 if (PyErr_Occurred()) SWIG_fail;
28123 }
28124 Py_INCREF(Py_None); resultobj = Py_None;
28125 return resultobj;
28126 fail:
28127 return NULL;
28128 }
28129
28130
28131 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
28132 PyObject *resultobj = NULL;
28133 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28134 wxDataFormatId result;
28135 PyObject * obj0 = 0 ;
28136 char *kwnames[] = {
28137 (char *) "self", NULL
28138 };
28139
28140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
28141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28142 if (SWIG_arg_fail(1)) SWIG_fail;
28143 {
28144 PyThreadState* __tstate = wxPyBeginAllowThreads();
28145 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
28146
28147 wxPyEndAllowThreads(__tstate);
28148 if (PyErr_Occurred()) SWIG_fail;
28149 }
28150 resultobj = SWIG_From_int((result));
28151 return resultobj;
28152 fail:
28153 return NULL;
28154 }
28155
28156
28157 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
28158 PyObject *resultobj = NULL;
28159 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28160 wxString result;
28161 PyObject * obj0 = 0 ;
28162 char *kwnames[] = {
28163 (char *) "self", NULL
28164 };
28165
28166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
28167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28168 if (SWIG_arg_fail(1)) SWIG_fail;
28169 {
28170 PyThreadState* __tstate = wxPyBeginAllowThreads();
28171 result = ((wxDataFormat const *)arg1)->GetId();
28172
28173 wxPyEndAllowThreads(__tstate);
28174 if (PyErr_Occurred()) SWIG_fail;
28175 }
28176 {
28177 #if wxUSE_UNICODE
28178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28179 #else
28180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28181 #endif
28182 }
28183 return resultobj;
28184 fail:
28185 return NULL;
28186 }
28187
28188
28189 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
28190 PyObject *resultobj = NULL;
28191 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28192 wxString *arg2 = 0 ;
28193 bool temp2 = false ;
28194 PyObject * obj0 = 0 ;
28195 PyObject * obj1 = 0 ;
28196 char *kwnames[] = {
28197 (char *) "self",(char *) "format", NULL
28198 };
28199
28200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
28201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28202 if (SWIG_arg_fail(1)) SWIG_fail;
28203 {
28204 arg2 = wxString_in_helper(obj1);
28205 if (arg2 == NULL) SWIG_fail;
28206 temp2 = true;
28207 }
28208 {
28209 PyThreadState* __tstate = wxPyBeginAllowThreads();
28210 (arg1)->SetId((wxString const &)*arg2);
28211
28212 wxPyEndAllowThreads(__tstate);
28213 if (PyErr_Occurred()) SWIG_fail;
28214 }
28215 Py_INCREF(Py_None); resultobj = Py_None;
28216 {
28217 if (temp2)
28218 delete arg2;
28219 }
28220 return resultobj;
28221 fail:
28222 {
28223 if (temp2)
28224 delete arg2;
28225 }
28226 return NULL;
28227 }
28228
28229
28230 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
28231 PyObject *obj;
28232 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28233 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
28234 Py_INCREF(obj);
28235 return Py_BuildValue((char *)"");
28236 }
28237 static int _wrap_FormatInvalid_set(PyObject *) {
28238 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
28239 return 1;
28240 }
28241
28242
28243 static PyObject *_wrap_FormatInvalid_get(void) {
28244 PyObject *pyobj = NULL;
28245
28246 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
28247 return pyobj;
28248 }
28249
28250
28251 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28252 PyObject *resultobj = NULL;
28253 wxDataObject *arg1 = (wxDataObject *) 0 ;
28254 PyObject * obj0 = 0 ;
28255 char *kwnames[] = {
28256 (char *) "self", NULL
28257 };
28258
28259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
28260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28261 if (SWIG_arg_fail(1)) SWIG_fail;
28262 {
28263 PyThreadState* __tstate = wxPyBeginAllowThreads();
28264 delete arg1;
28265
28266 wxPyEndAllowThreads(__tstate);
28267 if (PyErr_Occurred()) SWIG_fail;
28268 }
28269 Py_INCREF(Py_None); resultobj = Py_None;
28270 return resultobj;
28271 fail:
28272 return NULL;
28273 }
28274
28275
28276 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
28277 PyObject *resultobj = NULL;
28278 wxDataObject *arg1 = (wxDataObject *) 0 ;
28279 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
28280 SwigValueWrapper<wxDataFormat > result;
28281 PyObject * obj0 = 0 ;
28282 PyObject * obj1 = 0 ;
28283 char *kwnames[] = {
28284 (char *) "self",(char *) "dir", NULL
28285 };
28286
28287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
28288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28289 if (SWIG_arg_fail(1)) SWIG_fail;
28290 if (obj1) {
28291 {
28292 arg2 = static_cast<wxDataObject::Direction >(SWIG_As_int(obj1));
28293 if (SWIG_arg_fail(2)) SWIG_fail;
28294 }
28295 }
28296 {
28297 PyThreadState* __tstate = wxPyBeginAllowThreads();
28298 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
28299
28300 wxPyEndAllowThreads(__tstate);
28301 if (PyErr_Occurred()) SWIG_fail;
28302 }
28303 {
28304 wxDataFormat * resultptr;
28305 resultptr = new wxDataFormat(static_cast<wxDataFormat & >(result));
28306 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
28307 }
28308 return resultobj;
28309 fail:
28310 return NULL;
28311 }
28312
28313
28314 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
28315 PyObject *resultobj = NULL;
28316 wxDataObject *arg1 = (wxDataObject *) 0 ;
28317 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
28318 size_t result;
28319 PyObject * obj0 = 0 ;
28320 PyObject * obj1 = 0 ;
28321 char *kwnames[] = {
28322 (char *) "self",(char *) "dir", NULL
28323 };
28324
28325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
28326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28327 if (SWIG_arg_fail(1)) SWIG_fail;
28328 if (obj1) {
28329 {
28330 arg2 = static_cast<wxDataObject::Direction >(SWIG_As_int(obj1));
28331 if (SWIG_arg_fail(2)) SWIG_fail;
28332 }
28333 }
28334 {
28335 PyThreadState* __tstate = wxPyBeginAllowThreads();
28336 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
28337
28338 wxPyEndAllowThreads(__tstate);
28339 if (PyErr_Occurred()) SWIG_fail;
28340 }
28341 {
28342 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
28343 }
28344 return resultobj;
28345 fail:
28346 return NULL;
28347 }
28348
28349
28350 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
28351 PyObject *resultobj = NULL;
28352 wxDataObject *arg1 = (wxDataObject *) 0 ;
28353 wxDataFormat *arg2 = 0 ;
28354 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
28355 bool result;
28356 PyObject * obj0 = 0 ;
28357 PyObject * obj1 = 0 ;
28358 PyObject * obj2 = 0 ;
28359 char *kwnames[] = {
28360 (char *) "self",(char *) "format",(char *) "dir", NULL
28361 };
28362
28363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
28364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28365 if (SWIG_arg_fail(1)) SWIG_fail;
28366 {
28367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28368 if (SWIG_arg_fail(2)) SWIG_fail;
28369 if (arg2 == NULL) {
28370 SWIG_null_ref("wxDataFormat");
28371 }
28372 if (SWIG_arg_fail(2)) SWIG_fail;
28373 }
28374 if (obj2) {
28375 {
28376 arg3 = static_cast<wxDataObject::Direction >(SWIG_As_int(obj2));
28377 if (SWIG_arg_fail(3)) SWIG_fail;
28378 }
28379 }
28380 {
28381 PyThreadState* __tstate = wxPyBeginAllowThreads();
28382 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
28383
28384 wxPyEndAllowThreads(__tstate);
28385 if (PyErr_Occurred()) SWIG_fail;
28386 }
28387 {
28388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28389 }
28390 return resultobj;
28391 fail:
28392 return NULL;
28393 }
28394
28395
28396 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
28397 PyObject *resultobj = NULL;
28398 wxDataObject *arg1 = (wxDataObject *) 0 ;
28399 wxDataFormat *arg2 = 0 ;
28400 size_t result;
28401 PyObject * obj0 = 0 ;
28402 PyObject * obj1 = 0 ;
28403 char *kwnames[] = {
28404 (char *) "self",(char *) "format", NULL
28405 };
28406
28407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
28408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28409 if (SWIG_arg_fail(1)) SWIG_fail;
28410 {
28411 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28412 if (SWIG_arg_fail(2)) SWIG_fail;
28413 if (arg2 == NULL) {
28414 SWIG_null_ref("wxDataFormat");
28415 }
28416 if (SWIG_arg_fail(2)) SWIG_fail;
28417 }
28418 {
28419 PyThreadState* __tstate = wxPyBeginAllowThreads();
28420 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
28421
28422 wxPyEndAllowThreads(__tstate);
28423 if (PyErr_Occurred()) SWIG_fail;
28424 }
28425 {
28426 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
28427 }
28428 return resultobj;
28429 fail:
28430 return NULL;
28431 }
28432
28433
28434 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
28435 PyObject *resultobj = NULL;
28436 wxDataObject *arg1 = (wxDataObject *) 0 ;
28437 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
28438 PyObject *result;
28439 PyObject * obj0 = 0 ;
28440 PyObject * obj1 = 0 ;
28441 char *kwnames[] = {
28442 (char *) "self",(char *) "dir", NULL
28443 };
28444
28445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
28446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28447 if (SWIG_arg_fail(1)) SWIG_fail;
28448 if (obj1) {
28449 {
28450 arg2 = static_cast<wxDataObject::Direction >(SWIG_As_int(obj1));
28451 if (SWIG_arg_fail(2)) SWIG_fail;
28452 }
28453 }
28454 {
28455 PyThreadState* __tstate = wxPyBeginAllowThreads();
28456 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
28457
28458 wxPyEndAllowThreads(__tstate);
28459 if (PyErr_Occurred()) SWIG_fail;
28460 }
28461 resultobj = result;
28462 return resultobj;
28463 fail:
28464 return NULL;
28465 }
28466
28467
28468 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
28469 PyObject *resultobj = NULL;
28470 wxDataObject *arg1 = (wxDataObject *) 0 ;
28471 wxDataFormat *arg2 = 0 ;
28472 PyObject *result;
28473 PyObject * obj0 = 0 ;
28474 PyObject * obj1 = 0 ;
28475 char *kwnames[] = {
28476 (char *) "self",(char *) "format", NULL
28477 };
28478
28479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
28480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28481 if (SWIG_arg_fail(1)) SWIG_fail;
28482 {
28483 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28484 if (SWIG_arg_fail(2)) SWIG_fail;
28485 if (arg2 == NULL) {
28486 SWIG_null_ref("wxDataFormat");
28487 }
28488 if (SWIG_arg_fail(2)) SWIG_fail;
28489 }
28490 {
28491 PyThreadState* __tstate = wxPyBeginAllowThreads();
28492 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
28493
28494 wxPyEndAllowThreads(__tstate);
28495 if (PyErr_Occurred()) SWIG_fail;
28496 }
28497 resultobj = result;
28498 return resultobj;
28499 fail:
28500 return NULL;
28501 }
28502
28503
28504 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28505 PyObject *resultobj = NULL;
28506 wxDataObject *arg1 = (wxDataObject *) 0 ;
28507 wxDataFormat *arg2 = 0 ;
28508 PyObject *arg3 = (PyObject *) 0 ;
28509 bool result;
28510 PyObject * obj0 = 0 ;
28511 PyObject * obj1 = 0 ;
28512 PyObject * obj2 = 0 ;
28513 char *kwnames[] = {
28514 (char *) "self",(char *) "format",(char *) "data", NULL
28515 };
28516
28517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
28518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28519 if (SWIG_arg_fail(1)) SWIG_fail;
28520 {
28521 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28522 if (SWIG_arg_fail(2)) SWIG_fail;
28523 if (arg2 == NULL) {
28524 SWIG_null_ref("wxDataFormat");
28525 }
28526 if (SWIG_arg_fail(2)) SWIG_fail;
28527 }
28528 arg3 = obj2;
28529 {
28530 PyThreadState* __tstate = wxPyBeginAllowThreads();
28531 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
28532
28533 wxPyEndAllowThreads(__tstate);
28534 if (PyErr_Occurred()) SWIG_fail;
28535 }
28536 {
28537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28538 }
28539 return resultobj;
28540 fail:
28541 return NULL;
28542 }
28543
28544
28545 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
28546 PyObject *obj;
28547 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28548 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
28549 Py_INCREF(obj);
28550 return Py_BuildValue((char *)"");
28551 }
28552 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
28553 PyObject *resultobj = NULL;
28554 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
28555 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
28556 wxDataObjectSimple *result;
28557 PyObject * obj0 = 0 ;
28558 char *kwnames[] = {
28559 (char *) "format", NULL
28560 };
28561
28562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
28563 if (obj0) {
28564 {
28565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28566 if (SWIG_arg_fail(1)) SWIG_fail;
28567 if (arg1 == NULL) {
28568 SWIG_null_ref("wxDataFormat");
28569 }
28570 if (SWIG_arg_fail(1)) SWIG_fail;
28571 }
28572 }
28573 {
28574 PyThreadState* __tstate = wxPyBeginAllowThreads();
28575 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
28576
28577 wxPyEndAllowThreads(__tstate);
28578 if (PyErr_Occurred()) SWIG_fail;
28579 }
28580 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
28581 return resultobj;
28582 fail:
28583 return NULL;
28584 }
28585
28586
28587 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
28588 PyObject *resultobj = NULL;
28589 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28590 wxDataFormat *result;
28591 PyObject * obj0 = 0 ;
28592 char *kwnames[] = {
28593 (char *) "self", NULL
28594 };
28595
28596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
28597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28598 if (SWIG_arg_fail(1)) SWIG_fail;
28599 {
28600 PyThreadState* __tstate = wxPyBeginAllowThreads();
28601 {
28602 wxDataFormat const &_result_ref = (arg1)->GetFormat();
28603 result = (wxDataFormat *) &_result_ref;
28604 }
28605
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
28610 return resultobj;
28611 fail:
28612 return NULL;
28613 }
28614
28615
28616 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
28617 PyObject *resultobj = NULL;
28618 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28619 wxDataFormat *arg2 = 0 ;
28620 PyObject * obj0 = 0 ;
28621 PyObject * obj1 = 0 ;
28622 char *kwnames[] = {
28623 (char *) "self",(char *) "format", NULL
28624 };
28625
28626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
28627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28628 if (SWIG_arg_fail(1)) SWIG_fail;
28629 {
28630 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28631 if (SWIG_arg_fail(2)) SWIG_fail;
28632 if (arg2 == NULL) {
28633 SWIG_null_ref("wxDataFormat");
28634 }
28635 if (SWIG_arg_fail(2)) SWIG_fail;
28636 }
28637 {
28638 PyThreadState* __tstate = wxPyBeginAllowThreads();
28639 (arg1)->SetFormat((wxDataFormat const &)*arg2);
28640
28641 wxPyEndAllowThreads(__tstate);
28642 if (PyErr_Occurred()) SWIG_fail;
28643 }
28644 Py_INCREF(Py_None); resultobj = Py_None;
28645 return resultobj;
28646 fail:
28647 return NULL;
28648 }
28649
28650
28651 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
28652 PyObject *resultobj = NULL;
28653 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28654 size_t result;
28655 PyObject * obj0 = 0 ;
28656 char *kwnames[] = {
28657 (char *) "self", NULL
28658 };
28659
28660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
28661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28662 if (SWIG_arg_fail(1)) SWIG_fail;
28663 {
28664 PyThreadState* __tstate = wxPyBeginAllowThreads();
28665 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
28666
28667 wxPyEndAllowThreads(__tstate);
28668 if (PyErr_Occurred()) SWIG_fail;
28669 }
28670 {
28671 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
28672 }
28673 return resultobj;
28674 fail:
28675 return NULL;
28676 }
28677
28678
28679 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
28680 PyObject *resultobj = NULL;
28681 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28682 PyObject *result;
28683 PyObject * obj0 = 0 ;
28684 char *kwnames[] = {
28685 (char *) "self", NULL
28686 };
28687
28688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
28689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28690 if (SWIG_arg_fail(1)) SWIG_fail;
28691 {
28692 PyThreadState* __tstate = wxPyBeginAllowThreads();
28693 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
28694
28695 wxPyEndAllowThreads(__tstate);
28696 if (PyErr_Occurred()) SWIG_fail;
28697 }
28698 resultobj = result;
28699 return resultobj;
28700 fail:
28701 return NULL;
28702 }
28703
28704
28705 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28706 PyObject *resultobj = NULL;
28707 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28708 PyObject *arg2 = (PyObject *) 0 ;
28709 bool result;
28710 PyObject * obj0 = 0 ;
28711 PyObject * obj1 = 0 ;
28712 char *kwnames[] = {
28713 (char *) "self",(char *) "data", NULL
28714 };
28715
28716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
28717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28718 if (SWIG_arg_fail(1)) SWIG_fail;
28719 arg2 = obj1;
28720 {
28721 PyThreadState* __tstate = wxPyBeginAllowThreads();
28722 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
28723
28724 wxPyEndAllowThreads(__tstate);
28725 if (PyErr_Occurred()) SWIG_fail;
28726 }
28727 {
28728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28729 }
28730 return resultobj;
28731 fail:
28732 return NULL;
28733 }
28734
28735
28736 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
28737 PyObject *obj;
28738 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28739 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
28740 Py_INCREF(obj);
28741 return Py_BuildValue((char *)"");
28742 }
28743 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
28744 PyObject *resultobj = NULL;
28745 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
28746 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
28747 wxPyDataObjectSimple *result;
28748 PyObject * obj0 = 0 ;
28749 char *kwnames[] = {
28750 (char *) "format", NULL
28751 };
28752
28753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
28754 if (obj0) {
28755 {
28756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28757 if (SWIG_arg_fail(1)) SWIG_fail;
28758 if (arg1 == NULL) {
28759 SWIG_null_ref("wxDataFormat");
28760 }
28761 if (SWIG_arg_fail(1)) SWIG_fail;
28762 }
28763 }
28764 {
28765 PyThreadState* __tstate = wxPyBeginAllowThreads();
28766 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
28767
28768 wxPyEndAllowThreads(__tstate);
28769 if (PyErr_Occurred()) SWIG_fail;
28770 }
28771 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
28772 return resultobj;
28773 fail:
28774 return NULL;
28775 }
28776
28777
28778 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28779 PyObject *resultobj = NULL;
28780 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
28781 PyObject *arg2 = (PyObject *) 0 ;
28782 PyObject *arg3 = (PyObject *) 0 ;
28783 PyObject * obj0 = 0 ;
28784 PyObject * obj1 = 0 ;
28785 PyObject * obj2 = 0 ;
28786 char *kwnames[] = {
28787 (char *) "self",(char *) "self",(char *) "_class", NULL
28788 };
28789
28790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28792 if (SWIG_arg_fail(1)) SWIG_fail;
28793 arg2 = obj1;
28794 arg3 = obj2;
28795 {
28796 PyThreadState* __tstate = wxPyBeginAllowThreads();
28797 (arg1)->_setCallbackInfo(arg2,arg3);
28798
28799 wxPyEndAllowThreads(__tstate);
28800 if (PyErr_Occurred()) SWIG_fail;
28801 }
28802 Py_INCREF(Py_None); resultobj = Py_None;
28803 return resultobj;
28804 fail:
28805 return NULL;
28806 }
28807
28808
28809 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
28810 PyObject *obj;
28811 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28812 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
28813 Py_INCREF(obj);
28814 return Py_BuildValue((char *)"");
28815 }
28816 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
28817 PyObject *resultobj = NULL;
28818 wxDataObjectComposite *result;
28819 char *kwnames[] = {
28820 NULL
28821 };
28822
28823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
28824 {
28825 PyThreadState* __tstate = wxPyBeginAllowThreads();
28826 result = (wxDataObjectComposite *)new wxDataObjectComposite();
28827
28828 wxPyEndAllowThreads(__tstate);
28829 if (PyErr_Occurred()) SWIG_fail;
28830 }
28831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
28832 return resultobj;
28833 fail:
28834 return NULL;
28835 }
28836
28837
28838 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
28839 PyObject *resultobj = NULL;
28840 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
28841 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
28842 bool arg3 = (bool) false ;
28843 PyObject * obj0 = 0 ;
28844 PyObject * obj1 = 0 ;
28845 PyObject * obj2 = 0 ;
28846 char *kwnames[] = {
28847 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
28848 };
28849
28850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
28851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
28852 if (SWIG_arg_fail(1)) SWIG_fail;
28853 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28854 if (SWIG_arg_fail(2)) SWIG_fail;
28855 if (obj2) {
28856 {
28857 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
28858 if (SWIG_arg_fail(3)) SWIG_fail;
28859 }
28860 }
28861 {
28862 PyThreadState* __tstate = wxPyBeginAllowThreads();
28863 (arg1)->Add(arg2,arg3);
28864
28865 wxPyEndAllowThreads(__tstate);
28866 if (PyErr_Occurred()) SWIG_fail;
28867 }
28868 Py_INCREF(Py_None); resultobj = Py_None;
28869 return resultobj;
28870 fail:
28871 return NULL;
28872 }
28873
28874
28875 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
28876 PyObject *obj;
28877 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28878 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
28879 Py_INCREF(obj);
28880 return Py_BuildValue((char *)"");
28881 }
28882 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28883 PyObject *resultobj = NULL;
28884 wxString const &arg1_defvalue = wxPyEmptyString ;
28885 wxString *arg1 = (wxString *) &arg1_defvalue ;
28886 wxTextDataObject *result;
28887 bool temp1 = false ;
28888 PyObject * obj0 = 0 ;
28889 char *kwnames[] = {
28890 (char *) "text", NULL
28891 };
28892
28893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
28894 if (obj0) {
28895 {
28896 arg1 = wxString_in_helper(obj0);
28897 if (arg1 == NULL) SWIG_fail;
28898 temp1 = true;
28899 }
28900 }
28901 {
28902 PyThreadState* __tstate = wxPyBeginAllowThreads();
28903 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
28904
28905 wxPyEndAllowThreads(__tstate);
28906 if (PyErr_Occurred()) SWIG_fail;
28907 }
28908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
28909 {
28910 if (temp1)
28911 delete arg1;
28912 }
28913 return resultobj;
28914 fail:
28915 {
28916 if (temp1)
28917 delete arg1;
28918 }
28919 return NULL;
28920 }
28921
28922
28923 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
28924 PyObject *resultobj = NULL;
28925 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
28926 size_t result;
28927 PyObject * obj0 = 0 ;
28928 char *kwnames[] = {
28929 (char *) "self", NULL
28930 };
28931
28932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
28933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28934 if (SWIG_arg_fail(1)) SWIG_fail;
28935 {
28936 PyThreadState* __tstate = wxPyBeginAllowThreads();
28937 result = (size_t)(arg1)->GetTextLength();
28938
28939 wxPyEndAllowThreads(__tstate);
28940 if (PyErr_Occurred()) SWIG_fail;
28941 }
28942 {
28943 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
28944 }
28945 return resultobj;
28946 fail:
28947 return NULL;
28948 }
28949
28950
28951 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
28952 PyObject *resultobj = NULL;
28953 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
28954 wxString result;
28955 PyObject * obj0 = 0 ;
28956 char *kwnames[] = {
28957 (char *) "self", NULL
28958 };
28959
28960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
28961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28962 if (SWIG_arg_fail(1)) SWIG_fail;
28963 {
28964 PyThreadState* __tstate = wxPyBeginAllowThreads();
28965 result = (arg1)->GetText();
28966
28967 wxPyEndAllowThreads(__tstate);
28968 if (PyErr_Occurred()) SWIG_fail;
28969 }
28970 {
28971 #if wxUSE_UNICODE
28972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28973 #else
28974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28975 #endif
28976 }
28977 return resultobj;
28978 fail:
28979 return NULL;
28980 }
28981
28982
28983 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
28984 PyObject *resultobj = NULL;
28985 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
28986 wxString *arg2 = 0 ;
28987 bool temp2 = false ;
28988 PyObject * obj0 = 0 ;
28989 PyObject * obj1 = 0 ;
28990 char *kwnames[] = {
28991 (char *) "self",(char *) "text", NULL
28992 };
28993
28994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
28995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28996 if (SWIG_arg_fail(1)) SWIG_fail;
28997 {
28998 arg2 = wxString_in_helper(obj1);
28999 if (arg2 == NULL) SWIG_fail;
29000 temp2 = true;
29001 }
29002 {
29003 PyThreadState* __tstate = wxPyBeginAllowThreads();
29004 (arg1)->SetText((wxString const &)*arg2);
29005
29006 wxPyEndAllowThreads(__tstate);
29007 if (PyErr_Occurred()) SWIG_fail;
29008 }
29009 Py_INCREF(Py_None); resultobj = Py_None;
29010 {
29011 if (temp2)
29012 delete arg2;
29013 }
29014 return resultobj;
29015 fail:
29016 {
29017 if (temp2)
29018 delete arg2;
29019 }
29020 return NULL;
29021 }
29022
29023
29024 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
29025 PyObject *obj;
29026 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29027 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
29028 Py_INCREF(obj);
29029 return Py_BuildValue((char *)"");
29030 }
29031 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29032 PyObject *resultobj = NULL;
29033 wxString const &arg1_defvalue = wxPyEmptyString ;
29034 wxString *arg1 = (wxString *) &arg1_defvalue ;
29035 wxPyTextDataObject *result;
29036 bool temp1 = false ;
29037 PyObject * obj0 = 0 ;
29038 char *kwnames[] = {
29039 (char *) "text", NULL
29040 };
29041
29042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
29043 if (obj0) {
29044 {
29045 arg1 = wxString_in_helper(obj0);
29046 if (arg1 == NULL) SWIG_fail;
29047 temp1 = true;
29048 }
29049 }
29050 {
29051 PyThreadState* __tstate = wxPyBeginAllowThreads();
29052 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
29053
29054 wxPyEndAllowThreads(__tstate);
29055 if (PyErr_Occurred()) SWIG_fail;
29056 }
29057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
29058 {
29059 if (temp1)
29060 delete arg1;
29061 }
29062 return resultobj;
29063 fail:
29064 {
29065 if (temp1)
29066 delete arg1;
29067 }
29068 return NULL;
29069 }
29070
29071
29072 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29073 PyObject *resultobj = NULL;
29074 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
29075 PyObject *arg2 = (PyObject *) 0 ;
29076 PyObject *arg3 = (PyObject *) 0 ;
29077 PyObject * obj0 = 0 ;
29078 PyObject * obj1 = 0 ;
29079 PyObject * obj2 = 0 ;
29080 char *kwnames[] = {
29081 (char *) "self",(char *) "self",(char *) "_class", NULL
29082 };
29083
29084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
29086 if (SWIG_arg_fail(1)) SWIG_fail;
29087 arg2 = obj1;
29088 arg3 = obj2;
29089 {
29090 PyThreadState* __tstate = wxPyBeginAllowThreads();
29091 (arg1)->_setCallbackInfo(arg2,arg3);
29092
29093 wxPyEndAllowThreads(__tstate);
29094 if (PyErr_Occurred()) SWIG_fail;
29095 }
29096 Py_INCREF(Py_None); resultobj = Py_None;
29097 return resultobj;
29098 fail:
29099 return NULL;
29100 }
29101
29102
29103 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
29104 PyObject *obj;
29105 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29106 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
29107 Py_INCREF(obj);
29108 return Py_BuildValue((char *)"");
29109 }
29110 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29111 PyObject *resultobj = NULL;
29112 wxBitmap const &arg1_defvalue = wxNullBitmap ;
29113 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
29114 wxBitmapDataObject *result;
29115 PyObject * obj0 = 0 ;
29116 char *kwnames[] = {
29117 (char *) "bitmap", NULL
29118 };
29119
29120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
29121 if (obj0) {
29122 {
29123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
29124 if (SWIG_arg_fail(1)) SWIG_fail;
29125 if (arg1 == NULL) {
29126 SWIG_null_ref("wxBitmap");
29127 }
29128 if (SWIG_arg_fail(1)) SWIG_fail;
29129 }
29130 }
29131 {
29132 PyThreadState* __tstate = wxPyBeginAllowThreads();
29133 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
29134
29135 wxPyEndAllowThreads(__tstate);
29136 if (PyErr_Occurred()) SWIG_fail;
29137 }
29138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
29139 return resultobj;
29140 fail:
29141 return NULL;
29142 }
29143
29144
29145 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
29146 PyObject *resultobj = NULL;
29147 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
29148 wxBitmap result;
29149 PyObject * obj0 = 0 ;
29150 char *kwnames[] = {
29151 (char *) "self", NULL
29152 };
29153
29154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
29155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
29156 if (SWIG_arg_fail(1)) SWIG_fail;
29157 {
29158 PyThreadState* __tstate = wxPyBeginAllowThreads();
29159 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
29160
29161 wxPyEndAllowThreads(__tstate);
29162 if (PyErr_Occurred()) SWIG_fail;
29163 }
29164 {
29165 wxBitmap * resultptr;
29166 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
29167 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
29168 }
29169 return resultobj;
29170 fail:
29171 return NULL;
29172 }
29173
29174
29175 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
29176 PyObject *resultobj = NULL;
29177 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
29178 wxBitmap *arg2 = 0 ;
29179 PyObject * obj0 = 0 ;
29180 PyObject * obj1 = 0 ;
29181 char *kwnames[] = {
29182 (char *) "self",(char *) "bitmap", NULL
29183 };
29184
29185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
29186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
29187 if (SWIG_arg_fail(1)) SWIG_fail;
29188 {
29189 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
29190 if (SWIG_arg_fail(2)) SWIG_fail;
29191 if (arg2 == NULL) {
29192 SWIG_null_ref("wxBitmap");
29193 }
29194 if (SWIG_arg_fail(2)) SWIG_fail;
29195 }
29196 {
29197 PyThreadState* __tstate = wxPyBeginAllowThreads();
29198 (arg1)->SetBitmap((wxBitmap const &)*arg2);
29199
29200 wxPyEndAllowThreads(__tstate);
29201 if (PyErr_Occurred()) SWIG_fail;
29202 }
29203 Py_INCREF(Py_None); resultobj = Py_None;
29204 return resultobj;
29205 fail:
29206 return NULL;
29207 }
29208
29209
29210 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
29211 PyObject *obj;
29212 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29213 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
29214 Py_INCREF(obj);
29215 return Py_BuildValue((char *)"");
29216 }
29217 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29218 PyObject *resultobj = NULL;
29219 wxBitmap const &arg1_defvalue = wxNullBitmap ;
29220 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
29221 wxPyBitmapDataObject *result;
29222 PyObject * obj0 = 0 ;
29223 char *kwnames[] = {
29224 (char *) "bitmap", NULL
29225 };
29226
29227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
29228 if (obj0) {
29229 {
29230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
29231 if (SWIG_arg_fail(1)) SWIG_fail;
29232 if (arg1 == NULL) {
29233 SWIG_null_ref("wxBitmap");
29234 }
29235 if (SWIG_arg_fail(1)) SWIG_fail;
29236 }
29237 }
29238 {
29239 PyThreadState* __tstate = wxPyBeginAllowThreads();
29240 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
29241
29242 wxPyEndAllowThreads(__tstate);
29243 if (PyErr_Occurred()) SWIG_fail;
29244 }
29245 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
29246 return resultobj;
29247 fail:
29248 return NULL;
29249 }
29250
29251
29252 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29253 PyObject *resultobj = NULL;
29254 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
29255 PyObject *arg2 = (PyObject *) 0 ;
29256 PyObject *arg3 = (PyObject *) 0 ;
29257 PyObject * obj0 = 0 ;
29258 PyObject * obj1 = 0 ;
29259 PyObject * obj2 = 0 ;
29260 char *kwnames[] = {
29261 (char *) "self",(char *) "self",(char *) "_class", NULL
29262 };
29263
29264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
29266 if (SWIG_arg_fail(1)) SWIG_fail;
29267 arg2 = obj1;
29268 arg3 = obj2;
29269 {
29270 PyThreadState* __tstate = wxPyBeginAllowThreads();
29271 (arg1)->_setCallbackInfo(arg2,arg3);
29272
29273 wxPyEndAllowThreads(__tstate);
29274 if (PyErr_Occurred()) SWIG_fail;
29275 }
29276 Py_INCREF(Py_None); resultobj = Py_None;
29277 return resultobj;
29278 fail:
29279 return NULL;
29280 }
29281
29282
29283 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
29284 PyObject *obj;
29285 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29286 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
29287 Py_INCREF(obj);
29288 return Py_BuildValue((char *)"");
29289 }
29290 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29291 PyObject *resultobj = NULL;
29292 wxFileDataObject *result;
29293 char *kwnames[] = {
29294 NULL
29295 };
29296
29297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
29298 {
29299 PyThreadState* __tstate = wxPyBeginAllowThreads();
29300 result = (wxFileDataObject *)new wxFileDataObject();
29301
29302 wxPyEndAllowThreads(__tstate);
29303 if (PyErr_Occurred()) SWIG_fail;
29304 }
29305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
29306 return resultobj;
29307 fail:
29308 return NULL;
29309 }
29310
29311
29312 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
29313 PyObject *resultobj = NULL;
29314 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
29315 wxArrayString *result;
29316 PyObject * obj0 = 0 ;
29317 char *kwnames[] = {
29318 (char *) "self", NULL
29319 };
29320
29321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
29322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
29323 if (SWIG_arg_fail(1)) SWIG_fail;
29324 {
29325 PyThreadState* __tstate = wxPyBeginAllowThreads();
29326 {
29327 wxArrayString const &_result_ref = (arg1)->GetFilenames();
29328 result = (wxArrayString *) &_result_ref;
29329 }
29330
29331 wxPyEndAllowThreads(__tstate);
29332 if (PyErr_Occurred()) SWIG_fail;
29333 }
29334 {
29335 resultobj = wxArrayString2PyList_helper(*result);
29336 }
29337 return resultobj;
29338 fail:
29339 return NULL;
29340 }
29341
29342
29343 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
29344 PyObject *resultobj = NULL;
29345 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
29346 wxString *arg2 = 0 ;
29347 bool temp2 = false ;
29348 PyObject * obj0 = 0 ;
29349 PyObject * obj1 = 0 ;
29350 char *kwnames[] = {
29351 (char *) "self",(char *) "filename", NULL
29352 };
29353
29354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
29355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
29356 if (SWIG_arg_fail(1)) SWIG_fail;
29357 {
29358 arg2 = wxString_in_helper(obj1);
29359 if (arg2 == NULL) SWIG_fail;
29360 temp2 = true;
29361 }
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 (arg1)->AddFile((wxString const &)*arg2);
29365
29366 wxPyEndAllowThreads(__tstate);
29367 if (PyErr_Occurred()) SWIG_fail;
29368 }
29369 Py_INCREF(Py_None); resultobj = Py_None;
29370 {
29371 if (temp2)
29372 delete arg2;
29373 }
29374 return resultobj;
29375 fail:
29376 {
29377 if (temp2)
29378 delete arg2;
29379 }
29380 return NULL;
29381 }
29382
29383
29384 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
29385 PyObject *obj;
29386 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29387 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
29388 Py_INCREF(obj);
29389 return Py_BuildValue((char *)"");
29390 }
29391 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
29392 PyObject *resultobj = NULL;
29393 wxDataFormat *arg1 = 0 ;
29394 wxCustomDataObject *result;
29395 PyObject * obj0 = 0 ;
29396
29397 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
29398 {
29399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29400 if (SWIG_arg_fail(1)) SWIG_fail;
29401 if (arg1 == NULL) {
29402 SWIG_null_ref("wxDataFormat");
29403 }
29404 if (SWIG_arg_fail(1)) SWIG_fail;
29405 }
29406 {
29407 PyThreadState* __tstate = wxPyBeginAllowThreads();
29408 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
29409
29410 wxPyEndAllowThreads(__tstate);
29411 if (PyErr_Occurred()) SWIG_fail;
29412 }
29413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
29414 return resultobj;
29415 fail:
29416 return NULL;
29417 }
29418
29419
29420 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
29421 PyObject *resultobj = NULL;
29422 wxString *arg1 = 0 ;
29423 wxCustomDataObject *result;
29424 bool temp1 = false ;
29425 PyObject * obj0 = 0 ;
29426
29427 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
29428 {
29429 arg1 = wxString_in_helper(obj0);
29430 if (arg1 == NULL) SWIG_fail;
29431 temp1 = true;
29432 }
29433 {
29434 PyThreadState* __tstate = wxPyBeginAllowThreads();
29435 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
29436
29437 wxPyEndAllowThreads(__tstate);
29438 if (PyErr_Occurred()) SWIG_fail;
29439 }
29440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
29441 {
29442 if (temp1)
29443 delete arg1;
29444 }
29445 return resultobj;
29446 fail:
29447 {
29448 if (temp1)
29449 delete arg1;
29450 }
29451 return NULL;
29452 }
29453
29454
29455 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
29456 PyObject *resultobj = NULL;
29457 wxCustomDataObject *result;
29458
29459 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
29460 {
29461 PyThreadState* __tstate = wxPyBeginAllowThreads();
29462 result = (wxCustomDataObject *)new wxCustomDataObject();
29463
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
29468 return resultobj;
29469 fail:
29470 return NULL;
29471 }
29472
29473
29474 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
29475 int argc;
29476 PyObject *argv[2];
29477 int ii;
29478
29479 argc = PyObject_Length(args);
29480 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
29481 argv[ii] = PyTuple_GetItem(args,ii);
29482 }
29483 if (argc == 0) {
29484 return _wrap_new_CustomDataObject__SWIG_2(self,args);
29485 }
29486 if (argc == 1) {
29487 int _v;
29488 {
29489 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
29490 }
29491 if (_v) {
29492 return _wrap_new_CustomDataObject__SWIG_1(self,args);
29493 }
29494 }
29495 if (argc == 1) {
29496 int _v;
29497 {
29498 void *ptr = 0;
29499 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
29500 _v = 0;
29501 PyErr_Clear();
29502 } else {
29503 _v = (ptr != 0);
29504 }
29505 }
29506 if (_v) {
29507 return _wrap_new_CustomDataObject__SWIG_0(self,args);
29508 }
29509 }
29510
29511 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
29512 return NULL;
29513 }
29514
29515
29516 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29517 PyObject *resultobj = NULL;
29518 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
29519 PyObject *arg2 = (PyObject *) 0 ;
29520 bool result;
29521 PyObject * obj0 = 0 ;
29522 PyObject * obj1 = 0 ;
29523 char *kwnames[] = {
29524 (char *) "self",(char *) "data", NULL
29525 };
29526
29527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
29528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
29529 if (SWIG_arg_fail(1)) SWIG_fail;
29530 arg2 = obj1;
29531 {
29532 PyThreadState* __tstate = wxPyBeginAllowThreads();
29533 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
29534
29535 wxPyEndAllowThreads(__tstate);
29536 if (PyErr_Occurred()) SWIG_fail;
29537 }
29538 {
29539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29540 }
29541 return resultobj;
29542 fail:
29543 return NULL;
29544 }
29545
29546
29547 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
29548 PyObject *resultobj = NULL;
29549 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
29550 size_t result;
29551 PyObject * obj0 = 0 ;
29552 char *kwnames[] = {
29553 (char *) "self", NULL
29554 };
29555
29556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
29557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
29558 if (SWIG_arg_fail(1)) SWIG_fail;
29559 {
29560 PyThreadState* __tstate = wxPyBeginAllowThreads();
29561 result = (size_t)(arg1)->GetSize();
29562
29563 wxPyEndAllowThreads(__tstate);
29564 if (PyErr_Occurred()) SWIG_fail;
29565 }
29566 {
29567 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
29568 }
29569 return resultobj;
29570 fail:
29571 return NULL;
29572 }
29573
29574
29575 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29576 PyObject *resultobj = NULL;
29577 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
29578 PyObject *result;
29579 PyObject * obj0 = 0 ;
29580 char *kwnames[] = {
29581 (char *) "self", NULL
29582 };
29583
29584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
29585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
29586 if (SWIG_arg_fail(1)) SWIG_fail;
29587 {
29588 PyThreadState* __tstate = wxPyBeginAllowThreads();
29589 result = (PyObject *)wxCustomDataObject_GetData(arg1);
29590
29591 wxPyEndAllowThreads(__tstate);
29592 if (PyErr_Occurred()) SWIG_fail;
29593 }
29594 resultobj = result;
29595 return resultobj;
29596 fail:
29597 return NULL;
29598 }
29599
29600
29601 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
29602 PyObject *obj;
29603 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29604 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
29605 Py_INCREF(obj);
29606 return Py_BuildValue((char *)"");
29607 }
29608 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29609 PyObject *resultobj = NULL;
29610 wxURLDataObject *result;
29611 char *kwnames[] = {
29612 NULL
29613 };
29614
29615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
29616 {
29617 PyThreadState* __tstate = wxPyBeginAllowThreads();
29618 result = (wxURLDataObject *)new wxURLDataObject();
29619
29620 wxPyEndAllowThreads(__tstate);
29621 if (PyErr_Occurred()) SWIG_fail;
29622 }
29623 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
29624 return resultobj;
29625 fail:
29626 return NULL;
29627 }
29628
29629
29630 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
29631 PyObject *resultobj = NULL;
29632 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
29633 wxString result;
29634 PyObject * obj0 = 0 ;
29635 char *kwnames[] = {
29636 (char *) "self", NULL
29637 };
29638
29639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
29640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
29641 if (SWIG_arg_fail(1)) SWIG_fail;
29642 {
29643 PyThreadState* __tstate = wxPyBeginAllowThreads();
29644 result = (arg1)->GetURL();
29645
29646 wxPyEndAllowThreads(__tstate);
29647 if (PyErr_Occurred()) SWIG_fail;
29648 }
29649 {
29650 #if wxUSE_UNICODE
29651 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29652 #else
29653 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29654 #endif
29655 }
29656 return resultobj;
29657 fail:
29658 return NULL;
29659 }
29660
29661
29662 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
29663 PyObject *resultobj = NULL;
29664 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
29665 wxString *arg2 = 0 ;
29666 bool temp2 = false ;
29667 PyObject * obj0 = 0 ;
29668 PyObject * obj1 = 0 ;
29669 char *kwnames[] = {
29670 (char *) "self",(char *) "url", NULL
29671 };
29672
29673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
29674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
29675 if (SWIG_arg_fail(1)) SWIG_fail;
29676 {
29677 arg2 = wxString_in_helper(obj1);
29678 if (arg2 == NULL) SWIG_fail;
29679 temp2 = true;
29680 }
29681 {
29682 PyThreadState* __tstate = wxPyBeginAllowThreads();
29683 (arg1)->SetURL((wxString const &)*arg2);
29684
29685 wxPyEndAllowThreads(__tstate);
29686 if (PyErr_Occurred()) SWIG_fail;
29687 }
29688 Py_INCREF(Py_None); resultobj = Py_None;
29689 {
29690 if (temp2)
29691 delete arg2;
29692 }
29693 return resultobj;
29694 fail:
29695 {
29696 if (temp2)
29697 delete arg2;
29698 }
29699 return NULL;
29700 }
29701
29702
29703 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
29704 PyObject *obj;
29705 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29706 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
29707 Py_INCREF(obj);
29708 return Py_BuildValue((char *)"");
29709 }
29710 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29711 PyObject *resultobj = NULL;
29712 wxMetafileDataObject *result;
29713 char *kwnames[] = {
29714 NULL
29715 };
29716
29717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
29718 {
29719 PyThreadState* __tstate = wxPyBeginAllowThreads();
29720 result = (wxMetafileDataObject *)new wxMetafileDataObject();
29721
29722 wxPyEndAllowThreads(__tstate);
29723 if (PyErr_Occurred()) SWIG_fail;
29724 }
29725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
29726 return resultobj;
29727 fail:
29728 return NULL;
29729 }
29730
29731
29732 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
29733 PyObject *resultobj = NULL;
29734 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
29735 wxMetafile *arg2 = 0 ;
29736 PyObject * obj0 = 0 ;
29737 PyObject * obj1 = 0 ;
29738 char *kwnames[] = {
29739 (char *) "self",(char *) "metafile", NULL
29740 };
29741
29742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
29743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
29744 if (SWIG_arg_fail(1)) SWIG_fail;
29745 {
29746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
29747 if (SWIG_arg_fail(2)) SWIG_fail;
29748 if (arg2 == NULL) {
29749 SWIG_null_ref("wxMetafile");
29750 }
29751 if (SWIG_arg_fail(2)) SWIG_fail;
29752 }
29753 {
29754 PyThreadState* __tstate = wxPyBeginAllowThreads();
29755 (arg1)->SetMetafile((wxMetafile const &)*arg2);
29756
29757 wxPyEndAllowThreads(__tstate);
29758 if (PyErr_Occurred()) SWIG_fail;
29759 }
29760 Py_INCREF(Py_None); resultobj = Py_None;
29761 return resultobj;
29762 fail:
29763 return NULL;
29764 }
29765
29766
29767 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
29768 PyObject *resultobj = NULL;
29769 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
29770 wxMetafile result;
29771 PyObject * obj0 = 0 ;
29772 char *kwnames[] = {
29773 (char *) "self", NULL
29774 };
29775
29776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
29777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
29778 if (SWIG_arg_fail(1)) SWIG_fail;
29779 {
29780 PyThreadState* __tstate = wxPyBeginAllowThreads();
29781 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
29782
29783 wxPyEndAllowThreads(__tstate);
29784 if (PyErr_Occurred()) SWIG_fail;
29785 }
29786 {
29787 wxMetafile * resultptr;
29788 resultptr = new wxMetafile(static_cast<wxMetafile & >(result));
29789 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
29790 }
29791 return resultobj;
29792 fail:
29793 return NULL;
29794 }
29795
29796
29797 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
29798 PyObject *obj;
29799 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29800 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
29801 Py_INCREF(obj);
29802 return Py_BuildValue((char *)"");
29803 }
29804 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
29805 PyObject *resultobj = NULL;
29806 wxDragResult arg1 ;
29807 bool result;
29808 PyObject * obj0 = 0 ;
29809 char *kwnames[] = {
29810 (char *) "res", NULL
29811 };
29812
29813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
29814 {
29815 arg1 = static_cast<wxDragResult >(SWIG_As_int(obj0));
29816 if (SWIG_arg_fail(1)) SWIG_fail;
29817 }
29818 {
29819 PyThreadState* __tstate = wxPyBeginAllowThreads();
29820 result = (bool)wxIsDragResultOk(arg1);
29821
29822 wxPyEndAllowThreads(__tstate);
29823 if (PyErr_Occurred()) SWIG_fail;
29824 }
29825 {
29826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29827 }
29828 return resultobj;
29829 fail:
29830 return NULL;
29831 }
29832
29833
29834 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
29835 PyObject *resultobj = NULL;
29836 wxWindow *arg1 = (wxWindow *) 0 ;
29837 wxCursor const &arg2_defvalue = wxNullCursor ;
29838 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
29839 wxCursor const &arg3_defvalue = wxNullCursor ;
29840 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
29841 wxCursor const &arg4_defvalue = wxNullCursor ;
29842 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
29843 wxPyDropSource *result;
29844 PyObject * obj0 = 0 ;
29845 PyObject * obj1 = 0 ;
29846 PyObject * obj2 = 0 ;
29847 PyObject * obj3 = 0 ;
29848 char *kwnames[] = {
29849 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
29850 };
29851
29852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29854 if (SWIG_arg_fail(1)) SWIG_fail;
29855 if (obj1) {
29856 {
29857 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29858 if (SWIG_arg_fail(2)) SWIG_fail;
29859 if (arg2 == NULL) {
29860 SWIG_null_ref("wxCursor");
29861 }
29862 if (SWIG_arg_fail(2)) SWIG_fail;
29863 }
29864 }
29865 if (obj2) {
29866 {
29867 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29868 if (SWIG_arg_fail(3)) SWIG_fail;
29869 if (arg3 == NULL) {
29870 SWIG_null_ref("wxCursor");
29871 }
29872 if (SWIG_arg_fail(3)) SWIG_fail;
29873 }
29874 }
29875 if (obj3) {
29876 {
29877 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29878 if (SWIG_arg_fail(4)) SWIG_fail;
29879 if (arg4 == NULL) {
29880 SWIG_null_ref("wxCursor");
29881 }
29882 if (SWIG_arg_fail(4)) SWIG_fail;
29883 }
29884 }
29885 {
29886 PyThreadState* __tstate = wxPyBeginAllowThreads();
29887 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
29888
29889 wxPyEndAllowThreads(__tstate);
29890 if (PyErr_Occurred()) SWIG_fail;
29891 }
29892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
29893 return resultobj;
29894 fail:
29895 return NULL;
29896 }
29897
29898
29899 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29900 PyObject *resultobj = NULL;
29901 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29902 PyObject *arg2 = (PyObject *) 0 ;
29903 PyObject *arg3 = (PyObject *) 0 ;
29904 int arg4 ;
29905 PyObject * obj0 = 0 ;
29906 PyObject * obj1 = 0 ;
29907 PyObject * obj2 = 0 ;
29908 PyObject * obj3 = 0 ;
29909 char *kwnames[] = {
29910 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
29911 };
29912
29913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29915 if (SWIG_arg_fail(1)) SWIG_fail;
29916 arg2 = obj1;
29917 arg3 = obj2;
29918 {
29919 arg4 = static_cast<int >(SWIG_As_int(obj3));
29920 if (SWIG_arg_fail(4)) SWIG_fail;
29921 }
29922 {
29923 PyThreadState* __tstate = wxPyBeginAllowThreads();
29924 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
29925
29926 wxPyEndAllowThreads(__tstate);
29927 if (PyErr_Occurred()) SWIG_fail;
29928 }
29929 Py_INCREF(Py_None); resultobj = Py_None;
29930 return resultobj;
29931 fail:
29932 return NULL;
29933 }
29934
29935
29936 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
29937 PyObject *resultobj = NULL;
29938 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29939 PyObject * obj0 = 0 ;
29940 char *kwnames[] = {
29941 (char *) "self", NULL
29942 };
29943
29944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
29945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29946 if (SWIG_arg_fail(1)) SWIG_fail;
29947 {
29948 PyThreadState* __tstate = wxPyBeginAllowThreads();
29949 delete arg1;
29950
29951 wxPyEndAllowThreads(__tstate);
29952 if (PyErr_Occurred()) SWIG_fail;
29953 }
29954 Py_INCREF(Py_None); resultobj = Py_None;
29955 return resultobj;
29956 fail:
29957 return NULL;
29958 }
29959
29960
29961 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29962 PyObject *resultobj = NULL;
29963 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29964 wxDataObject *arg2 = 0 ;
29965 PyObject * obj0 = 0 ;
29966 PyObject * obj1 = 0 ;
29967 char *kwnames[] = {
29968 (char *) "self",(char *) "data", NULL
29969 };
29970
29971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
29972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29973 if (SWIG_arg_fail(1)) SWIG_fail;
29974 {
29975 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29976 if (SWIG_arg_fail(2)) SWIG_fail;
29977 if (arg2 == NULL) {
29978 SWIG_null_ref("wxDataObject");
29979 }
29980 if (SWIG_arg_fail(2)) SWIG_fail;
29981 }
29982 {
29983 PyThreadState* __tstate = wxPyBeginAllowThreads();
29984 (arg1)->SetData(*arg2);
29985
29986 wxPyEndAllowThreads(__tstate);
29987 if (PyErr_Occurred()) SWIG_fail;
29988 }
29989 Py_INCREF(Py_None); resultobj = Py_None;
29990 return resultobj;
29991 fail:
29992 return NULL;
29993 }
29994
29995
29996 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29997 PyObject *resultobj = NULL;
29998 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29999 wxDataObject *result;
30000 PyObject * obj0 = 0 ;
30001 char *kwnames[] = {
30002 (char *) "self", NULL
30003 };
30004
30005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
30006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
30007 if (SWIG_arg_fail(1)) SWIG_fail;
30008 {
30009 PyThreadState* __tstate = wxPyBeginAllowThreads();
30010 result = (wxDataObject *)(arg1)->GetDataObject();
30011
30012 wxPyEndAllowThreads(__tstate);
30013 if (PyErr_Occurred()) SWIG_fail;
30014 }
30015 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
30016 return resultobj;
30017 fail:
30018 return NULL;
30019 }
30020
30021
30022 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30023 PyObject *resultobj = NULL;
30024 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
30025 wxDragResult arg2 ;
30026 wxCursor *arg3 = 0 ;
30027 PyObject * obj0 = 0 ;
30028 PyObject * obj1 = 0 ;
30029 PyObject * obj2 = 0 ;
30030 char *kwnames[] = {
30031 (char *) "self",(char *) "res",(char *) "cursor", NULL
30032 };
30033
30034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
30035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
30036 if (SWIG_arg_fail(1)) SWIG_fail;
30037 {
30038 arg2 = static_cast<wxDragResult >(SWIG_As_int(obj1));
30039 if (SWIG_arg_fail(2)) SWIG_fail;
30040 }
30041 {
30042 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30043 if (SWIG_arg_fail(3)) SWIG_fail;
30044 if (arg3 == NULL) {
30045 SWIG_null_ref("wxCursor");
30046 }
30047 if (SWIG_arg_fail(3)) SWIG_fail;
30048 }
30049 {
30050 PyThreadState* __tstate = wxPyBeginAllowThreads();
30051 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
30052
30053 wxPyEndAllowThreads(__tstate);
30054 if (PyErr_Occurred()) SWIG_fail;
30055 }
30056 Py_INCREF(Py_None); resultobj = Py_None;
30057 return resultobj;
30058 fail:
30059 return NULL;
30060 }
30061
30062
30063 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
30064 PyObject *resultobj = NULL;
30065 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
30066 int arg2 = (int) wxDrag_CopyOnly ;
30067 wxDragResult result;
30068 PyObject * obj0 = 0 ;
30069 PyObject * obj1 = 0 ;
30070 char *kwnames[] = {
30071 (char *) "self",(char *) "flags", NULL
30072 };
30073
30074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
30075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
30076 if (SWIG_arg_fail(1)) SWIG_fail;
30077 if (obj1) {
30078 {
30079 arg2 = static_cast<int >(SWIG_As_int(obj1));
30080 if (SWIG_arg_fail(2)) SWIG_fail;
30081 }
30082 }
30083 {
30084 PyThreadState* __tstate = wxPyBeginAllowThreads();
30085 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
30086
30087 wxPyEndAllowThreads(__tstate);
30088 if (PyErr_Occurred()) SWIG_fail;
30089 }
30090 resultobj = SWIG_From_int((result));
30091 return resultobj;
30092 fail:
30093 return NULL;
30094 }
30095
30096
30097 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
30098 PyObject *resultobj = NULL;
30099 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
30100 wxDragResult arg2 ;
30101 bool result;
30102 PyObject * obj0 = 0 ;
30103 PyObject * obj1 = 0 ;
30104 char *kwnames[] = {
30105 (char *) "self",(char *) "effect", NULL
30106 };
30107
30108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
30109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
30110 if (SWIG_arg_fail(1)) SWIG_fail;
30111 {
30112 arg2 = static_cast<wxDragResult >(SWIG_As_int(obj1));
30113 if (SWIG_arg_fail(2)) SWIG_fail;
30114 }
30115 {
30116 PyThreadState* __tstate = wxPyBeginAllowThreads();
30117 result = (bool)(arg1)->base_GiveFeedback(arg2);
30118
30119 wxPyEndAllowThreads(__tstate);
30120 if (PyErr_Occurred()) SWIG_fail;
30121 }
30122 {
30123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30124 }
30125 return resultobj;
30126 fail:
30127 return NULL;
30128 }
30129
30130
30131 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
30132 PyObject *obj;
30133 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30134 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
30135 Py_INCREF(obj);
30136 return Py_BuildValue((char *)"");
30137 }
30138 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30139 PyObject *resultobj = NULL;
30140 wxDataObject *arg1 = (wxDataObject *) NULL ;
30141 wxPyDropTarget *result;
30142 PyObject * obj0 = 0 ;
30143 char *kwnames[] = {
30144 (char *) "dataObject", NULL
30145 };
30146
30147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
30148 if (obj0) {
30149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30150 if (SWIG_arg_fail(1)) SWIG_fail;
30151 }
30152 {
30153 PyThreadState* __tstate = wxPyBeginAllowThreads();
30154 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
30155
30156 wxPyEndAllowThreads(__tstate);
30157 if (PyErr_Occurred()) SWIG_fail;
30158 }
30159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
30160 return resultobj;
30161 fail:
30162 return NULL;
30163 }
30164
30165
30166 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
30167 PyObject *resultobj = NULL;
30168 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30169 PyObject *arg2 = (PyObject *) 0 ;
30170 PyObject *arg3 = (PyObject *) 0 ;
30171 PyObject * obj0 = 0 ;
30172 PyObject * obj1 = 0 ;
30173 PyObject * obj2 = 0 ;
30174 char *kwnames[] = {
30175 (char *) "self",(char *) "self",(char *) "_class", NULL
30176 };
30177
30178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
30179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30180 if (SWIG_arg_fail(1)) SWIG_fail;
30181 arg2 = obj1;
30182 arg3 = obj2;
30183 {
30184 PyThreadState* __tstate = wxPyBeginAllowThreads();
30185 (arg1)->_setCallbackInfo(arg2,arg3);
30186
30187 wxPyEndAllowThreads(__tstate);
30188 if (PyErr_Occurred()) SWIG_fail;
30189 }
30190 Py_INCREF(Py_None); resultobj = Py_None;
30191 return resultobj;
30192 fail:
30193 return NULL;
30194 }
30195
30196
30197 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30198 PyObject *resultobj = NULL;
30199 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30200 PyObject * obj0 = 0 ;
30201 char *kwnames[] = {
30202 (char *) "self", NULL
30203 };
30204
30205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
30206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30207 if (SWIG_arg_fail(1)) SWIG_fail;
30208 {
30209 PyThreadState* __tstate = wxPyBeginAllowThreads();
30210 delete arg1;
30211
30212 wxPyEndAllowThreads(__tstate);
30213 if (PyErr_Occurred()) SWIG_fail;
30214 }
30215 Py_INCREF(Py_None); resultobj = Py_None;
30216 return resultobj;
30217 fail:
30218 return NULL;
30219 }
30220
30221
30222 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
30223 PyObject *resultobj = NULL;
30224 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30225 wxDataObject *result;
30226 PyObject * obj0 = 0 ;
30227 char *kwnames[] = {
30228 (char *) "self", NULL
30229 };
30230
30231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
30232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30233 if (SWIG_arg_fail(1)) SWIG_fail;
30234 {
30235 PyThreadState* __tstate = wxPyBeginAllowThreads();
30236 result = (wxDataObject *)(arg1)->GetDataObject();
30237
30238 wxPyEndAllowThreads(__tstate);
30239 if (PyErr_Occurred()) SWIG_fail;
30240 }
30241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
30242 return resultobj;
30243 fail:
30244 return NULL;
30245 }
30246
30247
30248 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
30249 PyObject *resultobj = NULL;
30250 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30251 wxDataObject *arg2 = (wxDataObject *) 0 ;
30252 PyObject * obj0 = 0 ;
30253 PyObject * obj1 = 0 ;
30254 char *kwnames[] = {
30255 (char *) "self",(char *) "dataObject", NULL
30256 };
30257
30258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
30259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30260 if (SWIG_arg_fail(1)) SWIG_fail;
30261 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30262 if (SWIG_arg_fail(2)) SWIG_fail;
30263 {
30264 PyThreadState* __tstate = wxPyBeginAllowThreads();
30265 (arg1)->SetDataObject(arg2);
30266
30267 wxPyEndAllowThreads(__tstate);
30268 if (PyErr_Occurred()) SWIG_fail;
30269 }
30270 Py_INCREF(Py_None); resultobj = Py_None;
30271 return resultobj;
30272 fail:
30273 return NULL;
30274 }
30275
30276
30277 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
30278 PyObject *resultobj = NULL;
30279 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30280 int arg2 ;
30281 int arg3 ;
30282 wxDragResult arg4 ;
30283 wxDragResult result;
30284 PyObject * obj0 = 0 ;
30285 PyObject * obj1 = 0 ;
30286 PyObject * obj2 = 0 ;
30287 PyObject * obj3 = 0 ;
30288 char *kwnames[] = {
30289 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30290 };
30291
30292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30294 if (SWIG_arg_fail(1)) SWIG_fail;
30295 {
30296 arg2 = static_cast<int >(SWIG_As_int(obj1));
30297 if (SWIG_arg_fail(2)) SWIG_fail;
30298 }
30299 {
30300 arg3 = static_cast<int >(SWIG_As_int(obj2));
30301 if (SWIG_arg_fail(3)) SWIG_fail;
30302 }
30303 {
30304 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30305 if (SWIG_arg_fail(4)) SWIG_fail;
30306 }
30307 {
30308 PyThreadState* __tstate = wxPyBeginAllowThreads();
30309 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,arg4);
30310
30311 wxPyEndAllowThreads(__tstate);
30312 if (PyErr_Occurred()) SWIG_fail;
30313 }
30314 resultobj = SWIG_From_int((result));
30315 return resultobj;
30316 fail:
30317 return NULL;
30318 }
30319
30320
30321 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
30322 PyObject *resultobj = NULL;
30323 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30324 int arg2 ;
30325 int arg3 ;
30326 wxDragResult arg4 ;
30327 wxDragResult result;
30328 PyObject * obj0 = 0 ;
30329 PyObject * obj1 = 0 ;
30330 PyObject * obj2 = 0 ;
30331 PyObject * obj3 = 0 ;
30332 char *kwnames[] = {
30333 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30334 };
30335
30336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30338 if (SWIG_arg_fail(1)) SWIG_fail;
30339 {
30340 arg2 = static_cast<int >(SWIG_As_int(obj1));
30341 if (SWIG_arg_fail(2)) SWIG_fail;
30342 }
30343 {
30344 arg3 = static_cast<int >(SWIG_As_int(obj2));
30345 if (SWIG_arg_fail(3)) SWIG_fail;
30346 }
30347 {
30348 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30349 if (SWIG_arg_fail(4)) SWIG_fail;
30350 }
30351 {
30352 PyThreadState* __tstate = wxPyBeginAllowThreads();
30353 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,arg4);
30354
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 resultobj = SWIG_From_int((result));
30359 return resultobj;
30360 fail:
30361 return NULL;
30362 }
30363
30364
30365 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
30366 PyObject *resultobj = NULL;
30367 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30368 PyObject * obj0 = 0 ;
30369 char *kwnames[] = {
30370 (char *) "self", NULL
30371 };
30372
30373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
30374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30375 if (SWIG_arg_fail(1)) SWIG_fail;
30376 {
30377 PyThreadState* __tstate = wxPyBeginAllowThreads();
30378 (arg1)->base_OnLeave();
30379
30380 wxPyEndAllowThreads(__tstate);
30381 if (PyErr_Occurred()) SWIG_fail;
30382 }
30383 Py_INCREF(Py_None); resultobj = Py_None;
30384 return resultobj;
30385 fail:
30386 return NULL;
30387 }
30388
30389
30390 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
30391 PyObject *resultobj = NULL;
30392 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30393 int arg2 ;
30394 int arg3 ;
30395 bool result;
30396 PyObject * obj0 = 0 ;
30397 PyObject * obj1 = 0 ;
30398 PyObject * obj2 = 0 ;
30399 char *kwnames[] = {
30400 (char *) "self",(char *) "x",(char *) "y", NULL
30401 };
30402
30403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
30404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30405 if (SWIG_arg_fail(1)) SWIG_fail;
30406 {
30407 arg2 = static_cast<int >(SWIG_As_int(obj1));
30408 if (SWIG_arg_fail(2)) SWIG_fail;
30409 }
30410 {
30411 arg3 = static_cast<int >(SWIG_As_int(obj2));
30412 if (SWIG_arg_fail(3)) SWIG_fail;
30413 }
30414 {
30415 PyThreadState* __tstate = wxPyBeginAllowThreads();
30416 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
30417
30418 wxPyEndAllowThreads(__tstate);
30419 if (PyErr_Occurred()) SWIG_fail;
30420 }
30421 {
30422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30423 }
30424 return resultobj;
30425 fail:
30426 return NULL;
30427 }
30428
30429
30430 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30431 PyObject *resultobj = NULL;
30432 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30433 bool result;
30434 PyObject * obj0 = 0 ;
30435 char *kwnames[] = {
30436 (char *) "self", NULL
30437 };
30438
30439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
30440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30441 if (SWIG_arg_fail(1)) SWIG_fail;
30442 {
30443 PyThreadState* __tstate = wxPyBeginAllowThreads();
30444 result = (bool)(arg1)->GetData();
30445
30446 wxPyEndAllowThreads(__tstate);
30447 if (PyErr_Occurred()) SWIG_fail;
30448 }
30449 {
30450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30451 }
30452 return resultobj;
30453 fail:
30454 return NULL;
30455 }
30456
30457
30458 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
30459 PyObject *resultobj = NULL;
30460 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30461 wxDragResult arg2 ;
30462 PyObject * obj0 = 0 ;
30463 PyObject * obj1 = 0 ;
30464 char *kwnames[] = {
30465 (char *) "self",(char *) "action", NULL
30466 };
30467
30468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
30469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30470 if (SWIG_arg_fail(1)) SWIG_fail;
30471 {
30472 arg2 = static_cast<wxDragResult >(SWIG_As_int(obj1));
30473 if (SWIG_arg_fail(2)) SWIG_fail;
30474 }
30475 {
30476 PyThreadState* __tstate = wxPyBeginAllowThreads();
30477 (arg1)->SetDefaultAction(arg2);
30478
30479 wxPyEndAllowThreads(__tstate);
30480 if (PyErr_Occurred()) SWIG_fail;
30481 }
30482 Py_INCREF(Py_None); resultobj = Py_None;
30483 return resultobj;
30484 fail:
30485 return NULL;
30486 }
30487
30488
30489 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
30490 PyObject *resultobj = NULL;
30491 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30492 wxDragResult result;
30493 PyObject * obj0 = 0 ;
30494 char *kwnames[] = {
30495 (char *) "self", NULL
30496 };
30497
30498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
30499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30500 if (SWIG_arg_fail(1)) SWIG_fail;
30501 {
30502 PyThreadState* __tstate = wxPyBeginAllowThreads();
30503 result = (wxDragResult)(arg1)->GetDefaultAction();
30504
30505 wxPyEndAllowThreads(__tstate);
30506 if (PyErr_Occurred()) SWIG_fail;
30507 }
30508 resultobj = SWIG_From_int((result));
30509 return resultobj;
30510 fail:
30511 return NULL;
30512 }
30513
30514
30515 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
30516 PyObject *obj;
30517 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30518 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
30519 Py_INCREF(obj);
30520 return Py_BuildValue((char *)"");
30521 }
30522 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30523 PyObject *resultobj = NULL;
30524 wxPyTextDropTarget *result;
30525 char *kwnames[] = {
30526 NULL
30527 };
30528
30529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
30530 {
30531 PyThreadState* __tstate = wxPyBeginAllowThreads();
30532 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
30533
30534 wxPyEndAllowThreads(__tstate);
30535 if (PyErr_Occurred()) SWIG_fail;
30536 }
30537 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
30538 return resultobj;
30539 fail:
30540 return NULL;
30541 }
30542
30543
30544 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
30545 PyObject *resultobj = NULL;
30546 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30547 PyObject *arg2 = (PyObject *) 0 ;
30548 PyObject *arg3 = (PyObject *) 0 ;
30549 PyObject * obj0 = 0 ;
30550 PyObject * obj1 = 0 ;
30551 PyObject * obj2 = 0 ;
30552 char *kwnames[] = {
30553 (char *) "self",(char *) "self",(char *) "_class", NULL
30554 };
30555
30556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
30557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30558 if (SWIG_arg_fail(1)) SWIG_fail;
30559 arg2 = obj1;
30560 arg3 = obj2;
30561 {
30562 PyThreadState* __tstate = wxPyBeginAllowThreads();
30563 (arg1)->_setCallbackInfo(arg2,arg3);
30564
30565 wxPyEndAllowThreads(__tstate);
30566 if (PyErr_Occurred()) SWIG_fail;
30567 }
30568 Py_INCREF(Py_None); resultobj = Py_None;
30569 return resultobj;
30570 fail:
30571 return NULL;
30572 }
30573
30574
30575 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
30576 PyObject *resultobj = NULL;
30577 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30578 int arg2 ;
30579 int arg3 ;
30580 wxDragResult arg4 ;
30581 wxDragResult result;
30582 PyObject * obj0 = 0 ;
30583 PyObject * obj1 = 0 ;
30584 PyObject * obj2 = 0 ;
30585 PyObject * obj3 = 0 ;
30586 char *kwnames[] = {
30587 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30588 };
30589
30590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30592 if (SWIG_arg_fail(1)) SWIG_fail;
30593 {
30594 arg2 = static_cast<int >(SWIG_As_int(obj1));
30595 if (SWIG_arg_fail(2)) SWIG_fail;
30596 }
30597 {
30598 arg3 = static_cast<int >(SWIG_As_int(obj2));
30599 if (SWIG_arg_fail(3)) SWIG_fail;
30600 }
30601 {
30602 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30603 if (SWIG_arg_fail(4)) SWIG_fail;
30604 }
30605 {
30606 PyThreadState* __tstate = wxPyBeginAllowThreads();
30607 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,arg4);
30608
30609 wxPyEndAllowThreads(__tstate);
30610 if (PyErr_Occurred()) SWIG_fail;
30611 }
30612 resultobj = SWIG_From_int((result));
30613 return resultobj;
30614 fail:
30615 return NULL;
30616 }
30617
30618
30619 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
30620 PyObject *resultobj = NULL;
30621 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30622 int arg2 ;
30623 int arg3 ;
30624 wxDragResult arg4 ;
30625 wxDragResult result;
30626 PyObject * obj0 = 0 ;
30627 PyObject * obj1 = 0 ;
30628 PyObject * obj2 = 0 ;
30629 PyObject * obj3 = 0 ;
30630 char *kwnames[] = {
30631 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30632 };
30633
30634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30636 if (SWIG_arg_fail(1)) SWIG_fail;
30637 {
30638 arg2 = static_cast<int >(SWIG_As_int(obj1));
30639 if (SWIG_arg_fail(2)) SWIG_fail;
30640 }
30641 {
30642 arg3 = static_cast<int >(SWIG_As_int(obj2));
30643 if (SWIG_arg_fail(3)) SWIG_fail;
30644 }
30645 {
30646 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30647 if (SWIG_arg_fail(4)) SWIG_fail;
30648 }
30649 {
30650 PyThreadState* __tstate = wxPyBeginAllowThreads();
30651 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,arg4);
30652
30653 wxPyEndAllowThreads(__tstate);
30654 if (PyErr_Occurred()) SWIG_fail;
30655 }
30656 resultobj = SWIG_From_int((result));
30657 return resultobj;
30658 fail:
30659 return NULL;
30660 }
30661
30662
30663 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
30664 PyObject *resultobj = NULL;
30665 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30666 PyObject * obj0 = 0 ;
30667 char *kwnames[] = {
30668 (char *) "self", NULL
30669 };
30670
30671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
30672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30673 if (SWIG_arg_fail(1)) SWIG_fail;
30674 {
30675 PyThreadState* __tstate = wxPyBeginAllowThreads();
30676 (arg1)->base_OnLeave();
30677
30678 wxPyEndAllowThreads(__tstate);
30679 if (PyErr_Occurred()) SWIG_fail;
30680 }
30681 Py_INCREF(Py_None); resultobj = Py_None;
30682 return resultobj;
30683 fail:
30684 return NULL;
30685 }
30686
30687
30688 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
30689 PyObject *resultobj = NULL;
30690 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30691 int arg2 ;
30692 int arg3 ;
30693 bool result;
30694 PyObject * obj0 = 0 ;
30695 PyObject * obj1 = 0 ;
30696 PyObject * obj2 = 0 ;
30697 char *kwnames[] = {
30698 (char *) "self",(char *) "x",(char *) "y", NULL
30699 };
30700
30701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
30702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30703 if (SWIG_arg_fail(1)) SWIG_fail;
30704 {
30705 arg2 = static_cast<int >(SWIG_As_int(obj1));
30706 if (SWIG_arg_fail(2)) SWIG_fail;
30707 }
30708 {
30709 arg3 = static_cast<int >(SWIG_As_int(obj2));
30710 if (SWIG_arg_fail(3)) SWIG_fail;
30711 }
30712 {
30713 PyThreadState* __tstate = wxPyBeginAllowThreads();
30714 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
30715
30716 wxPyEndAllowThreads(__tstate);
30717 if (PyErr_Occurred()) SWIG_fail;
30718 }
30719 {
30720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30721 }
30722 return resultobj;
30723 fail:
30724 return NULL;
30725 }
30726
30727
30728 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
30729 PyObject *resultobj = NULL;
30730 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30731 int arg2 ;
30732 int arg3 ;
30733 wxDragResult arg4 ;
30734 wxDragResult result;
30735 PyObject * obj0 = 0 ;
30736 PyObject * obj1 = 0 ;
30737 PyObject * obj2 = 0 ;
30738 PyObject * obj3 = 0 ;
30739 char *kwnames[] = {
30740 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30741 };
30742
30743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30745 if (SWIG_arg_fail(1)) SWIG_fail;
30746 {
30747 arg2 = static_cast<int >(SWIG_As_int(obj1));
30748 if (SWIG_arg_fail(2)) SWIG_fail;
30749 }
30750 {
30751 arg3 = static_cast<int >(SWIG_As_int(obj2));
30752 if (SWIG_arg_fail(3)) SWIG_fail;
30753 }
30754 {
30755 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30756 if (SWIG_arg_fail(4)) SWIG_fail;
30757 }
30758 {
30759 PyThreadState* __tstate = wxPyBeginAllowThreads();
30760 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,arg4);
30761
30762 wxPyEndAllowThreads(__tstate);
30763 if (PyErr_Occurred()) SWIG_fail;
30764 }
30765 resultobj = SWIG_From_int((result));
30766 return resultobj;
30767 fail:
30768 return NULL;
30769 }
30770
30771
30772 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
30773 PyObject *obj;
30774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30775 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
30776 Py_INCREF(obj);
30777 return Py_BuildValue((char *)"");
30778 }
30779 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30780 PyObject *resultobj = NULL;
30781 wxPyFileDropTarget *result;
30782 char *kwnames[] = {
30783 NULL
30784 };
30785
30786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
30787 {
30788 PyThreadState* __tstate = wxPyBeginAllowThreads();
30789 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
30790
30791 wxPyEndAllowThreads(__tstate);
30792 if (PyErr_Occurred()) SWIG_fail;
30793 }
30794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
30795 return resultobj;
30796 fail:
30797 return NULL;
30798 }
30799
30800
30801 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
30802 PyObject *resultobj = NULL;
30803 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30804 PyObject *arg2 = (PyObject *) 0 ;
30805 PyObject *arg3 = (PyObject *) 0 ;
30806 PyObject * obj0 = 0 ;
30807 PyObject * obj1 = 0 ;
30808 PyObject * obj2 = 0 ;
30809 char *kwnames[] = {
30810 (char *) "self",(char *) "self",(char *) "_class", NULL
30811 };
30812
30813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
30814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30815 if (SWIG_arg_fail(1)) SWIG_fail;
30816 arg2 = obj1;
30817 arg3 = obj2;
30818 {
30819 PyThreadState* __tstate = wxPyBeginAllowThreads();
30820 (arg1)->_setCallbackInfo(arg2,arg3);
30821
30822 wxPyEndAllowThreads(__tstate);
30823 if (PyErr_Occurred()) SWIG_fail;
30824 }
30825 Py_INCREF(Py_None); resultobj = Py_None;
30826 return resultobj;
30827 fail:
30828 return NULL;
30829 }
30830
30831
30832 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
30833 PyObject *resultobj = NULL;
30834 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30835 int arg2 ;
30836 int arg3 ;
30837 wxDragResult arg4 ;
30838 wxDragResult result;
30839 PyObject * obj0 = 0 ;
30840 PyObject * obj1 = 0 ;
30841 PyObject * obj2 = 0 ;
30842 PyObject * obj3 = 0 ;
30843 char *kwnames[] = {
30844 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30845 };
30846
30847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30849 if (SWIG_arg_fail(1)) SWIG_fail;
30850 {
30851 arg2 = static_cast<int >(SWIG_As_int(obj1));
30852 if (SWIG_arg_fail(2)) SWIG_fail;
30853 }
30854 {
30855 arg3 = static_cast<int >(SWIG_As_int(obj2));
30856 if (SWIG_arg_fail(3)) SWIG_fail;
30857 }
30858 {
30859 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30860 if (SWIG_arg_fail(4)) SWIG_fail;
30861 }
30862 {
30863 PyThreadState* __tstate = wxPyBeginAllowThreads();
30864 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,arg4);
30865
30866 wxPyEndAllowThreads(__tstate);
30867 if (PyErr_Occurred()) SWIG_fail;
30868 }
30869 resultobj = SWIG_From_int((result));
30870 return resultobj;
30871 fail:
30872 return NULL;
30873 }
30874
30875
30876 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
30877 PyObject *resultobj = NULL;
30878 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30879 int arg2 ;
30880 int arg3 ;
30881 wxDragResult arg4 ;
30882 wxDragResult result;
30883 PyObject * obj0 = 0 ;
30884 PyObject * obj1 = 0 ;
30885 PyObject * obj2 = 0 ;
30886 PyObject * obj3 = 0 ;
30887 char *kwnames[] = {
30888 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30889 };
30890
30891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30893 if (SWIG_arg_fail(1)) SWIG_fail;
30894 {
30895 arg2 = static_cast<int >(SWIG_As_int(obj1));
30896 if (SWIG_arg_fail(2)) SWIG_fail;
30897 }
30898 {
30899 arg3 = static_cast<int >(SWIG_As_int(obj2));
30900 if (SWIG_arg_fail(3)) SWIG_fail;
30901 }
30902 {
30903 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30904 if (SWIG_arg_fail(4)) SWIG_fail;
30905 }
30906 {
30907 PyThreadState* __tstate = wxPyBeginAllowThreads();
30908 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,arg4);
30909
30910 wxPyEndAllowThreads(__tstate);
30911 if (PyErr_Occurred()) SWIG_fail;
30912 }
30913 resultobj = SWIG_From_int((result));
30914 return resultobj;
30915 fail:
30916 return NULL;
30917 }
30918
30919
30920 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
30921 PyObject *resultobj = NULL;
30922 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30923 PyObject * obj0 = 0 ;
30924 char *kwnames[] = {
30925 (char *) "self", NULL
30926 };
30927
30928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
30929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30930 if (SWIG_arg_fail(1)) SWIG_fail;
30931 {
30932 PyThreadState* __tstate = wxPyBeginAllowThreads();
30933 (arg1)->base_OnLeave();
30934
30935 wxPyEndAllowThreads(__tstate);
30936 if (PyErr_Occurred()) SWIG_fail;
30937 }
30938 Py_INCREF(Py_None); resultobj = Py_None;
30939 return resultobj;
30940 fail:
30941 return NULL;
30942 }
30943
30944
30945 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
30946 PyObject *resultobj = NULL;
30947 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30948 int arg2 ;
30949 int arg3 ;
30950 bool result;
30951 PyObject * obj0 = 0 ;
30952 PyObject * obj1 = 0 ;
30953 PyObject * obj2 = 0 ;
30954 char *kwnames[] = {
30955 (char *) "self",(char *) "x",(char *) "y", NULL
30956 };
30957
30958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
30959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30960 if (SWIG_arg_fail(1)) SWIG_fail;
30961 {
30962 arg2 = static_cast<int >(SWIG_As_int(obj1));
30963 if (SWIG_arg_fail(2)) SWIG_fail;
30964 }
30965 {
30966 arg3 = static_cast<int >(SWIG_As_int(obj2));
30967 if (SWIG_arg_fail(3)) SWIG_fail;
30968 }
30969 {
30970 PyThreadState* __tstate = wxPyBeginAllowThreads();
30971 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
30972
30973 wxPyEndAllowThreads(__tstate);
30974 if (PyErr_Occurred()) SWIG_fail;
30975 }
30976 {
30977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30978 }
30979 return resultobj;
30980 fail:
30981 return NULL;
30982 }
30983
30984
30985 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
30986 PyObject *resultobj = NULL;
30987 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30988 int arg2 ;
30989 int arg3 ;
30990 wxDragResult arg4 ;
30991 wxDragResult result;
30992 PyObject * obj0 = 0 ;
30993 PyObject * obj1 = 0 ;
30994 PyObject * obj2 = 0 ;
30995 PyObject * obj3 = 0 ;
30996 char *kwnames[] = {
30997 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30998 };
30999
31000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
31002 if (SWIG_arg_fail(1)) SWIG_fail;
31003 {
31004 arg2 = static_cast<int >(SWIG_As_int(obj1));
31005 if (SWIG_arg_fail(2)) SWIG_fail;
31006 }
31007 {
31008 arg3 = static_cast<int >(SWIG_As_int(obj2));
31009 if (SWIG_arg_fail(3)) SWIG_fail;
31010 }
31011 {
31012 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
31013 if (SWIG_arg_fail(4)) SWIG_fail;
31014 }
31015 {
31016 PyThreadState* __tstate = wxPyBeginAllowThreads();
31017 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,arg4);
31018
31019 wxPyEndAllowThreads(__tstate);
31020 if (PyErr_Occurred()) SWIG_fail;
31021 }
31022 resultobj = SWIG_From_int((result));
31023 return resultobj;
31024 fail:
31025 return NULL;
31026 }
31027
31028
31029 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
31030 PyObject *obj;
31031 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31032 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
31033 Py_INCREF(obj);
31034 return Py_BuildValue((char *)"");
31035 }
31036 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
31037 PyObject *resultobj = NULL;
31038 wxClipboard *result;
31039 char *kwnames[] = {
31040 NULL
31041 };
31042
31043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
31044 {
31045 PyThreadState* __tstate = wxPyBeginAllowThreads();
31046 result = (wxClipboard *)new wxClipboard();
31047
31048 wxPyEndAllowThreads(__tstate);
31049 if (PyErr_Occurred()) SWIG_fail;
31050 }
31051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
31052 return resultobj;
31053 fail:
31054 return NULL;
31055 }
31056
31057
31058 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
31059 PyObject *resultobj = NULL;
31060 wxClipboard *arg1 = (wxClipboard *) 0 ;
31061 PyObject * obj0 = 0 ;
31062 char *kwnames[] = {
31063 (char *) "self", NULL
31064 };
31065
31066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
31067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31068 if (SWIG_arg_fail(1)) SWIG_fail;
31069 {
31070 PyThreadState* __tstate = wxPyBeginAllowThreads();
31071 delete arg1;
31072
31073 wxPyEndAllowThreads(__tstate);
31074 if (PyErr_Occurred()) SWIG_fail;
31075 }
31076 Py_INCREF(Py_None); resultobj = Py_None;
31077 return resultobj;
31078 fail:
31079 return NULL;
31080 }
31081
31082
31083 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
31084 PyObject *resultobj = NULL;
31085 wxClipboard *arg1 = (wxClipboard *) 0 ;
31086 bool result;
31087 PyObject * obj0 = 0 ;
31088 char *kwnames[] = {
31089 (char *) "self", NULL
31090 };
31091
31092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
31093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31094 if (SWIG_arg_fail(1)) SWIG_fail;
31095 {
31096 PyThreadState* __tstate = wxPyBeginAllowThreads();
31097 result = (bool)(arg1)->Open();
31098
31099 wxPyEndAllowThreads(__tstate);
31100 if (PyErr_Occurred()) SWIG_fail;
31101 }
31102 {
31103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31104 }
31105 return resultobj;
31106 fail:
31107 return NULL;
31108 }
31109
31110
31111 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
31112 PyObject *resultobj = NULL;
31113 wxClipboard *arg1 = (wxClipboard *) 0 ;
31114 PyObject * obj0 = 0 ;
31115 char *kwnames[] = {
31116 (char *) "self", NULL
31117 };
31118
31119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
31120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31121 if (SWIG_arg_fail(1)) SWIG_fail;
31122 {
31123 PyThreadState* __tstate = wxPyBeginAllowThreads();
31124 (arg1)->Close();
31125
31126 wxPyEndAllowThreads(__tstate);
31127 if (PyErr_Occurred()) SWIG_fail;
31128 }
31129 Py_INCREF(Py_None); resultobj = Py_None;
31130 return resultobj;
31131 fail:
31132 return NULL;
31133 }
31134
31135
31136 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
31137 PyObject *resultobj = NULL;
31138 wxClipboard *arg1 = (wxClipboard *) 0 ;
31139 bool result;
31140 PyObject * obj0 = 0 ;
31141 char *kwnames[] = {
31142 (char *) "self", NULL
31143 };
31144
31145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
31146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31147 if (SWIG_arg_fail(1)) SWIG_fail;
31148 {
31149 PyThreadState* __tstate = wxPyBeginAllowThreads();
31150 result = (bool)((wxClipboard const *)arg1)->IsOpened();
31151
31152 wxPyEndAllowThreads(__tstate);
31153 if (PyErr_Occurred()) SWIG_fail;
31154 }
31155 {
31156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31157 }
31158 return resultobj;
31159 fail:
31160 return NULL;
31161 }
31162
31163
31164 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
31165 PyObject *resultobj = NULL;
31166 wxClipboard *arg1 = (wxClipboard *) 0 ;
31167 wxDataObject *arg2 = (wxDataObject *) 0 ;
31168 bool result;
31169 PyObject * obj0 = 0 ;
31170 PyObject * obj1 = 0 ;
31171 char *kwnames[] = {
31172 (char *) "self",(char *) "data", NULL
31173 };
31174
31175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
31176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31177 if (SWIG_arg_fail(1)) SWIG_fail;
31178 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31179 if (SWIG_arg_fail(2)) SWIG_fail;
31180 {
31181 PyThreadState* __tstate = wxPyBeginAllowThreads();
31182 result = (bool)(arg1)->AddData(arg2);
31183
31184 wxPyEndAllowThreads(__tstate);
31185 if (PyErr_Occurred()) SWIG_fail;
31186 }
31187 {
31188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31189 }
31190 return resultobj;
31191 fail:
31192 return NULL;
31193 }
31194
31195
31196 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
31197 PyObject *resultobj = NULL;
31198 wxClipboard *arg1 = (wxClipboard *) 0 ;
31199 wxDataObject *arg2 = (wxDataObject *) 0 ;
31200 bool result;
31201 PyObject * obj0 = 0 ;
31202 PyObject * obj1 = 0 ;
31203 char *kwnames[] = {
31204 (char *) "self",(char *) "data", NULL
31205 };
31206
31207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
31208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31209 if (SWIG_arg_fail(1)) SWIG_fail;
31210 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31211 if (SWIG_arg_fail(2)) SWIG_fail;
31212 {
31213 PyThreadState* __tstate = wxPyBeginAllowThreads();
31214 result = (bool)(arg1)->SetData(arg2);
31215
31216 wxPyEndAllowThreads(__tstate);
31217 if (PyErr_Occurred()) SWIG_fail;
31218 }
31219 {
31220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31221 }
31222 return resultobj;
31223 fail:
31224 return NULL;
31225 }
31226
31227
31228 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
31229 PyObject *resultobj = NULL;
31230 wxClipboard *arg1 = (wxClipboard *) 0 ;
31231 wxDataFormat *arg2 = 0 ;
31232 bool result;
31233 PyObject * obj0 = 0 ;
31234 PyObject * obj1 = 0 ;
31235 char *kwnames[] = {
31236 (char *) "self",(char *) "format", NULL
31237 };
31238
31239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
31240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31241 if (SWIG_arg_fail(1)) SWIG_fail;
31242 {
31243 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
31244 if (SWIG_arg_fail(2)) SWIG_fail;
31245 if (arg2 == NULL) {
31246 SWIG_null_ref("wxDataFormat");
31247 }
31248 if (SWIG_arg_fail(2)) SWIG_fail;
31249 }
31250 {
31251 PyThreadState* __tstate = wxPyBeginAllowThreads();
31252 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
31253
31254 wxPyEndAllowThreads(__tstate);
31255 if (PyErr_Occurred()) SWIG_fail;
31256 }
31257 {
31258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31259 }
31260 return resultobj;
31261 fail:
31262 return NULL;
31263 }
31264
31265
31266 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
31267 PyObject *resultobj = NULL;
31268 wxClipboard *arg1 = (wxClipboard *) 0 ;
31269 wxDataObject *arg2 = 0 ;
31270 bool result;
31271 PyObject * obj0 = 0 ;
31272 PyObject * obj1 = 0 ;
31273 char *kwnames[] = {
31274 (char *) "self",(char *) "data", NULL
31275 };
31276
31277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
31278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31279 if (SWIG_arg_fail(1)) SWIG_fail;
31280 {
31281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
31282 if (SWIG_arg_fail(2)) SWIG_fail;
31283 if (arg2 == NULL) {
31284 SWIG_null_ref("wxDataObject");
31285 }
31286 if (SWIG_arg_fail(2)) SWIG_fail;
31287 }
31288 {
31289 PyThreadState* __tstate = wxPyBeginAllowThreads();
31290 result = (bool)(arg1)->GetData(*arg2);
31291
31292 wxPyEndAllowThreads(__tstate);
31293 if (PyErr_Occurred()) SWIG_fail;
31294 }
31295 {
31296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31297 }
31298 return resultobj;
31299 fail:
31300 return NULL;
31301 }
31302
31303
31304 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
31305 PyObject *resultobj = NULL;
31306 wxClipboard *arg1 = (wxClipboard *) 0 ;
31307 PyObject * obj0 = 0 ;
31308 char *kwnames[] = {
31309 (char *) "self", NULL
31310 };
31311
31312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
31313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31314 if (SWIG_arg_fail(1)) SWIG_fail;
31315 {
31316 PyThreadState* __tstate = wxPyBeginAllowThreads();
31317 (arg1)->Clear();
31318
31319 wxPyEndAllowThreads(__tstate);
31320 if (PyErr_Occurred()) SWIG_fail;
31321 }
31322 Py_INCREF(Py_None); resultobj = Py_None;
31323 return resultobj;
31324 fail:
31325 return NULL;
31326 }
31327
31328
31329 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
31330 PyObject *resultobj = NULL;
31331 wxClipboard *arg1 = (wxClipboard *) 0 ;
31332 bool result;
31333 PyObject * obj0 = 0 ;
31334 char *kwnames[] = {
31335 (char *) "self", NULL
31336 };
31337
31338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
31339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31340 if (SWIG_arg_fail(1)) SWIG_fail;
31341 {
31342 PyThreadState* __tstate = wxPyBeginAllowThreads();
31343 result = (bool)(arg1)->Flush();
31344
31345 wxPyEndAllowThreads(__tstate);
31346 if (PyErr_Occurred()) SWIG_fail;
31347 }
31348 {
31349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31350 }
31351 return resultobj;
31352 fail:
31353 return NULL;
31354 }
31355
31356
31357 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
31358 PyObject *resultobj = NULL;
31359 wxClipboard *arg1 = (wxClipboard *) 0 ;
31360 bool arg2 = (bool) true ;
31361 PyObject * obj0 = 0 ;
31362 PyObject * obj1 = 0 ;
31363 char *kwnames[] = {
31364 (char *) "self",(char *) "primary", NULL
31365 };
31366
31367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
31368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31369 if (SWIG_arg_fail(1)) SWIG_fail;
31370 if (obj1) {
31371 {
31372 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
31373 if (SWIG_arg_fail(2)) SWIG_fail;
31374 }
31375 }
31376 {
31377 PyThreadState* __tstate = wxPyBeginAllowThreads();
31378 (arg1)->UsePrimarySelection(arg2);
31379
31380 wxPyEndAllowThreads(__tstate);
31381 if (PyErr_Occurred()) SWIG_fail;
31382 }
31383 Py_INCREF(Py_None); resultobj = Py_None;
31384 return resultobj;
31385 fail:
31386 return NULL;
31387 }
31388
31389
31390 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31391 PyObject *resultobj = NULL;
31392 wxClipboard *result;
31393 char *kwnames[] = {
31394 NULL
31395 };
31396
31397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
31398 {
31399 PyThreadState* __tstate = wxPyBeginAllowThreads();
31400 result = (wxClipboard *)wxClipboard::Get();
31401
31402 wxPyEndAllowThreads(__tstate);
31403 if (PyErr_Occurred()) SWIG_fail;
31404 }
31405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
31406 return resultobj;
31407 fail:
31408 return NULL;
31409 }
31410
31411
31412 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
31413 PyObject *obj;
31414 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31415 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
31416 Py_INCREF(obj);
31417 return Py_BuildValue((char *)"");
31418 }
31419 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
31420 PyObject *resultobj = NULL;
31421 wxClipboard *arg1 = (wxClipboard *) NULL ;
31422 wxClipboardLocker *result;
31423 PyObject * obj0 = 0 ;
31424 char *kwnames[] = {
31425 (char *) "clipboard", NULL
31426 };
31427
31428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
31429 if (obj0) {
31430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31431 if (SWIG_arg_fail(1)) SWIG_fail;
31432 }
31433 {
31434 PyThreadState* __tstate = wxPyBeginAllowThreads();
31435 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
31436
31437 wxPyEndAllowThreads(__tstate);
31438 if (PyErr_Occurred()) SWIG_fail;
31439 }
31440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
31441 return resultobj;
31442 fail:
31443 return NULL;
31444 }
31445
31446
31447 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
31448 PyObject *resultobj = NULL;
31449 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
31450 PyObject * obj0 = 0 ;
31451 char *kwnames[] = {
31452 (char *) "self", NULL
31453 };
31454
31455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
31456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
31457 if (SWIG_arg_fail(1)) SWIG_fail;
31458 {
31459 PyThreadState* __tstate = wxPyBeginAllowThreads();
31460 delete arg1;
31461
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 Py_INCREF(Py_None); resultobj = Py_None;
31466 return resultobj;
31467 fail:
31468 return NULL;
31469 }
31470
31471
31472 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
31473 PyObject *resultobj = NULL;
31474 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
31475 bool result;
31476 PyObject * obj0 = 0 ;
31477 char *kwnames[] = {
31478 (char *) "self", NULL
31479 };
31480
31481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
31482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
31483 if (SWIG_arg_fail(1)) SWIG_fail;
31484 {
31485 PyThreadState* __tstate = wxPyBeginAllowThreads();
31486 result = (bool)wxClipboardLocker___nonzero__(arg1);
31487
31488 wxPyEndAllowThreads(__tstate);
31489 if (PyErr_Occurred()) SWIG_fail;
31490 }
31491 {
31492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31493 }
31494 return resultobj;
31495 fail:
31496 return NULL;
31497 }
31498
31499
31500 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
31501 PyObject *obj;
31502 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31503 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
31504 Py_INCREF(obj);
31505 return Py_BuildValue((char *)"");
31506 }
31507 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
31508 PyObject *resultobj = NULL;
31509 int arg1 = (int) 0 ;
31510 int arg2 = (int) 0 ;
31511 int arg3 = (int) 0 ;
31512 int arg4 = (int) 0 ;
31513 wxVideoMode *result;
31514 PyObject * obj0 = 0 ;
31515 PyObject * obj1 = 0 ;
31516 PyObject * obj2 = 0 ;
31517 PyObject * obj3 = 0 ;
31518 char *kwnames[] = {
31519 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
31520 };
31521
31522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31523 if (obj0) {
31524 {
31525 arg1 = static_cast<int >(SWIG_As_int(obj0));
31526 if (SWIG_arg_fail(1)) SWIG_fail;
31527 }
31528 }
31529 if (obj1) {
31530 {
31531 arg2 = static_cast<int >(SWIG_As_int(obj1));
31532 if (SWIG_arg_fail(2)) SWIG_fail;
31533 }
31534 }
31535 if (obj2) {
31536 {
31537 arg3 = static_cast<int >(SWIG_As_int(obj2));
31538 if (SWIG_arg_fail(3)) SWIG_fail;
31539 }
31540 }
31541 if (obj3) {
31542 {
31543 arg4 = static_cast<int >(SWIG_As_int(obj3));
31544 if (SWIG_arg_fail(4)) SWIG_fail;
31545 }
31546 }
31547 {
31548 PyThreadState* __tstate = wxPyBeginAllowThreads();
31549 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
31550
31551 wxPyEndAllowThreads(__tstate);
31552 if (PyErr_Occurred()) SWIG_fail;
31553 }
31554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
31555 return resultobj;
31556 fail:
31557 return NULL;
31558 }
31559
31560
31561 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
31562 PyObject *resultobj = NULL;
31563 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31564 PyObject * obj0 = 0 ;
31565 char *kwnames[] = {
31566 (char *) "self", NULL
31567 };
31568
31569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
31570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31571 if (SWIG_arg_fail(1)) SWIG_fail;
31572 {
31573 PyThreadState* __tstate = wxPyBeginAllowThreads();
31574 delete arg1;
31575
31576 wxPyEndAllowThreads(__tstate);
31577 if (PyErr_Occurred()) SWIG_fail;
31578 }
31579 Py_INCREF(Py_None); resultobj = Py_None;
31580 return resultobj;
31581 fail:
31582 return NULL;
31583 }
31584
31585
31586 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
31587 PyObject *resultobj = NULL;
31588 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31589 wxVideoMode *arg2 = 0 ;
31590 bool result;
31591 PyObject * obj0 = 0 ;
31592 PyObject * obj1 = 0 ;
31593 char *kwnames[] = {
31594 (char *) "self",(char *) "other", NULL
31595 };
31596
31597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
31598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31599 if (SWIG_arg_fail(1)) SWIG_fail;
31600 {
31601 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31602 if (SWIG_arg_fail(2)) SWIG_fail;
31603 if (arg2 == NULL) {
31604 SWIG_null_ref("wxVideoMode");
31605 }
31606 if (SWIG_arg_fail(2)) SWIG_fail;
31607 }
31608 {
31609 PyThreadState* __tstate = wxPyBeginAllowThreads();
31610 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
31611
31612 wxPyEndAllowThreads(__tstate);
31613 if (PyErr_Occurred()) SWIG_fail;
31614 }
31615 {
31616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31617 }
31618 return resultobj;
31619 fail:
31620 return NULL;
31621 }
31622
31623
31624 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
31625 PyObject *resultobj = NULL;
31626 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31627 int result;
31628 PyObject * obj0 = 0 ;
31629 char *kwnames[] = {
31630 (char *) "self", NULL
31631 };
31632
31633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
31634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31635 if (SWIG_arg_fail(1)) SWIG_fail;
31636 {
31637 PyThreadState* __tstate = wxPyBeginAllowThreads();
31638 result = (int)((wxVideoMode const *)arg1)->GetWidth();
31639
31640 wxPyEndAllowThreads(__tstate);
31641 if (PyErr_Occurred()) SWIG_fail;
31642 }
31643 {
31644 resultobj = SWIG_From_int(static_cast<int >(result));
31645 }
31646 return resultobj;
31647 fail:
31648 return NULL;
31649 }
31650
31651
31652 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
31653 PyObject *resultobj = NULL;
31654 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31655 int result;
31656 PyObject * obj0 = 0 ;
31657 char *kwnames[] = {
31658 (char *) "self", NULL
31659 };
31660
31661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
31662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31663 if (SWIG_arg_fail(1)) SWIG_fail;
31664 {
31665 PyThreadState* __tstate = wxPyBeginAllowThreads();
31666 result = (int)((wxVideoMode const *)arg1)->GetHeight();
31667
31668 wxPyEndAllowThreads(__tstate);
31669 if (PyErr_Occurred()) SWIG_fail;
31670 }
31671 {
31672 resultobj = SWIG_From_int(static_cast<int >(result));
31673 }
31674 return resultobj;
31675 fail:
31676 return NULL;
31677 }
31678
31679
31680 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
31681 PyObject *resultobj = NULL;
31682 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31683 int result;
31684 PyObject * obj0 = 0 ;
31685 char *kwnames[] = {
31686 (char *) "self", NULL
31687 };
31688
31689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
31690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31691 if (SWIG_arg_fail(1)) SWIG_fail;
31692 {
31693 PyThreadState* __tstate = wxPyBeginAllowThreads();
31694 result = (int)((wxVideoMode const *)arg1)->GetDepth();
31695
31696 wxPyEndAllowThreads(__tstate);
31697 if (PyErr_Occurred()) SWIG_fail;
31698 }
31699 {
31700 resultobj = SWIG_From_int(static_cast<int >(result));
31701 }
31702 return resultobj;
31703 fail:
31704 return NULL;
31705 }
31706
31707
31708 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
31709 PyObject *resultobj = NULL;
31710 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31711 bool result;
31712 PyObject * obj0 = 0 ;
31713 char *kwnames[] = {
31714 (char *) "self", NULL
31715 };
31716
31717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
31718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31719 if (SWIG_arg_fail(1)) SWIG_fail;
31720 {
31721 PyThreadState* __tstate = wxPyBeginAllowThreads();
31722 result = (bool)((wxVideoMode const *)arg1)->IsOk();
31723
31724 wxPyEndAllowThreads(__tstate);
31725 if (PyErr_Occurred()) SWIG_fail;
31726 }
31727 {
31728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31729 }
31730 return resultobj;
31731 fail:
31732 return NULL;
31733 }
31734
31735
31736 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
31737 PyObject *resultobj = NULL;
31738 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31739 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
31740 bool result;
31741 PyObject * obj0 = 0 ;
31742 PyObject * obj1 = 0 ;
31743 char *kwnames[] = {
31744 (char *) "self",(char *) "other", NULL
31745 };
31746
31747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
31748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31749 if (SWIG_arg_fail(1)) SWIG_fail;
31750 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31751 if (SWIG_arg_fail(2)) SWIG_fail;
31752 {
31753 PyThreadState* __tstate = wxPyBeginAllowThreads();
31754 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
31755
31756 wxPyEndAllowThreads(__tstate);
31757 if (PyErr_Occurred()) SWIG_fail;
31758 }
31759 {
31760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31761 }
31762 return resultobj;
31763 fail:
31764 return NULL;
31765 }
31766
31767
31768 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
31769 PyObject *resultobj = NULL;
31770 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31771 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
31772 bool result;
31773 PyObject * obj0 = 0 ;
31774 PyObject * obj1 = 0 ;
31775 char *kwnames[] = {
31776 (char *) "self",(char *) "other", NULL
31777 };
31778
31779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
31780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31781 if (SWIG_arg_fail(1)) SWIG_fail;
31782 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31783 if (SWIG_arg_fail(2)) SWIG_fail;
31784 {
31785 PyThreadState* __tstate = wxPyBeginAllowThreads();
31786 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
31787
31788 wxPyEndAllowThreads(__tstate);
31789 if (PyErr_Occurred()) SWIG_fail;
31790 }
31791 {
31792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31793 }
31794 return resultobj;
31795 fail:
31796 return NULL;
31797 }
31798
31799
31800 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
31801 PyObject *resultobj = NULL;
31802 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31803 int arg2 ;
31804 PyObject * obj0 = 0 ;
31805 PyObject * obj1 = 0 ;
31806 char *kwnames[] = {
31807 (char *) "self",(char *) "w", NULL
31808 };
31809
31810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
31811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31812 if (SWIG_arg_fail(1)) SWIG_fail;
31813 {
31814 arg2 = static_cast<int >(SWIG_As_int(obj1));
31815 if (SWIG_arg_fail(2)) SWIG_fail;
31816 }
31817 if (arg1) (arg1)->w = arg2;
31818
31819 Py_INCREF(Py_None); resultobj = Py_None;
31820 return resultobj;
31821 fail:
31822 return NULL;
31823 }
31824
31825
31826 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
31827 PyObject *resultobj = NULL;
31828 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31829 int result;
31830 PyObject * obj0 = 0 ;
31831 char *kwnames[] = {
31832 (char *) "self", NULL
31833 };
31834
31835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
31836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31837 if (SWIG_arg_fail(1)) SWIG_fail;
31838 result = (int) ((arg1)->w);
31839
31840 {
31841 resultobj = SWIG_From_int(static_cast<int >(result));
31842 }
31843 return resultobj;
31844 fail:
31845 return NULL;
31846 }
31847
31848
31849 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
31850 PyObject *resultobj = NULL;
31851 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31852 int arg2 ;
31853 PyObject * obj0 = 0 ;
31854 PyObject * obj1 = 0 ;
31855 char *kwnames[] = {
31856 (char *) "self",(char *) "h", NULL
31857 };
31858
31859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
31860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31861 if (SWIG_arg_fail(1)) SWIG_fail;
31862 {
31863 arg2 = static_cast<int >(SWIG_As_int(obj1));
31864 if (SWIG_arg_fail(2)) SWIG_fail;
31865 }
31866 if (arg1) (arg1)->h = arg2;
31867
31868 Py_INCREF(Py_None); resultobj = Py_None;
31869 return resultobj;
31870 fail:
31871 return NULL;
31872 }
31873
31874
31875 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
31876 PyObject *resultobj = NULL;
31877 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31878 int result;
31879 PyObject * obj0 = 0 ;
31880 char *kwnames[] = {
31881 (char *) "self", NULL
31882 };
31883
31884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
31885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31886 if (SWIG_arg_fail(1)) SWIG_fail;
31887 result = (int) ((arg1)->h);
31888
31889 {
31890 resultobj = SWIG_From_int(static_cast<int >(result));
31891 }
31892 return resultobj;
31893 fail:
31894 return NULL;
31895 }
31896
31897
31898 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
31899 PyObject *resultobj = NULL;
31900 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31901 int arg2 ;
31902 PyObject * obj0 = 0 ;
31903 PyObject * obj1 = 0 ;
31904 char *kwnames[] = {
31905 (char *) "self",(char *) "bpp", NULL
31906 };
31907
31908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
31909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31910 if (SWIG_arg_fail(1)) SWIG_fail;
31911 {
31912 arg2 = static_cast<int >(SWIG_As_int(obj1));
31913 if (SWIG_arg_fail(2)) SWIG_fail;
31914 }
31915 if (arg1) (arg1)->bpp = arg2;
31916
31917 Py_INCREF(Py_None); resultobj = Py_None;
31918 return resultobj;
31919 fail:
31920 return NULL;
31921 }
31922
31923
31924 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
31925 PyObject *resultobj = NULL;
31926 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31927 int result;
31928 PyObject * obj0 = 0 ;
31929 char *kwnames[] = {
31930 (char *) "self", NULL
31931 };
31932
31933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
31934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31935 if (SWIG_arg_fail(1)) SWIG_fail;
31936 result = (int) ((arg1)->bpp);
31937
31938 {
31939 resultobj = SWIG_From_int(static_cast<int >(result));
31940 }
31941 return resultobj;
31942 fail:
31943 return NULL;
31944 }
31945
31946
31947 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
31948 PyObject *resultobj = NULL;
31949 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31950 int arg2 ;
31951 PyObject * obj0 = 0 ;
31952 PyObject * obj1 = 0 ;
31953 char *kwnames[] = {
31954 (char *) "self",(char *) "refresh", NULL
31955 };
31956
31957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
31958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31959 if (SWIG_arg_fail(1)) SWIG_fail;
31960 {
31961 arg2 = static_cast<int >(SWIG_As_int(obj1));
31962 if (SWIG_arg_fail(2)) SWIG_fail;
31963 }
31964 if (arg1) (arg1)->refresh = arg2;
31965
31966 Py_INCREF(Py_None); resultobj = Py_None;
31967 return resultobj;
31968 fail:
31969 return NULL;
31970 }
31971
31972
31973 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
31974 PyObject *resultobj = NULL;
31975 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31976 int result;
31977 PyObject * obj0 = 0 ;
31978 char *kwnames[] = {
31979 (char *) "self", NULL
31980 };
31981
31982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
31983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31984 if (SWIG_arg_fail(1)) SWIG_fail;
31985 result = (int) ((arg1)->refresh);
31986
31987 {
31988 resultobj = SWIG_From_int(static_cast<int >(result));
31989 }
31990 return resultobj;
31991 fail:
31992 return NULL;
31993 }
31994
31995
31996 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
31997 PyObject *obj;
31998 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31999 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
32000 Py_INCREF(obj);
32001 return Py_BuildValue((char *)"");
32002 }
32003 static int _wrap_DefaultVideoMode_set(PyObject *) {
32004 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
32005 return 1;
32006 }
32007
32008
32009 static PyObject *_wrap_DefaultVideoMode_get(void) {
32010 PyObject *pyobj = NULL;
32011
32012 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
32013 return pyobj;
32014 }
32015
32016
32017 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
32018 PyObject *resultobj = NULL;
32019 size_t arg1 = (size_t) 0 ;
32020 wxDisplay *result;
32021 PyObject * obj0 = 0 ;
32022 char *kwnames[] = {
32023 (char *) "index", NULL
32024 };
32025
32026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
32027 if (obj0) {
32028 {
32029 arg1 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj0));
32030 if (SWIG_arg_fail(1)) SWIG_fail;
32031 }
32032 }
32033 {
32034 PyThreadState* __tstate = wxPyBeginAllowThreads();
32035 result = (wxDisplay *)new wxDisplay(arg1);
32036
32037 wxPyEndAllowThreads(__tstate);
32038 if (PyErr_Occurred()) SWIG_fail;
32039 }
32040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
32041 return resultobj;
32042 fail:
32043 return NULL;
32044 }
32045
32046
32047 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
32048 PyObject *resultobj = NULL;
32049 wxDisplay *arg1 = (wxDisplay *) 0 ;
32050 PyObject * obj0 = 0 ;
32051 char *kwnames[] = {
32052 (char *) "self", NULL
32053 };
32054
32055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
32056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32057 if (SWIG_arg_fail(1)) SWIG_fail;
32058 {
32059 PyThreadState* __tstate = wxPyBeginAllowThreads();
32060 delete arg1;
32061
32062 wxPyEndAllowThreads(__tstate);
32063 if (PyErr_Occurred()) SWIG_fail;
32064 }
32065 Py_INCREF(Py_None); resultobj = Py_None;
32066 return resultobj;
32067 fail:
32068 return NULL;
32069 }
32070
32071
32072 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
32073 PyObject *resultobj = NULL;
32074 size_t result;
32075 char *kwnames[] = {
32076 NULL
32077 };
32078
32079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
32080 {
32081 PyThreadState* __tstate = wxPyBeginAllowThreads();
32082 result = (size_t)wxDisplay::GetCount();
32083
32084 wxPyEndAllowThreads(__tstate);
32085 if (PyErr_Occurred()) SWIG_fail;
32086 }
32087 {
32088 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
32089 }
32090 return resultobj;
32091 fail:
32092 return NULL;
32093 }
32094
32095
32096 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
32097 PyObject *resultobj = NULL;
32098 wxPoint *arg1 = 0 ;
32099 int result;
32100 wxPoint temp1 ;
32101 PyObject * obj0 = 0 ;
32102 char *kwnames[] = {
32103 (char *) "pt", NULL
32104 };
32105
32106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
32107 {
32108 arg1 = &temp1;
32109 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
32110 }
32111 {
32112 PyThreadState* __tstate = wxPyBeginAllowThreads();
32113 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
32114
32115 wxPyEndAllowThreads(__tstate);
32116 if (PyErr_Occurred()) SWIG_fail;
32117 }
32118 {
32119 resultobj = SWIG_From_int(static_cast<int >(result));
32120 }
32121 return resultobj;
32122 fail:
32123 return NULL;
32124 }
32125
32126
32127 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32128 PyObject *resultobj = NULL;
32129 wxWindow *arg1 = (wxWindow *) 0 ;
32130 int result;
32131 PyObject * obj0 = 0 ;
32132 char *kwnames[] = {
32133 (char *) "window", NULL
32134 };
32135
32136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
32137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32138 if (SWIG_arg_fail(1)) SWIG_fail;
32139 {
32140 PyThreadState* __tstate = wxPyBeginAllowThreads();
32141 result = (int)wxDisplay_GetFromWindow(arg1);
32142
32143 wxPyEndAllowThreads(__tstate);
32144 if (PyErr_Occurred()) SWIG_fail;
32145 }
32146 {
32147 resultobj = SWIG_From_int(static_cast<int >(result));
32148 }
32149 return resultobj;
32150 fail:
32151 return NULL;
32152 }
32153
32154
32155 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
32156 PyObject *resultobj = NULL;
32157 wxDisplay *arg1 = (wxDisplay *) 0 ;
32158 bool result;
32159 PyObject * obj0 = 0 ;
32160 char *kwnames[] = {
32161 (char *) "self", NULL
32162 };
32163
32164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
32165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32166 if (SWIG_arg_fail(1)) SWIG_fail;
32167 {
32168 PyThreadState* __tstate = wxPyBeginAllowThreads();
32169 result = (bool)((wxDisplay const *)arg1)->IsOk();
32170
32171 wxPyEndAllowThreads(__tstate);
32172 if (PyErr_Occurred()) SWIG_fail;
32173 }
32174 {
32175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32176 }
32177 return resultobj;
32178 fail:
32179 return NULL;
32180 }
32181
32182
32183 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
32184 PyObject *resultobj = NULL;
32185 wxDisplay *arg1 = (wxDisplay *) 0 ;
32186 wxRect result;
32187 PyObject * obj0 = 0 ;
32188 char *kwnames[] = {
32189 (char *) "self", NULL
32190 };
32191
32192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
32193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32194 if (SWIG_arg_fail(1)) SWIG_fail;
32195 {
32196 PyThreadState* __tstate = wxPyBeginAllowThreads();
32197 result = ((wxDisplay const *)arg1)->GetGeometry();
32198
32199 wxPyEndAllowThreads(__tstate);
32200 if (PyErr_Occurred()) SWIG_fail;
32201 }
32202 {
32203 wxRect * resultptr;
32204 resultptr = new wxRect(static_cast<wxRect & >(result));
32205 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
32206 }
32207 return resultobj;
32208 fail:
32209 return NULL;
32210 }
32211
32212
32213 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
32214 PyObject *resultobj = NULL;
32215 wxDisplay *arg1 = (wxDisplay *) 0 ;
32216 wxString result;
32217 PyObject * obj0 = 0 ;
32218 char *kwnames[] = {
32219 (char *) "self", NULL
32220 };
32221
32222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
32223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32224 if (SWIG_arg_fail(1)) SWIG_fail;
32225 {
32226 PyThreadState* __tstate = wxPyBeginAllowThreads();
32227 result = ((wxDisplay const *)arg1)->GetName();
32228
32229 wxPyEndAllowThreads(__tstate);
32230 if (PyErr_Occurred()) SWIG_fail;
32231 }
32232 {
32233 #if wxUSE_UNICODE
32234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32235 #else
32236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32237 #endif
32238 }
32239 return resultobj;
32240 fail:
32241 return NULL;
32242 }
32243
32244
32245 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
32246 PyObject *resultobj = NULL;
32247 wxDisplay *arg1 = (wxDisplay *) 0 ;
32248 bool result;
32249 PyObject * obj0 = 0 ;
32250 char *kwnames[] = {
32251 (char *) "self", NULL
32252 };
32253
32254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
32255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32256 if (SWIG_arg_fail(1)) SWIG_fail;
32257 {
32258 PyThreadState* __tstate = wxPyBeginAllowThreads();
32259 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
32260
32261 wxPyEndAllowThreads(__tstate);
32262 if (PyErr_Occurred()) SWIG_fail;
32263 }
32264 {
32265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32266 }
32267 return resultobj;
32268 fail:
32269 return NULL;
32270 }
32271
32272
32273 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
32274 PyObject *resultobj = NULL;
32275 wxDisplay *arg1 = (wxDisplay *) 0 ;
32276 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
32277 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
32278 PyObject *result;
32279 PyObject * obj0 = 0 ;
32280 PyObject * obj1 = 0 ;
32281 char *kwnames[] = {
32282 (char *) "self",(char *) "mode", NULL
32283 };
32284
32285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
32286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32287 if (SWIG_arg_fail(1)) SWIG_fail;
32288 if (obj1) {
32289 {
32290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
32291 if (SWIG_arg_fail(2)) SWIG_fail;
32292 if (arg2 == NULL) {
32293 SWIG_null_ref("wxVideoMode");
32294 }
32295 if (SWIG_arg_fail(2)) SWIG_fail;
32296 }
32297 }
32298 {
32299 PyThreadState* __tstate = wxPyBeginAllowThreads();
32300 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
32301
32302 wxPyEndAllowThreads(__tstate);
32303 if (PyErr_Occurred()) SWIG_fail;
32304 }
32305 resultobj = result;
32306 return resultobj;
32307 fail:
32308 return NULL;
32309 }
32310
32311
32312 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
32313 PyObject *resultobj = NULL;
32314 wxDisplay *arg1 = (wxDisplay *) 0 ;
32315 wxVideoMode result;
32316 PyObject * obj0 = 0 ;
32317 char *kwnames[] = {
32318 (char *) "self", NULL
32319 };
32320
32321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
32322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32323 if (SWIG_arg_fail(1)) SWIG_fail;
32324 {
32325 PyThreadState* __tstate = wxPyBeginAllowThreads();
32326 result = ((wxDisplay const *)arg1)->GetCurrentMode();
32327
32328 wxPyEndAllowThreads(__tstate);
32329 if (PyErr_Occurred()) SWIG_fail;
32330 }
32331 {
32332 wxVideoMode * resultptr;
32333 resultptr = new wxVideoMode(static_cast<wxVideoMode & >(result));
32334 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
32335 }
32336 return resultobj;
32337 fail:
32338 return NULL;
32339 }
32340
32341
32342 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
32343 PyObject *resultobj = NULL;
32344 wxDisplay *arg1 = (wxDisplay *) 0 ;
32345 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
32346 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
32347 bool result;
32348 PyObject * obj0 = 0 ;
32349 PyObject * obj1 = 0 ;
32350 char *kwnames[] = {
32351 (char *) "self",(char *) "mode", NULL
32352 };
32353
32354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
32355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32356 if (SWIG_arg_fail(1)) SWIG_fail;
32357 if (obj1) {
32358 {
32359 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
32360 if (SWIG_arg_fail(2)) SWIG_fail;
32361 if (arg2 == NULL) {
32362 SWIG_null_ref("wxVideoMode");
32363 }
32364 if (SWIG_arg_fail(2)) SWIG_fail;
32365 }
32366 }
32367 {
32368 PyThreadState* __tstate = wxPyBeginAllowThreads();
32369 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
32370
32371 wxPyEndAllowThreads(__tstate);
32372 if (PyErr_Occurred()) SWIG_fail;
32373 }
32374 {
32375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32376 }
32377 return resultobj;
32378 fail:
32379 return NULL;
32380 }
32381
32382
32383 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
32384 PyObject *resultobj = NULL;
32385 wxDisplay *arg1 = (wxDisplay *) 0 ;
32386 PyObject * obj0 = 0 ;
32387 char *kwnames[] = {
32388 (char *) "self", NULL
32389 };
32390
32391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
32392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32393 if (SWIG_arg_fail(1)) SWIG_fail;
32394 {
32395 PyThreadState* __tstate = wxPyBeginAllowThreads();
32396 (arg1)->ResetMode();
32397
32398 wxPyEndAllowThreads(__tstate);
32399 if (PyErr_Occurred()) SWIG_fail;
32400 }
32401 Py_INCREF(Py_None); resultobj = Py_None;
32402 return resultobj;
32403 fail:
32404 return NULL;
32405 }
32406
32407
32408 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
32409 PyObject *obj;
32410 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32411 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
32412 Py_INCREF(obj);
32413 return Py_BuildValue((char *)"");
32414 }
32415 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
32416 PyObject *resultobj = NULL;
32417 wxStandardPaths *result;
32418 char *kwnames[] = {
32419 NULL
32420 };
32421
32422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
32423 {
32424 PyThreadState* __tstate = wxPyBeginAllowThreads();
32425 result = (wxStandardPaths *)wxStandardPaths_Get();
32426
32427 wxPyEndAllowThreads(__tstate);
32428 if (PyErr_Occurred()) SWIG_fail;
32429 }
32430 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
32431 return resultobj;
32432 fail:
32433 return NULL;
32434 }
32435
32436
32437 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
32438 PyObject *resultobj = NULL;
32439 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32440 wxString result;
32441 PyObject * obj0 = 0 ;
32442 char *kwnames[] = {
32443 (char *) "self", NULL
32444 };
32445
32446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
32447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32448 if (SWIG_arg_fail(1)) SWIG_fail;
32449 {
32450 PyThreadState* __tstate = wxPyBeginAllowThreads();
32451 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
32452
32453 wxPyEndAllowThreads(__tstate);
32454 if (PyErr_Occurred()) SWIG_fail;
32455 }
32456 {
32457 #if wxUSE_UNICODE
32458 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32459 #else
32460 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32461 #endif
32462 }
32463 return resultobj;
32464 fail:
32465 return NULL;
32466 }
32467
32468
32469 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
32470 PyObject *resultobj = NULL;
32471 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32472 wxString result;
32473 PyObject * obj0 = 0 ;
32474 char *kwnames[] = {
32475 (char *) "self", NULL
32476 };
32477
32478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
32479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32480 if (SWIG_arg_fail(1)) SWIG_fail;
32481 {
32482 PyThreadState* __tstate = wxPyBeginAllowThreads();
32483 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
32484
32485 wxPyEndAllowThreads(__tstate);
32486 if (PyErr_Occurred()) SWIG_fail;
32487 }
32488 {
32489 #if wxUSE_UNICODE
32490 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32491 #else
32492 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32493 #endif
32494 }
32495 return resultobj;
32496 fail:
32497 return NULL;
32498 }
32499
32500
32501 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
32502 PyObject *resultobj = NULL;
32503 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32504 wxString result;
32505 PyObject * obj0 = 0 ;
32506 char *kwnames[] = {
32507 (char *) "self", NULL
32508 };
32509
32510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
32511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32512 if (SWIG_arg_fail(1)) SWIG_fail;
32513 {
32514 PyThreadState* __tstate = wxPyBeginAllowThreads();
32515 result = ((wxStandardPaths const *)arg1)->GetDataDir();
32516
32517 wxPyEndAllowThreads(__tstate);
32518 if (PyErr_Occurred()) SWIG_fail;
32519 }
32520 {
32521 #if wxUSE_UNICODE
32522 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32523 #else
32524 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32525 #endif
32526 }
32527 return resultobj;
32528 fail:
32529 return NULL;
32530 }
32531
32532
32533 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
32534 PyObject *resultobj = NULL;
32535 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32536 wxString result;
32537 PyObject * obj0 = 0 ;
32538 char *kwnames[] = {
32539 (char *) "self", NULL
32540 };
32541
32542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
32543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32544 if (SWIG_arg_fail(1)) SWIG_fail;
32545 {
32546 PyThreadState* __tstate = wxPyBeginAllowThreads();
32547 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
32548
32549 wxPyEndAllowThreads(__tstate);
32550 if (PyErr_Occurred()) SWIG_fail;
32551 }
32552 {
32553 #if wxUSE_UNICODE
32554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32555 #else
32556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32557 #endif
32558 }
32559 return resultobj;
32560 fail:
32561 return NULL;
32562 }
32563
32564
32565 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
32566 PyObject *resultobj = NULL;
32567 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32568 wxString result;
32569 PyObject * obj0 = 0 ;
32570 char *kwnames[] = {
32571 (char *) "self", NULL
32572 };
32573
32574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
32575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32576 if (SWIG_arg_fail(1)) SWIG_fail;
32577 {
32578 PyThreadState* __tstate = wxPyBeginAllowThreads();
32579 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
32580
32581 wxPyEndAllowThreads(__tstate);
32582 if (PyErr_Occurred()) SWIG_fail;
32583 }
32584 {
32585 #if wxUSE_UNICODE
32586 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32587 #else
32588 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32589 #endif
32590 }
32591 return resultobj;
32592 fail:
32593 return NULL;
32594 }
32595
32596
32597 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
32598 PyObject *resultobj = NULL;
32599 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32600 wxString result;
32601 PyObject * obj0 = 0 ;
32602 char *kwnames[] = {
32603 (char *) "self", NULL
32604 };
32605
32606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
32607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32608 if (SWIG_arg_fail(1)) SWIG_fail;
32609 {
32610 PyThreadState* __tstate = wxPyBeginAllowThreads();
32611 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
32612
32613 wxPyEndAllowThreads(__tstate);
32614 if (PyErr_Occurred()) SWIG_fail;
32615 }
32616 {
32617 #if wxUSE_UNICODE
32618 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32619 #else
32620 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32621 #endif
32622 }
32623 return resultobj;
32624 fail:
32625 return NULL;
32626 }
32627
32628
32629 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
32630 PyObject *resultobj = NULL;
32631 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32632 wxString result;
32633 PyObject * obj0 = 0 ;
32634 char *kwnames[] = {
32635 (char *) "self", NULL
32636 };
32637
32638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
32639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32640 if (SWIG_arg_fail(1)) SWIG_fail;
32641 {
32642 PyThreadState* __tstate = wxPyBeginAllowThreads();
32643 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
32644
32645 wxPyEndAllowThreads(__tstate);
32646 if (PyErr_Occurred()) SWIG_fail;
32647 }
32648 {
32649 #if wxUSE_UNICODE
32650 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32651 #else
32652 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32653 #endif
32654 }
32655 return resultobj;
32656 fail:
32657 return NULL;
32658 }
32659
32660
32661 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
32662 PyObject *resultobj = NULL;
32663 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32664 wxString *arg2 = 0 ;
32665 bool temp2 = false ;
32666 PyObject * obj0 = 0 ;
32667 PyObject * obj1 = 0 ;
32668 char *kwnames[] = {
32669 (char *) "self",(char *) "prefix", NULL
32670 };
32671
32672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
32673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32674 if (SWIG_arg_fail(1)) SWIG_fail;
32675 {
32676 arg2 = wxString_in_helper(obj1);
32677 if (arg2 == NULL) SWIG_fail;
32678 temp2 = true;
32679 }
32680 {
32681 PyThreadState* __tstate = wxPyBeginAllowThreads();
32682 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
32683
32684 wxPyEndAllowThreads(__tstate);
32685 if (PyErr_Occurred()) SWIG_fail;
32686 }
32687 Py_INCREF(Py_None); resultobj = Py_None;
32688 {
32689 if (temp2)
32690 delete arg2;
32691 }
32692 return resultobj;
32693 fail:
32694 {
32695 if (temp2)
32696 delete arg2;
32697 }
32698 return NULL;
32699 }
32700
32701
32702 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
32703 PyObject *resultobj = NULL;
32704 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32705 wxString result;
32706 PyObject * obj0 = 0 ;
32707 char *kwnames[] = {
32708 (char *) "self", NULL
32709 };
32710
32711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
32712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32713 if (SWIG_arg_fail(1)) SWIG_fail;
32714 {
32715 PyThreadState* __tstate = wxPyBeginAllowThreads();
32716 result = wxStandardPaths_GetInstallPrefix(arg1);
32717
32718 wxPyEndAllowThreads(__tstate);
32719 if (PyErr_Occurred()) SWIG_fail;
32720 }
32721 {
32722 #if wxUSE_UNICODE
32723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32724 #else
32725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32726 #endif
32727 }
32728 return resultobj;
32729 fail:
32730 return NULL;
32731 }
32732
32733
32734 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
32735 PyObject *obj;
32736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32737 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
32738 Py_INCREF(obj);
32739 return Py_BuildValue((char *)"");
32740 }
32741 static PyMethodDef SwigMethods[] = {
32742 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
32743 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
32744 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
32745 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
32746 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
32747 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
32748 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
32749 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
32750 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
32751 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
32752 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
32753 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
32754 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
32755 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
32756 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
32757 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
32758 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
32759 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
32760 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
32761 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
32762 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
32763 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
32764 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32765 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
32766 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
32767 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
32768 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
32769 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
32770 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
32771 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
32772 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
32773 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
32774 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
32775 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
32776 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
32777 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
32778 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
32779 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
32780 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
32781 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
32782 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
32783 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
32784 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
32785 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
32786 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
32787 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
32788 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
32789 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
32790 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
32791 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
32792 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
32793 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
32794 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
32795 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
32796 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
32797 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
32798 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32799 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32800 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
32801 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
32802 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
32803 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
32804 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
32805 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
32806 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32807 { (char *)"GetXDisplay", (PyCFunction) _wrap_GetXDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
32808 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32809 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
32810 { (char *)"FindWindowAtPointer", (PyCFunction) _wrap_FindWindowAtPointer, METH_VARARGS | METH_KEYWORDS, NULL},
32811 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32812 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32813 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32814 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
32815 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
32816 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
32817 { (char *)"new_MouseState", (PyCFunction) _wrap_new_MouseState, METH_VARARGS | METH_KEYWORDS, NULL},
32818 { (char *)"delete_MouseState", (PyCFunction) _wrap_delete_MouseState, METH_VARARGS | METH_KEYWORDS, NULL},
32819 { (char *)"MouseState_GetX", (PyCFunction) _wrap_MouseState_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
32820 { (char *)"MouseState_GetY", (PyCFunction) _wrap_MouseState_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
32821 { (char *)"MouseState_LeftDown", (PyCFunction) _wrap_MouseState_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
32822 { (char *)"MouseState_MiddleDown", (PyCFunction) _wrap_MouseState_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
32823 { (char *)"MouseState_RightDown", (PyCFunction) _wrap_MouseState_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
32824 { (char *)"MouseState_ControlDown", (PyCFunction) _wrap_MouseState_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
32825 { (char *)"MouseState_ShiftDown", (PyCFunction) _wrap_MouseState_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
32826 { (char *)"MouseState_AltDown", (PyCFunction) _wrap_MouseState_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
32827 { (char *)"MouseState_MetaDown", (PyCFunction) _wrap_MouseState_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
32828 { (char *)"MouseState_CmdDown", (PyCFunction) _wrap_MouseState_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
32829 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
32830 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
32831 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
32832 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
32833 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
32834 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
32835 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
32836 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
32837 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
32838 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
32839 { (char *)"GetMouseState", (PyCFunction) _wrap_GetMouseState, METH_VARARGS | METH_KEYWORDS, NULL},
32840 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
32841 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32842 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32843 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32844 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32845 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
32846 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
32847 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
32848 { (char *)"delete_ToolTip", (PyCFunction) _wrap_delete_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
32849 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
32850 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
32851 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32852 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
32853 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
32854 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
32855 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
32856 { (char *)"delete_Caret", (PyCFunction) _wrap_delete_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
32857 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
32858 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32859 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
32860 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32861 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
32862 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32863 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
32864 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32865 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
32866 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
32867 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
32868 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32869 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
32870 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
32871 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
32872 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
32873 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
32874 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32875 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32876 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
32877 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
32878 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
32879 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
32880 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32881 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32882 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
32883 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
32884 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
32885 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
32886 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
32887 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
32888 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
32889 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
32890 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
32891 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
32892 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
32893 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
32894 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
32895 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
32896 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
32897 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
32898 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
32899 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
32900 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
32901 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32902 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
32903 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
32904 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
32905 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
32906 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
32907 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
32908 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
32909 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
32910 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32911 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
32912 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
32913 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
32914 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
32915 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32916 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32917 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
32918 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
32919 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32920 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
32921 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
32922 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32923 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
32924 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
32925 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
32926 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
32927 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
32928 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
32929 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
32930 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32931 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
32932 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
32933 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
32934 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
32935 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
32936 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
32937 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
32938 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
32939 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
32940 { (char *)"delete_Log", (PyCFunction) _wrap_delete_Log, METH_VARARGS | METH_KEYWORDS, NULL},
32941 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
32942 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
32943 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
32944 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32945 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
32946 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32947 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32948 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
32949 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
32950 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
32951 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
32952 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
32953 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32954 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32955 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32956 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
32957 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
32958 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
32959 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
32960 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32961 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32962 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
32963 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
32964 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
32965 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
32966 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
32967 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
32968 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
32969 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
32970 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
32971 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
32972 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
32973 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32974 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
32975 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
32976 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
32977 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
32978 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
32979 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
32980 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
32981 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
32982 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
32983 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
32984 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
32985 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
32986 { (char *)"new_LogBuffer", (PyCFunction) _wrap_new_LogBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
32987 { (char *)"LogBuffer_GetBuffer", (PyCFunction) _wrap_LogBuffer_GetBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
32988 { (char *)"LogBuffer_Flush", (PyCFunction) _wrap_LogBuffer_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32989 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
32990 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
32991 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
32992 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
32993 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
32994 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
32995 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
32996 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32997 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
32998 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
32999 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
33000 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
33001 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
33002 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
33003 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
33004 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
33005 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
33006 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
33007 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
33008 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
33009 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33010 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
33011 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
33012 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
33013 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
33014 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
33015 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33016 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
33017 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
33018 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
33019 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
33020 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
33021 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
33022 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
33023 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
33024 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
33025 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
33026 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
33027 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
33028 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
33029 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
33030 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
33031 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
33032 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
33033 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
33034 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
33035 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
33036 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
33037 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
33038 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
33039 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
33040 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33041 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33042 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
33043 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33044 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33045 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33046 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33047 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33048 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
33049 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
33050 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
33051 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
33052 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
33053 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
33054 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
33055 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
33056 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
33057 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
33058 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
33059 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
33060 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
33061 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
33062 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
33063 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
33064 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
33065 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
33066 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
33067 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
33068 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
33069 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
33070 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
33071 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
33072 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
33073 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
33074 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
33075 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
33076 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
33077 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
33078 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
33079 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
33080 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
33081 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
33082 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
33083 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
33084 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33085 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33086 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
33087 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
33088 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
33089 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
33090 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
33091 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
33092 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33093 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33094 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
33095 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
33096 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
33097 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
33098 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
33099 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
33100 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
33101 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
33102 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
33103 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
33104 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
33105 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
33106 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
33107 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
33108 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
33109 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
33110 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
33111 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33112 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
33113 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33114 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
33115 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
33116 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
33117 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
33118 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33119 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33120 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
33121 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
33122 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
33123 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
33124 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
33125 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
33126 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
33127 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
33128 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
33129 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
33130 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
33131 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
33132 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
33133 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33134 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
33135 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33136 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33137 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
33138 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33139 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
33140 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
33141 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33142 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
33143 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
33144 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
33145 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
33146 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
33147 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
33148 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
33149 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
33150 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
33151 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
33152 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
33153 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
33154 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
33155 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
33156 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
33157 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33158 { (char *)"delete_ArtProvider", (PyCFunction) _wrap_delete_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33159 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33160 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33161 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33162 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33163 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
33164 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
33165 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
33166 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
33167 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
33168 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
33169 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
33170 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
33171 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
33172 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
33173 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
33174 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
33175 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33176 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33177 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33178 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33179 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
33180 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
33181 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33182 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33183 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
33184 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
33185 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
33186 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
33187 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
33188 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
33189 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
33190 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
33191 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
33192 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
33193 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
33194 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33195 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33196 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33197 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33198 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
33199 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
33200 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
33201 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
33202 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
33203 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
33204 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
33205 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
33206 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
33207 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
33208 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
33209 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
33210 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
33211 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
33212 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
33213 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
33214 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
33215 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
33216 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
33217 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
33218 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
33219 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
33220 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
33221 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
33222 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
33223 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
33224 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
33225 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
33226 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
33227 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33228 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
33229 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
33230 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
33231 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33232 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
33233 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
33234 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
33235 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
33236 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
33237 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
33238 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
33239 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
33240 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
33241 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
33242 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
33243 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
33244 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
33245 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
33246 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
33247 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
33248 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
33249 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
33250 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
33251 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
33252 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
33253 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
33254 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33255 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
33256 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
33257 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
33258 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
33259 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
33260 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
33261 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
33262 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33263 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33264 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33265 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33266 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33267 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33268 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33269 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
33270 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
33271 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
33272 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
33273 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
33274 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
33275 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
33276 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
33277 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
33278 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
33279 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
33280 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
33281 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
33282 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
33283 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
33284 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
33285 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
33286 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
33287 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
33288 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
33289 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
33290 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
33291 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
33292 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
33293 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
33294 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
33295 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33296 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
33297 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33298 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
33299 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
33300 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
33301 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
33302 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
33303 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
33304 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33305 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
33306 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
33307 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
33308 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
33309 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
33310 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
33311 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
33312 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
33313 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
33314 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
33315 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
33316 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
33317 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
33318 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
33319 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
33320 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
33321 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
33322 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
33323 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
33324 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
33325 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
33326 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
33327 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
33328 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33329 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
33330 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33331 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
33332 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
33333 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
33334 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
33335 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
33336 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
33337 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
33338 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
33339 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
33340 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
33341 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
33342 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
33343 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
33344 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
33345 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
33346 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
33347 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
33348 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
33349 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
33350 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
33351 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
33352 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
33353 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
33354 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
33355 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
33356 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
33357 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
33358 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
33359 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
33360 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
33361 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
33362 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
33363 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
33364 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
33365 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
33366 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
33367 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
33368 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
33369 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
33370 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33371 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
33372 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
33373 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
33374 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
33375 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
33376 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
33377 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
33378 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
33379 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
33380 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
33381 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
33382 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
33383 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
33384 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
33385 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
33386 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
33387 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
33388 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
33389 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
33390 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
33391 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
33392 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
33393 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
33394 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
33395 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
33396 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
33397 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
33398 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
33399 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
33400 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
33401 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
33402 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
33403 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
33404 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
33405 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
33406 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
33407 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
33408 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
33409 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
33410 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
33411 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
33412 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
33413 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
33414 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
33415 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
33416 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
33417 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33418 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
33419 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
33420 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
33421 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
33422 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
33423 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33424 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33425 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33426 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
33427 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
33428 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
33429 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
33430 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
33431 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
33432 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
33433 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33434 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33435 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
33436 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
33437 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
33438 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
33439 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
33440 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33441 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
33442 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
33443 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33444 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33445 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
33446 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
33447 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33448 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
33449 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
33450 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33451 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
33452 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
33453 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
33454 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
33455 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33456 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
33457 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
33458 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
33459 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
33460 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33461 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33462 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
33463 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33464 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
33465 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
33466 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
33467 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33468 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33469 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
33470 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33471 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
33472 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
33473 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
33474 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
33475 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33476 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
33477 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
33478 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
33479 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33480 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
33481 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
33482 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
33483 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33484 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
33485 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
33486 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
33487 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
33488 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
33489 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33490 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
33491 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33492 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33493 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
33494 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
33495 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
33496 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
33497 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33498 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33499 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33500 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33501 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33502 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
33503 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
33504 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
33505 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
33506 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
33507 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
33508 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
33509 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
33510 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33511 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33512 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
33513 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
33514 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
33515 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
33516 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
33517 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
33518 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33519 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33520 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
33521 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
33522 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
33523 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
33524 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
33525 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
33526 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
33527 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
33528 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
33529 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
33530 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
33531 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
33532 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33533 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
33534 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
33535 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
33536 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
33537 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
33538 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
33539 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
33540 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
33541 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
33542 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
33543 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
33544 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
33545 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
33546 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
33547 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
33548 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
33549 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
33550 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
33551 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
33552 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33553 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
33554 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
33555 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
33556 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
33557 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
33558 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
33559 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
33560 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
33561 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
33562 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
33563 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
33564 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
33565 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
33566 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
33567 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
33568 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
33569 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
33570 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
33571 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
33572 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
33573 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
33574 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
33575 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
33576 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
33577 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
33578 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
33579 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
33580 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
33581 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
33582 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
33583 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
33584 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
33585 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
33586 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
33587 { NULL, NULL, 0, NULL }
33588 };
33589
33590
33591 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
33592
33593 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
33594 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
33595 }
33596 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
33597 return (void *)((wxEvent *) ((wxMenuEvent *) x));
33598 }
33599 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
33600 return (void *)((wxEvent *) ((wxCloseEvent *) x));
33601 }
33602 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
33603 return (void *)((wxEvent *) ((wxMouseEvent *) x));
33604 }
33605 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
33606 return (void *)((wxEvent *) ((wxEraseEvent *) x));
33607 }
33608 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
33609 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
33610 }
33611 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
33612 return (void *)((wxEvent *) ((wxTimerEvent *) x));
33613 }
33614 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
33615 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
33616 }
33617 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
33618 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
33619 }
33620 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
33621 return (void *)((wxEvent *) ((wxPyEvent *) x));
33622 }
33623 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
33624 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
33625 }
33626 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
33627 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
33628 }
33629 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
33630 return (void *)((wxEvent *) ((wxIdleEvent *) x));
33631 }
33632 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
33633 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
33634 }
33635 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
33636 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
33637 }
33638 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
33639 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
33640 }
33641 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
33642 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
33643 }
33644 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
33645 return (void *)((wxEvent *) ((wxActivateEvent *) x));
33646 }
33647 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
33648 return (void *)((wxEvent *) ((wxSizeEvent *) x));
33649 }
33650 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
33651 return (void *)((wxEvent *) ((wxMoveEvent *) x));
33652 }
33653 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
33654 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
33655 }
33656 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
33657 return (void *)((wxEvent *) ((wxPaintEvent *) x));
33658 }
33659 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
33660 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
33661 }
33662 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
33663 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
33664 }
33665 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
33666 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
33667 }
33668 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
33669 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
33670 }
33671 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
33672 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
33673 }
33674 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
33675 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
33676 }
33677 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
33678 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
33679 }
33680 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
33681 return (void *)((wxEvent *) ((wxFocusEvent *) x));
33682 }
33683 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
33684 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
33685 }
33686 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
33687 return (void *)((wxEvent *) ((wxProcessEvent *) x));
33688 }
33689 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
33690 return (void *)((wxEvent *) ((wxShowEvent *) x));
33691 }
33692 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
33693 return (void *)((wxEvent *) ((wxCommandEvent *) x));
33694 }
33695 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
33696 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
33697 }
33698 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
33699 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
33700 }
33701 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
33702 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
33703 }
33704 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
33705 return (void *)((wxEvent *) ((wxKeyEvent *) x));
33706 }
33707 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
33708 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
33709 }
33710 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
33711 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
33712 }
33713 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
33714 return (void *)((wxConfigBase *) ((wxConfig *) x));
33715 }
33716 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
33717 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
33718 }
33719 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
33720 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
33721 }
33722 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
33723 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
33724 }
33725 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
33726 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
33727 }
33728 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
33729 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
33730 }
33731 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
33732 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
33733 }
33734 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
33735 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
33736 }
33737 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
33738 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
33739 }
33740 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
33741 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
33742 }
33743 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
33744 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
33745 }
33746 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
33747 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
33748 }
33749 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
33750 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
33751 }
33752 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
33753 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
33754 }
33755 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
33756 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
33757 }
33758 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
33759 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
33760 }
33761 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
33762 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
33763 }
33764 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
33765 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
33766 }
33767 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
33768 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
33769 }
33770 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
33771 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
33772 }
33773 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
33774 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
33775 }
33776 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
33777 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
33778 }
33779 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
33780 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
33781 }
33782 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
33783 return (void *)((wxEvtHandler *) ((wxWindow *) x));
33784 }
33785 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
33786 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
33787 }
33788 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
33789 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
33790 }
33791 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
33792 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
33793 }
33794 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
33795 return (void *)((wxEvtHandler *) ((wxValidator *) x));
33796 }
33797 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
33798 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
33799 }
33800 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
33801 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
33802 }
33803 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
33804 return (void *)((wxEvtHandler *) ((wxMenu *) x));
33805 }
33806 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
33807 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
33808 }
33809 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
33810 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
33811 }
33812 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
33813 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
33814 }
33815 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
33816 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
33817 }
33818 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
33819 return (void *)((wxObject *) ((wxSizerItem *) x));
33820 }
33821 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
33822 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
33823 }
33824 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
33825 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
33826 }
33827 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
33828 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
33829 }
33830 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
33831 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
33832 }
33833 static void *_p_wxSizerTo_p_wxObject(void *x) {
33834 return (void *)((wxObject *) ((wxSizer *) x));
33835 }
33836 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
33837 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
33838 }
33839 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
33840 return (void *)((wxObject *) ((wxFileHistory *) x));
33841 }
33842 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
33843 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
33844 }
33845 static void *_p_wxEventTo_p_wxObject(void *x) {
33846 return (void *)((wxObject *) ((wxEvent *) x));
33847 }
33848 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
33849 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
33850 }
33851 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
33852 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
33853 }
33854 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
33855 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
33856 }
33857 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
33858 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
33859 }
33860 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
33861 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
33862 }
33863 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
33864 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
33865 }
33866 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
33867 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
33868 }
33869 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
33870 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
33871 }
33872 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
33873 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
33874 }
33875 static void *_p_wxControlTo_p_wxObject(void *x) {
33876 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
33877 }
33878 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
33879 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
33880 }
33881 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
33882 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
33883 }
33884 static void *_p_wxFSFileTo_p_wxObject(void *x) {
33885 return (void *)((wxObject *) ((wxFSFile *) x));
33886 }
33887 static void *_p_wxClipboardTo_p_wxObject(void *x) {
33888 return (void *)((wxObject *) ((wxClipboard *) x));
33889 }
33890 static void *_p_wxPySizerTo_p_wxObject(void *x) {
33891 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
33892 }
33893 static void *_p_wxPyEventTo_p_wxObject(void *x) {
33894 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
33895 }
33896 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
33897 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
33898 }
33899 static void *_p_wxShowEventTo_p_wxObject(void *x) {
33900 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
33901 }
33902 static void *_p_wxToolTipTo_p_wxObject(void *x) {
33903 return (void *)((wxObject *) ((wxToolTip *) x));
33904 }
33905 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
33906 return (void *)((wxObject *) ((wxMenuItem *) x));
33907 }
33908 static void *_p_wxDateEventTo_p_wxObject(void *x) {
33909 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
33910 }
33911 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
33912 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
33913 }
33914 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
33915 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
33916 }
33917 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
33918 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
33919 }
33920 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
33921 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
33922 }
33923 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
33924 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
33925 }
33926 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
33927 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
33928 }
33929 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
33930 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
33931 }
33932 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
33933 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
33934 }
33935 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
33936 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
33937 }
33938 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
33939 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
33940 }
33941 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
33942 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
33943 }
33944 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
33945 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
33946 }
33947 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
33948 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
33949 }
33950 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
33951 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
33952 }
33953 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
33954 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
33955 }
33956 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
33957 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
33958 }
33959 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
33960 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
33961 }
33962 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
33963 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
33964 }
33965 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
33966 return (void *)((wxObject *) ((wxImageHandler *) x));
33967 }
33968 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
33969 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
33970 }
33971 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
33972 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
33973 }
33974 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
33975 return (void *)((wxObject *) ((wxEvtHandler *) x));
33976 }
33977 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
33978 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
33979 }
33980 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
33981 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
33982 }
33983 static void *_p_wxImageTo_p_wxObject(void *x) {
33984 return (void *)((wxObject *) ((wxImage *) x));
33985 }
33986 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
33987 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
33988 }
33989 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
33990 return (void *)((wxObject *) ((wxSystemOptions *) x));
33991 }
33992 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
33993 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
33994 }
33995 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
33996 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
33997 }
33998 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
33999 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
34000 }
34001 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
34002 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
34003 }
34004 static void *_p_wxWindowTo_p_wxObject(void *x) {
34005 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
34006 }
34007 static void *_p_wxMenuTo_p_wxObject(void *x) {
34008 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
34009 }
34010 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
34011 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
34012 }
34013 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
34014 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
34015 }
34016 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
34017 return (void *)((wxObject *) ((wxFileSystem *) x));
34018 }
34019 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
34020 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
34021 }
34022 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
34023 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
34024 }
34025 static void *_p_wxPyAppTo_p_wxObject(void *x) {
34026 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
34027 }
34028 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
34029 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
34030 }
34031 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
34032 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
34033 }
34034 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
34035 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
34036 }
34037 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
34038 return (void *)((wxObject *) ((wxBusyInfo *) x));
34039 }
34040 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
34041 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
34042 }
34043 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
34044 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
34045 }
34046 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
34047 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
34048 }
34049 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
34050 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
34051 }
34052 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
34053 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
34054 }
34055 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
34056 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
34057 }
34058 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
34059 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
34060 }
34061 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
34062 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
34063 }
34064 static void *_p_wxValidatorTo_p_wxObject(void *x) {
34065 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
34066 }
34067 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
34068 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
34069 }
34070 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
34071 return (void *)((wxLog *) ((wxLogBuffer *) x));
34072 }
34073 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
34074 return (void *)((wxLog *) ((wxLogStderr *) x));
34075 }
34076 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
34077 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
34078 }
34079 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
34080 return (void *)((wxLog *) ((wxLogWindow *) x));
34081 }
34082 static void *_p_wxLogChainTo_p_wxLog(void *x) {
34083 return (void *)((wxLog *) ((wxLogChain *) x));
34084 }
34085 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
34086 return (void *)((wxLog *) ((wxLogGui *) x));
34087 }
34088 static void *_p_wxPyLogTo_p_wxLog(void *x) {
34089 return (void *)((wxLog *) ((wxPyLog *) x));
34090 }
34091 static void *_p_wxControlTo_p_wxWindow(void *x) {
34092 return (void *)((wxWindow *) ((wxControl *) x));
34093 }
34094 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
34095 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
34096 }
34097 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
34098 return (void *)((wxWindow *) ((wxMenuBar *) x));
34099 }
34100 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
34101 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
34102 }
34103 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
34104 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
34105 }
34106 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
34107 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, 0};
34108 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
34109 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, 0};
34110 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, 0};
34111 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, 0};
34112 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, 0};
34113 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, 0};
34114 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, 0};
34115 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, 0};
34116 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, 0};
34117 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, 0};
34118 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, 0};
34119 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, 0};
34120 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, 0};
34121 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, 0};
34122 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, 0};
34123 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, 0};
34124 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, 0};
34125 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, 0};
34126 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, 0};
34127 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, 0};
34128 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, 0};
34129 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, 0};
34130 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, 0};
34131 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, 0};
34132 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, 0};
34133 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, 0};
34134 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, 0};
34135 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, 0};
34136 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, 0};
34137 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0};
34138 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, 0};
34139 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0};
34140 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0};
34141 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0};
34142 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0};
34143 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0};
34144 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0};
34145 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0};
34146 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0};
34147 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0};
34148 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0};
34149 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0};
34150 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0};
34151 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0};
34152 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0};
34153 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0};
34154 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0};
34155 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0};
34156 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0};
34157 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0};
34158 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0};
34159 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0};
34160 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0};
34161 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0};
34162 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0};
34163 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0};
34164 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0};
34165 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0};
34166 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0};
34167 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0};
34168 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0};
34169 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0};
34170 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0};
34171 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0};
34172 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0};
34173 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0};
34174 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0};
34175 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, 0};
34176 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0};
34177 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0};
34178 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0};
34179 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0};
34180 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0};
34181 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0};
34182 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, 0};
34183 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, 0};
34184 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, 0};
34185 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, 0};
34186 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, 0};
34187 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, 0};
34188 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, 0};
34189 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, 0};
34190 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, 0};
34191 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, 0};
34192 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, 0};
34193 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, 0};
34194 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, 0};
34195 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, 0};
34196 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, 0};
34197 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, 0};
34198 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, 0};
34199 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, 0};
34200 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, 0};
34201 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, 0};
34202 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, 0};
34203 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, 0};
34204 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, 0};
34205 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, 0};
34206 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, 0};
34207 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, 0};
34208 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, 0};
34209 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0};
34210 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0};
34211 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0};
34212 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0};
34213 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0};
34214 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0};
34215 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0};
34216 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0};
34217 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0};
34218 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0};
34219 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0};
34220 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0};
34221 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0};
34222 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0};
34223 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0};
34224 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0};
34225 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0};
34226 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0};
34227 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0};
34228 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0};
34229 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0};
34230 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0};
34231 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0};
34232 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0};
34233 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0};
34234 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0};
34235 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0};
34236 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0};
34237 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0};
34238 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0};
34239 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, 0};
34240 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, 0};
34241 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, 0};
34242 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, 0};
34243 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, 0};
34244 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, 0};
34245 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, 0};
34246 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, 0};
34247 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, 0};
34248 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, 0};
34249 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, 0};
34250 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, 0};
34251 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, 0};
34252 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, 0};
34253 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, 0};
34254 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, 0};
34255 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, 0};
34256 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, 0};
34257 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, 0};
34258 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, 0};
34259 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, 0};
34260 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, 0};
34261 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, 0};
34262 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, 0};
34263 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, 0};
34264 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, 0};
34265 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, 0};
34266 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, 0};
34267 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, 0};
34268 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, 0};
34269 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, 0};
34270 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, 0};
34271 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, 0};
34272 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, 0};
34273 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, 0};
34274 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, 0};
34275 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, 0};
34276 static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
34277 static swig_type_info _swigt__std__ptrdiff_t = {"_std__ptrdiff_t", "std::ptrdiff_t", 0, 0, 0};
34278 static swig_type_info _swigt__unsigned_int = {"_unsigned_int", "unsigned int|std::size_t", 0, 0, 0};
34279
34280 static swig_type_info *swig_type_initial[] = {
34281 &_swigt__p_char,
34282 &_swigt__p_form_ops_t,
34283 &_swigt__p_int,
34284 &_swigt__p_unsigned_char,
34285 &_swigt__p_unsigned_int,
34286 &_swigt__p_unsigned_long,
34287 &_swigt__p_void,
34288 &_swigt__p_wxANIHandler,
34289 &_swigt__p_wxAcceleratorTable,
34290 &_swigt__p_wxActivateEvent,
34291 &_swigt__p_wxArrayString,
34292 &_swigt__p_wxBMPHandler,
34293 &_swigt__p_wxBitmap,
34294 &_swigt__p_wxBitmapDataObject,
34295 &_swigt__p_wxBoxSizer,
34296 &_swigt__p_wxBusyCursor,
34297 &_swigt__p_wxBusyInfo,
34298 &_swigt__p_wxCURHandler,
34299 &_swigt__p_wxCaret,
34300 &_swigt__p_wxChar,
34301 &_swigt__p_wxChildFocusEvent,
34302 &_swigt__p_wxClipboard,
34303 &_swigt__p_wxClipboardLocker,
34304 &_swigt__p_wxCloseEvent,
34305 &_swigt__p_wxColour,
34306 &_swigt__p_wxCommandEvent,
34307 &_swigt__p_wxConfig,
34308 &_swigt__p_wxConfigBase,
34309 &_swigt__p_wxConfigPathChanger,
34310 &_swigt__p_wxContextMenuEvent,
34311 &_swigt__p_wxControl,
34312 &_swigt__p_wxControlWithItems,
34313 &_swigt__p_wxCursor,
34314 &_swigt__p_wxCustomDataObject,
34315 &_swigt__p_wxDC,
34316 &_swigt__p_wxDataFormat,
34317 &_swigt__p_wxDataObject,
34318 &_swigt__p_wxDataObjectComposite,
34319 &_swigt__p_wxDataObjectSimple,
34320 &_swigt__p_wxDateEvent,
34321 &_swigt__p_wxDateSpan,
34322 &_swigt__p_wxDateTime,
34323 &_swigt__p_wxDateTime__TimeZone,
34324 &_swigt__p_wxDisplay,
34325 &_swigt__p_wxDisplayChangedEvent,
34326 &_swigt__p_wxDropFilesEvent,
34327 &_swigt__p_wxDuplexMode,
34328 &_swigt__p_wxEraseEvent,
34329 &_swigt__p_wxEvent,
34330 &_swigt__p_wxEvtHandler,
34331 &_swigt__p_wxFSFile,
34332 &_swigt__p_wxFileConfig,
34333 &_swigt__p_wxFileDataObject,
34334 &_swigt__p_wxFileHistory,
34335 &_swigt__p_wxFileSystem,
34336 &_swigt__p_wxFileType,
34337 &_swigt__p_wxFileTypeInfo,
34338 &_swigt__p_wxFlexGridSizer,
34339 &_swigt__p_wxFocusEvent,
34340 &_swigt__p_wxFont,
34341 &_swigt__p_wxFrame,
34342 &_swigt__p_wxGBSizerItem,
34343 &_swigt__p_wxGIFHandler,
34344 &_swigt__p_wxGridBagSizer,
34345 &_swigt__p_wxGridSizer,
34346 &_swigt__p_wxICOHandler,
34347 &_swigt__p_wxIcon,
34348 &_swigt__p_wxIconizeEvent,
34349 &_swigt__p_wxIdleEvent,
34350 &_swigt__p_wxImage,
34351 &_swigt__p_wxImageHandler,
34352 &_swigt__p_wxIndividualLayoutConstraint,
34353 &_swigt__p_wxInitDialogEvent,
34354 &_swigt__p_wxJPEGHandler,
34355 &_swigt__p_wxJoystick,
34356 &_swigt__p_wxJoystickEvent,
34357 &_swigt__p_wxKeyEvent,
34358 &_swigt__p_wxKillError,
34359 &_swigt__p_wxLayoutConstraints,
34360 &_swigt__p_wxLog,
34361 &_swigt__p_wxLogBuffer,
34362 &_swigt__p_wxLogChain,
34363 &_swigt__p_wxLogGui,
34364 &_swigt__p_wxLogNull,
34365 &_swigt__p_wxLogStderr,
34366 &_swigt__p_wxLogTextCtrl,
34367 &_swigt__p_wxLogWindow,
34368 &_swigt__p_wxMaximizeEvent,
34369 &_swigt__p_wxMemorySize,
34370 &_swigt__p_wxMenu,
34371 &_swigt__p_wxMenuBar,
34372 &_swigt__p_wxMenuEvent,
34373 &_swigt__p_wxMenuItem,
34374 &_swigt__p_wxMetafile,
34375 &_swigt__p_wxMetafileDataObject,
34376 &_swigt__p_wxMimeTypesManager,
34377 &_swigt__p_wxMouseCaptureChangedEvent,
34378 &_swigt__p_wxMouseEvent,
34379 &_swigt__p_wxMouseState,
34380 &_swigt__p_wxMoveEvent,
34381 &_swigt__p_wxMutexGuiLocker,
34382 &_swigt__p_wxNavigationKeyEvent,
34383 &_swigt__p_wxNcPaintEvent,
34384 &_swigt__p_wxNotifyEvent,
34385 &_swigt__p_wxObject,
34386 &_swigt__p_wxOutputStream,
34387 &_swigt__p_wxPCXHandler,
34388 &_swigt__p_wxPNGHandler,
34389 &_swigt__p_wxPNMHandler,
34390 &_swigt__p_wxPaintEvent,
34391 &_swigt__p_wxPaletteChangedEvent,
34392 &_swigt__p_wxPaperSize,
34393 &_swigt__p_wxPoint,
34394 &_swigt__p_wxProcessEvent,
34395 &_swigt__p_wxPyApp,
34396 &_swigt__p_wxPyArtProvider,
34397 &_swigt__p_wxPyBitmapDataObject,
34398 &_swigt__p_wxPyCommandEvent,
34399 &_swigt__p_wxPyDataObjectSimple,
34400 &_swigt__p_wxPyDropSource,
34401 &_swigt__p_wxPyDropTarget,
34402 &_swigt__p_wxPyEvent,
34403 &_swigt__p_wxPyFileDropTarget,
34404 &_swigt__p_wxPyImageHandler,
34405 &_swigt__p_wxPyLog,
34406 &_swigt__p_wxPyProcess,
34407 &_swigt__p_wxPySizer,
34408 &_swigt__p_wxPyTextDataObject,
34409 &_swigt__p_wxPyTextDropTarget,
34410 &_swigt__p_wxPyTimer,
34411 &_swigt__p_wxPyTipProvider,
34412 &_swigt__p_wxPyValidator,
34413 &_swigt__p_wxQueryNewPaletteEvent,
34414 &_swigt__p_wxRect,
34415 &_swigt__p_wxScrollEvent,
34416 &_swigt__p_wxScrollWinEvent,
34417 &_swigt__p_wxSetCursorEvent,
34418 &_swigt__p_wxShowEvent,
34419 &_swigt__p_wxSingleInstanceChecker,
34420 &_swigt__p_wxSize,
34421 &_swigt__p_wxSizeEvent,
34422 &_swigt__p_wxSizer,
34423 &_swigt__p_wxSizerItem,
34424 &_swigt__p_wxSound,
34425 &_swigt__p_wxStandardPaths,
34426 &_swigt__p_wxStaticBoxSizer,
34427 &_swigt__p_wxStdDialogButtonSizer,
34428 &_swigt__p_wxStopWatch,
34429 &_swigt__p_wxString,
34430 &_swigt__p_wxSysColourChangedEvent,
34431 &_swigt__p_wxSystemOptions,
34432 &_swigt__p_wxSystemSettings,
34433 &_swigt__p_wxTIFFHandler,
34434 &_swigt__p_wxTextCtrl,
34435 &_swigt__p_wxTextDataObject,
34436 &_swigt__p_wxTimeSpan,
34437 &_swigt__p_wxTimer,
34438 &_swigt__p_wxTimerEvent,
34439 &_swigt__p_wxTimerRunner,
34440 &_swigt__p_wxTipProvider,
34441 &_swigt__p_wxToolTip,
34442 &_swigt__p_wxURLDataObject,
34443 &_swigt__p_wxUpdateUIEvent,
34444 &_swigt__p_wxValidator,
34445 &_swigt__p_wxVideoMode,
34446 &_swigt__p_wxWindow,
34447 &_swigt__p_wxWindowCreateEvent,
34448 &_swigt__p_wxWindowDestroyEvent,
34449 &_swigt__p_wxWindowDisabler,
34450 &_swigt__p_wxXPMHandler,
34451 &_swigt__ptrdiff_t,
34452 &_swigt__std__ptrdiff_t,
34453 &_swigt__unsigned_int,
34454 };
34455
34456 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
34457 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
34458 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
34459 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
34460 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
34461 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
34462 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
34463 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
34464 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
34465 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}};
34466 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
34467 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
34468 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
34469 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
34470 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
34471 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
34472 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
34473 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
34474 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}};
34475 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
34476 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
34477 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
34478 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
34479 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
34480 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}};
34481 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
34482 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}};
34483 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
34484 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
34485 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
34486 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
34487 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
34488 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
34489 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
34490 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
34491 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
34492 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
34493 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
34494 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
34495 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
34496 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
34497 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
34498 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
34499 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
34500 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
34501 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
34502 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
34503 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
34504 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
34505 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
34506 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
34507 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
34508 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
34509 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
34510 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34511 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34512 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34513 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34514 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
34515 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
34516 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
34517 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
34518 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
34519 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
34520 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
34521 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
34522 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
34523 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
34524 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}};
34525 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
34526 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
34527 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
34528 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
34529 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
34530 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
34531 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}};
34532 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
34533 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
34534 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
34535 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
34536 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
34537 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
34538 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
34539 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
34540 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
34541 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
34542 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
34543 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}};
34544 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
34545 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
34546 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
34547 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
34548 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
34549 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
34550 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
34551 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
34552 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
34553 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
34554 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
34555 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
34556 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
34557 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
34558 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
34559 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
34560 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
34561 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
34562 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
34563 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
34564 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
34565 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
34566 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
34567 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
34568 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
34569 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
34570 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
34571 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
34572 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
34573 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
34574 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
34575 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
34576 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
34577 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
34578 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
34579 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
34580 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
34581 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
34582 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
34583 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
34584 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
34585 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
34586 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
34587 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
34588 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}};
34589 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
34590 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
34591 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
34592 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
34593 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
34594 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
34595 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
34596 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
34597 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}};
34598 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
34599 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
34600 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
34601 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
34602 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
34603 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
34604 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
34605 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
34606 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
34607 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
34608 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
34609 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
34610 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
34611 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
34612 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
34613 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
34614 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
34615 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}};
34616 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
34617 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
34618 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
34619 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
34620 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}};
34621 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
34622 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
34623 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
34624 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}};
34625 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
34626 static swig_cast_info _swigc__ptrdiff_t[] = { {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
34627 static swig_cast_info _swigc__std__ptrdiff_t[] = { {&_swigt__std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
34628 static swig_cast_info _swigc__unsigned_int[] = { {&_swigt__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
34629
34630 static swig_cast_info *swig_cast_initial[] = {
34631 _swigc__p_char,
34632 _swigc__p_form_ops_t,
34633 _swigc__p_int,
34634 _swigc__p_unsigned_char,
34635 _swigc__p_unsigned_int,
34636 _swigc__p_unsigned_long,
34637 _swigc__p_void,
34638 _swigc__p_wxANIHandler,
34639 _swigc__p_wxAcceleratorTable,
34640 _swigc__p_wxActivateEvent,
34641 _swigc__p_wxArrayString,
34642 _swigc__p_wxBMPHandler,
34643 _swigc__p_wxBitmap,
34644 _swigc__p_wxBitmapDataObject,
34645 _swigc__p_wxBoxSizer,
34646 _swigc__p_wxBusyCursor,
34647 _swigc__p_wxBusyInfo,
34648 _swigc__p_wxCURHandler,
34649 _swigc__p_wxCaret,
34650 _swigc__p_wxChar,
34651 _swigc__p_wxChildFocusEvent,
34652 _swigc__p_wxClipboard,
34653 _swigc__p_wxClipboardLocker,
34654 _swigc__p_wxCloseEvent,
34655 _swigc__p_wxColour,
34656 _swigc__p_wxCommandEvent,
34657 _swigc__p_wxConfig,
34658 _swigc__p_wxConfigBase,
34659 _swigc__p_wxConfigPathChanger,
34660 _swigc__p_wxContextMenuEvent,
34661 _swigc__p_wxControl,
34662 _swigc__p_wxControlWithItems,
34663 _swigc__p_wxCursor,
34664 _swigc__p_wxCustomDataObject,
34665 _swigc__p_wxDC,
34666 _swigc__p_wxDataFormat,
34667 _swigc__p_wxDataObject,
34668 _swigc__p_wxDataObjectComposite,
34669 _swigc__p_wxDataObjectSimple,
34670 _swigc__p_wxDateEvent,
34671 _swigc__p_wxDateSpan,
34672 _swigc__p_wxDateTime,
34673 _swigc__p_wxDateTime__TimeZone,
34674 _swigc__p_wxDisplay,
34675 _swigc__p_wxDisplayChangedEvent,
34676 _swigc__p_wxDropFilesEvent,
34677 _swigc__p_wxDuplexMode,
34678 _swigc__p_wxEraseEvent,
34679 _swigc__p_wxEvent,
34680 _swigc__p_wxEvtHandler,
34681 _swigc__p_wxFSFile,
34682 _swigc__p_wxFileConfig,
34683 _swigc__p_wxFileDataObject,
34684 _swigc__p_wxFileHistory,
34685 _swigc__p_wxFileSystem,
34686 _swigc__p_wxFileType,
34687 _swigc__p_wxFileTypeInfo,
34688 _swigc__p_wxFlexGridSizer,
34689 _swigc__p_wxFocusEvent,
34690 _swigc__p_wxFont,
34691 _swigc__p_wxFrame,
34692 _swigc__p_wxGBSizerItem,
34693 _swigc__p_wxGIFHandler,
34694 _swigc__p_wxGridBagSizer,
34695 _swigc__p_wxGridSizer,
34696 _swigc__p_wxICOHandler,
34697 _swigc__p_wxIcon,
34698 _swigc__p_wxIconizeEvent,
34699 _swigc__p_wxIdleEvent,
34700 _swigc__p_wxImage,
34701 _swigc__p_wxImageHandler,
34702 _swigc__p_wxIndividualLayoutConstraint,
34703 _swigc__p_wxInitDialogEvent,
34704 _swigc__p_wxJPEGHandler,
34705 _swigc__p_wxJoystick,
34706 _swigc__p_wxJoystickEvent,
34707 _swigc__p_wxKeyEvent,
34708 _swigc__p_wxKillError,
34709 _swigc__p_wxLayoutConstraints,
34710 _swigc__p_wxLog,
34711 _swigc__p_wxLogBuffer,
34712 _swigc__p_wxLogChain,
34713 _swigc__p_wxLogGui,
34714 _swigc__p_wxLogNull,
34715 _swigc__p_wxLogStderr,
34716 _swigc__p_wxLogTextCtrl,
34717 _swigc__p_wxLogWindow,
34718 _swigc__p_wxMaximizeEvent,
34719 _swigc__p_wxMemorySize,
34720 _swigc__p_wxMenu,
34721 _swigc__p_wxMenuBar,
34722 _swigc__p_wxMenuEvent,
34723 _swigc__p_wxMenuItem,
34724 _swigc__p_wxMetafile,
34725 _swigc__p_wxMetafileDataObject,
34726 _swigc__p_wxMimeTypesManager,
34727 _swigc__p_wxMouseCaptureChangedEvent,
34728 _swigc__p_wxMouseEvent,
34729 _swigc__p_wxMouseState,
34730 _swigc__p_wxMoveEvent,
34731 _swigc__p_wxMutexGuiLocker,
34732 _swigc__p_wxNavigationKeyEvent,
34733 _swigc__p_wxNcPaintEvent,
34734 _swigc__p_wxNotifyEvent,
34735 _swigc__p_wxObject,
34736 _swigc__p_wxOutputStream,
34737 _swigc__p_wxPCXHandler,
34738 _swigc__p_wxPNGHandler,
34739 _swigc__p_wxPNMHandler,
34740 _swigc__p_wxPaintEvent,
34741 _swigc__p_wxPaletteChangedEvent,
34742 _swigc__p_wxPaperSize,
34743 _swigc__p_wxPoint,
34744 _swigc__p_wxProcessEvent,
34745 _swigc__p_wxPyApp,
34746 _swigc__p_wxPyArtProvider,
34747 _swigc__p_wxPyBitmapDataObject,
34748 _swigc__p_wxPyCommandEvent,
34749 _swigc__p_wxPyDataObjectSimple,
34750 _swigc__p_wxPyDropSource,
34751 _swigc__p_wxPyDropTarget,
34752 _swigc__p_wxPyEvent,
34753 _swigc__p_wxPyFileDropTarget,
34754 _swigc__p_wxPyImageHandler,
34755 _swigc__p_wxPyLog,
34756 _swigc__p_wxPyProcess,
34757 _swigc__p_wxPySizer,
34758 _swigc__p_wxPyTextDataObject,
34759 _swigc__p_wxPyTextDropTarget,
34760 _swigc__p_wxPyTimer,
34761 _swigc__p_wxPyTipProvider,
34762 _swigc__p_wxPyValidator,
34763 _swigc__p_wxQueryNewPaletteEvent,
34764 _swigc__p_wxRect,
34765 _swigc__p_wxScrollEvent,
34766 _swigc__p_wxScrollWinEvent,
34767 _swigc__p_wxSetCursorEvent,
34768 _swigc__p_wxShowEvent,
34769 _swigc__p_wxSingleInstanceChecker,
34770 _swigc__p_wxSize,
34771 _swigc__p_wxSizeEvent,
34772 _swigc__p_wxSizer,
34773 _swigc__p_wxSizerItem,
34774 _swigc__p_wxSound,
34775 _swigc__p_wxStandardPaths,
34776 _swigc__p_wxStaticBoxSizer,
34777 _swigc__p_wxStdDialogButtonSizer,
34778 _swigc__p_wxStopWatch,
34779 _swigc__p_wxString,
34780 _swigc__p_wxSysColourChangedEvent,
34781 _swigc__p_wxSystemOptions,
34782 _swigc__p_wxSystemSettings,
34783 _swigc__p_wxTIFFHandler,
34784 _swigc__p_wxTextCtrl,
34785 _swigc__p_wxTextDataObject,
34786 _swigc__p_wxTimeSpan,
34787 _swigc__p_wxTimer,
34788 _swigc__p_wxTimerEvent,
34789 _swigc__p_wxTimerRunner,
34790 _swigc__p_wxTipProvider,
34791 _swigc__p_wxToolTip,
34792 _swigc__p_wxURLDataObject,
34793 _swigc__p_wxUpdateUIEvent,
34794 _swigc__p_wxValidator,
34795 _swigc__p_wxVideoMode,
34796 _swigc__p_wxWindow,
34797 _swigc__p_wxWindowCreateEvent,
34798 _swigc__p_wxWindowDestroyEvent,
34799 _swigc__p_wxWindowDisabler,
34800 _swigc__p_wxXPMHandler,
34801 _swigc__ptrdiff_t,
34802 _swigc__std__ptrdiff_t,
34803 _swigc__unsigned_int,
34804 };
34805
34806
34807 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
34808
34809 static swig_const_info swig_const_table[] = {
34810 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
34811 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
34812 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
34813 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
34814 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
34815 {0, 0, 0, 0.0, 0, 0}};
34816
34817 #ifdef __cplusplus
34818 }
34819 #endif
34820 /*************************************************************************
34821 * Type initialization:
34822 * This problem is tough by the requirement that no dynamic
34823 * memory is used. Also, since swig_type_info structures store pointers to
34824 * swig_cast_info structures and swig_cast_info structures store pointers back
34825 * to swig_type_info structures, we need some lookup code at initialization.
34826 * The idea is that swig generates all the structures that are needed.
34827 * The runtime then collects these partially filled structures.
34828 * The SWIG_InitializeModule function takes these initial arrays out of
34829 * swig_module, and does all the lookup, filling in the swig_module.types
34830 * array with the correct data and linking the correct swig_cast_info
34831 * structures together.
34832
34833 * The generated swig_type_info structures are assigned staticly to an initial
34834 * array. We just loop though that array, and handle each type individually.
34835 * First we lookup if this type has been already loaded, and if so, use the
34836 * loaded structure instead of the generated one. Then we have to fill in the
34837 * cast linked list. The cast data is initially stored in something like a
34838 * two-dimensional array. Each row corresponds to a type (there are the same
34839 * number of rows as there are in the swig_type_initial array). Each entry in
34840 * a column is one of the swig_cast_info structures for that type.
34841 * The cast_initial array is actually an array of arrays, because each row has
34842 * a variable number of columns. So to actually build the cast linked list,
34843 * we find the array of casts associated with the type, and loop through it
34844 * adding the casts to the list. The one last trick we need to do is making
34845 * sure the type pointer in the swig_cast_info struct is correct.
34846
34847 * First off, we lookup the cast->type name to see if it is already loaded.
34848 * There are three cases to handle:
34849 * 1) If the cast->type has already been loaded AND the type we are adding
34850 * casting info to has not been loaded (it is in this module), THEN we
34851 * replace the cast->type pointer with the type pointer that has already
34852 * been loaded.
34853 * 2) If BOTH types (the one we are adding casting info to, and the
34854 * cast->type) are loaded, THEN the cast info has already been loaded by
34855 * the previous module so we just ignore it.
34856 * 3) Finally, if cast->type has not already been loaded, then we add that
34857 * swig_cast_info to the linked list (because the cast->type) pointer will
34858 * be correct.
34859 **/
34860
34861 #ifdef __cplusplus
34862 extern "C" {
34863 #if 0
34864 } /* c-mode */
34865 #endif
34866 #endif
34867
34868 #if 0
34869 #define SWIGRUNTIME_DEBUG
34870 #endif
34871
34872 SWIGRUNTIME void
34873 SWIG_InitializeModule(void *clientdata) {
34874 size_t i;
34875 swig_module_info *module_head;
34876 static int init_run = 0;
34877
34878 clientdata = clientdata;
34879
34880 if (init_run) return;
34881 init_run = 1;
34882
34883 /* Initialize the swig_module */
34884 swig_module.type_initial = swig_type_initial;
34885 swig_module.cast_initial = swig_cast_initial;
34886
34887 /* Try and load any already created modules */
34888 module_head = SWIG_GetModule(clientdata);
34889 if (module_head) {
34890 swig_module.next = module_head->next;
34891 module_head->next = &swig_module;
34892 } else {
34893 /* This is the first module loaded */
34894 swig_module.next = &swig_module;
34895 SWIG_SetModule(clientdata, &swig_module);
34896 }
34897
34898 /* Now work on filling in swig_module.types */
34899 #ifdef SWIGRUNTIME_DEBUG
34900 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
34901 #endif
34902 for (i = 0; i < swig_module.size; ++i) {
34903 swig_type_info *type = 0;
34904 swig_type_info *ret;
34905 swig_cast_info *cast;
34906
34907 #ifdef SWIGRUNTIME_DEBUG
34908 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
34909 #endif
34910
34911 /* if there is another module already loaded */
34912 if (swig_module.next != &swig_module) {
34913 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
34914 }
34915 if (type) {
34916 /* Overwrite clientdata field */
34917 #ifdef SWIGRUNTIME_DEBUG
34918 printf("SWIG_InitializeModule: found type %s\n", type->name);
34919 #endif
34920 if (swig_module.type_initial[i]->clientdata) {
34921 type->clientdata = swig_module.type_initial[i]->clientdata;
34922 #ifdef SWIGRUNTIME_DEBUG
34923 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
34924 #endif
34925 }
34926 } else {
34927 type = swig_module.type_initial[i];
34928 }
34929
34930 /* Insert casting types */
34931 cast = swig_module.cast_initial[i];
34932 while (cast->type) {
34933 /* Don't need to add information already in the list */
34934 ret = 0;
34935 #ifdef SWIGRUNTIME_DEBUG
34936 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
34937 #endif
34938 if (swig_module.next != &swig_module) {
34939 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
34940 #ifdef SWIGRUNTIME_DEBUG
34941 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
34942 #endif
34943 }
34944 if (ret) {
34945 if (type == swig_module.type_initial[i]) {
34946 #ifdef SWIGRUNTIME_DEBUG
34947 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
34948 #endif
34949 cast->type = ret;
34950 ret = 0;
34951 } else {
34952 /* Check for casting already in the list */
34953 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
34954 #ifdef SWIGRUNTIME_DEBUG
34955 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
34956 #endif
34957 if (!ocast) ret = 0;
34958 }
34959 }
34960
34961 if (!ret) {
34962 #ifdef SWIGRUNTIME_DEBUG
34963 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
34964 #endif
34965 if (type->cast) {
34966 type->cast->prev = cast;
34967 cast->next = type->cast;
34968 }
34969 type->cast = cast;
34970 }
34971 cast++;
34972 }
34973 /* Set entry in modules->types array equal to the type */
34974 swig_module.types[i] = type;
34975 }
34976 swig_module.types[i] = 0;
34977
34978 #ifdef SWIGRUNTIME_DEBUG
34979 printf("**** SWIG_InitializeModule: Cast List ******\n");
34980 for (i = 0; i < swig_module.size; ++i) {
34981 int j = 0;
34982 swig_cast_info *cast = swig_module.cast_initial[i];
34983 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
34984 while (cast->type) {
34985 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
34986 cast++;
34987 ++j;
34988 }
34989 printf("---- Total casts: %d\n",j);
34990 }
34991 printf("**** SWIG_InitializeModule: Cast List ******\n");
34992 #endif
34993 }
34994
34995 /* This function will propagate the clientdata field of type to
34996 * any new swig_type_info structures that have been added into the list
34997 * of equivalent types. It is like calling
34998 * SWIG_TypeClientData(type, clientdata) a second time.
34999 */
35000 SWIGRUNTIME void
35001 SWIG_PropagateClientData(void) {
35002 size_t i;
35003 swig_cast_info *equiv;
35004 static int init_run = 0;
35005
35006 if (init_run) return;
35007 init_run = 1;
35008
35009 for (i = 0; i < swig_module.size; i++) {
35010 if (swig_module.types[i]->clientdata) {
35011 equiv = swig_module.types[i]->cast;
35012 while (equiv) {
35013 if (!equiv->converter) {
35014 if (equiv->type && !equiv->type->clientdata)
35015 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
35016 }
35017 equiv = equiv->next;
35018 }
35019 }
35020 }
35021 }
35022
35023 #ifdef __cplusplus
35024 #if 0
35025 {
35026 /* c-mode */
35027 #endif
35028 }
35029 #endif
35030
35031
35032
35033 #ifdef __cplusplus
35034 extern "C" {
35035 #endif
35036
35037 /* Python-specific SWIG API */
35038 #define SWIG_newvarlink() SWIG_Python_newvarlink()
35039 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
35040 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
35041
35042 /* -----------------------------------------------------------------------------
35043 * global variable support code.
35044 * ----------------------------------------------------------------------------- */
35045
35046 typedef struct swig_globalvar {
35047 char *name; /* Name of global variable */
35048 PyObject *(*get_attr)(void); /* Return the current value */
35049 int (*set_attr)(PyObject *); /* Set the value */
35050 struct swig_globalvar *next;
35051 } swig_globalvar;
35052
35053 typedef struct swig_varlinkobject {
35054 PyObject_HEAD
35055 swig_globalvar *vars;
35056 } swig_varlinkobject;
35057
35058 SWIGINTERN PyObject *
35059 swig_varlink_repr(swig_varlinkobject *v) {
35060 v = v;
35061 return PyString_FromString("<Swig global variables>");
35062 }
35063
35064 SWIGINTERN int
35065 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
35066 swig_globalvar *var;
35067 flags = flags;
35068 fprintf(fp,"Swig global variables { ");
35069 for (var = v->vars; var; var=var->next) {
35070 fprintf(fp,"%s", var->name);
35071 if (var->next) fprintf(fp,", ");
35072 }
35073 fprintf(fp," }\n");
35074 return 0;
35075 }
35076
35077 SWIGINTERN PyObject *
35078 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
35079 swig_globalvar *var = v->vars;
35080 while (var) {
35081 if (strcmp(var->name,n) == 0) {
35082 return (*var->get_attr)();
35083 }
35084 var = var->next;
35085 }
35086 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
35087 return NULL;
35088 }
35089
35090 SWIGINTERN int
35091 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
35092 swig_globalvar *var = v->vars;
35093 while (var) {
35094 if (strcmp(var->name,n) == 0) {
35095 return (*var->set_attr)(p);
35096 }
35097 var = var->next;
35098 }
35099 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
35100 return 1;
35101 }
35102
35103 SWIGINTERN PyTypeObject*
35104 swig_varlink_type(void) {
35105 static char varlink__doc__[] = "Swig var link object";
35106 static PyTypeObject varlink_type
35107 #if !defined(__cplusplus)
35108 ;
35109 static int type_init = 0;
35110 if (!type_init) {
35111 PyTypeObject tmp
35112 #endif
35113 = {
35114 PyObject_HEAD_INIT(&PyType_Type)
35115 0, /* Number of items in variable part (ob_size) */
35116 (char *)"swigvarlink", /* Type name (tp_name) */
35117 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
35118 0, /* Itemsize (tp_itemsize) */
35119 0, /* Deallocator (tp_dealloc) */
35120 (printfunc) swig_varlink_print, /* Print (tp_print) */
35121 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
35122 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
35123 0, /* tp_compare */
35124 (reprfunc) swig_varlink_repr, /* tp_repr */
35125 0, /* tp_as_number */
35126 0, /* tp_as_sequence */
35127 0, /* tp_as_mapping */
35128 0, /* tp_hash */
35129 0, /* tp_call */
35130 0, /* tp_str */
35131 0, /* tp_getattro */
35132 0, /* tp_setattro */
35133 0, /* tp_as_buffer */
35134 0, /* tp_flags */
35135 varlink__doc__, /* tp_doc */
35136 #if PY_VERSION_HEX >= 0x02000000
35137 0, /* tp_traverse */
35138 0, /* tp_clear */
35139 #endif
35140 #if PY_VERSION_HEX >= 0x02010000
35141 0, /* tp_richcompare */
35142 0, /* tp_weaklistoffset */
35143 #endif
35144 #if PY_VERSION_HEX >= 0x02020000
35145 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
35146 #endif
35147 #if PY_VERSION_HEX >= 0x02030000
35148 0, /* tp_del */
35149 #endif
35150 #ifdef COUNT_ALLOCS
35151 0,0,0,0 /* tp_alloc -> tp_next */
35152 #endif
35153 };
35154 #if !defined(__cplusplus)
35155 varlink_type = tmp;
35156 type_init = 1;
35157 }
35158 #endif
35159 return &varlink_type;
35160 }
35161
35162 /* Create a variable linking object for use later */
35163 SWIGINTERN PyObject *
35164 SWIG_Python_newvarlink(void) {
35165 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
35166 if (result) {
35167 result->vars = 0;
35168 }
35169 return ((PyObject*) result);
35170 }
35171
35172 SWIGINTERN void
35173 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
35174 swig_varlinkobject *v = (swig_varlinkobject *) p;
35175 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
35176 if (gv) {
35177 size_t size = strlen(name)+1;
35178 gv->name = (char *)malloc(size);
35179 if (gv->name) {
35180 strncpy(gv->name,name,size);
35181 gv->get_attr = get_attr;
35182 gv->set_attr = set_attr;
35183 gv->next = v->vars;
35184 }
35185 }
35186 v->vars = gv;
35187 }
35188
35189 /* -----------------------------------------------------------------------------
35190 * constants/methods manipulation
35191 * ----------------------------------------------------------------------------- */
35192
35193 /* Install Constants */
35194 SWIGINTERN void
35195 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
35196 PyObject *obj = 0;
35197 size_t i;
35198 for (i = 0; constants[i].type; ++i) {
35199 switch(constants[i].type) {
35200 case SWIG_PY_INT:
35201 obj = PyInt_FromLong(constants[i].lvalue);
35202 break;
35203 case SWIG_PY_FLOAT:
35204 obj = PyFloat_FromDouble(constants[i].dvalue);
35205 break;
35206 case SWIG_PY_STRING:
35207 if (constants[i].pvalue) {
35208 obj = PyString_FromString((char *) constants[i].pvalue);
35209 } else {
35210 Py_INCREF(Py_None);
35211 obj = Py_None;
35212 }
35213 break;
35214 case SWIG_PY_POINTER:
35215 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
35216 break;
35217 case SWIG_PY_BINARY:
35218 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
35219 break;
35220 default:
35221 obj = 0;
35222 break;
35223 }
35224 if (obj) {
35225 PyDict_SetItemString(d,constants[i].name,obj);
35226 Py_DECREF(obj);
35227 }
35228 }
35229 }
35230
35231 /* -----------------------------------------------------------------------------*/
35232 /* Fix SwigMethods to carry the callback ptrs when needed */
35233 /* -----------------------------------------------------------------------------*/
35234
35235 SWIGINTERN void
35236 SWIG_Python_FixMethods(PyMethodDef *methods,
35237 swig_const_info *const_table,
35238 swig_type_info **types,
35239 swig_type_info **types_initial) {
35240 size_t i;
35241 for (i = 0; methods[i].ml_name; ++i) {
35242 char *c = methods[i].ml_doc;
35243 if (c && (c = strstr(c, "swig_ptr: "))) {
35244 int j;
35245 swig_const_info *ci = 0;
35246 char *name = c + 10;
35247 for (j = 0; const_table[j].type; ++j) {
35248 if (strncmp(const_table[j].name, name,
35249 strlen(const_table[j].name)) == 0) {
35250 ci = &(const_table[j]);
35251 break;
35252 }
35253 }
35254 if (ci) {
35255 size_t shift = (ci->ptype) - types;
35256 swig_type_info *ty = types_initial[shift];
35257 size_t ldoc = (c - methods[i].ml_doc);
35258 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
35259 char *ndoc = (char*)malloc(ldoc + lptr + 10);
35260 if (ndoc) {
35261 char *buff = ndoc;
35262 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
35263 if (ptr) {
35264 strncpy(buff, methods[i].ml_doc, ldoc);
35265 buff += ldoc;
35266 strncpy(buff, "swig_ptr: ", 10);
35267 buff += 10;
35268 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
35269 methods[i].ml_doc = ndoc;
35270 }
35271 }
35272 }
35273 }
35274 }
35275 }
35276
35277 /* -----------------------------------------------------------------------------*
35278 * Initialize type list
35279 * -----------------------------------------------------------------------------*/
35280
35281 #ifdef __cplusplus
35282 }
35283 #endif
35284
35285 /* -----------------------------------------------------------------------------*
35286 * Partial Init method
35287 * -----------------------------------------------------------------------------*/
35288
35289 #ifdef __cplusplus
35290 extern "C"
35291 #endif
35292 SWIGEXPORT void SWIG_init(void) {
35293 static PyObject *SWIG_globals = 0;
35294 PyObject *m, *d;
35295 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
35296
35297 /* Fix SwigMethods to carry the callback ptrs when needed */
35298 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
35299
35300 m = Py_InitModule((char *) SWIG_name, SwigMethods);
35301 d = PyModule_GetDict(m);
35302
35303 SWIG_InitializeModule(0);
35304 SWIG_InstallConstants(d,swig_const_table);
35305
35306 {
35307 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int(static_cast<int >(wxSYS_OEM_FIXED_FONT)));
35308 }
35309 {
35310 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int(static_cast<int >(wxSYS_ANSI_FIXED_FONT)));
35311 }
35312 {
35313 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int(static_cast<int >(wxSYS_ANSI_VAR_FONT)));
35314 }
35315 {
35316 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int(static_cast<int >(wxSYS_SYSTEM_FONT)));
35317 }
35318 {
35319 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int(static_cast<int >(wxSYS_DEVICE_DEFAULT_FONT)));
35320 }
35321 {
35322 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int(static_cast<int >(wxSYS_DEFAULT_PALETTE)));
35323 }
35324 {
35325 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int(static_cast<int >(wxSYS_SYSTEM_FIXED_FONT)));
35326 }
35327 {
35328 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int(static_cast<int >(wxSYS_DEFAULT_GUI_FONT)));
35329 }
35330 {
35331 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int(static_cast<int >(wxSYS_ICONTITLE_FONT)));
35332 }
35333 {
35334 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_SCROLLBAR)));
35335 }
35336 {
35337 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BACKGROUND)));
35338 }
35339 {
35340 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_DESKTOP)));
35341 }
35342 {
35343 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_ACTIVECAPTION)));
35344 }
35345 {
35346 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INACTIVECAPTION)));
35347 }
35348 {
35349 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MENU)));
35350 }
35351 {
35352 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_WINDOW)));
35353 }
35354 {
35355 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_WINDOWFRAME)));
35356 }
35357 {
35358 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MENUTEXT)));
35359 }
35360 {
35361 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_WINDOWTEXT)));
35362 }
35363 {
35364 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_CAPTIONTEXT)));
35365 }
35366 {
35367 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_ACTIVEBORDER)));
35368 }
35369 {
35370 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INACTIVEBORDER)));
35371 }
35372 {
35373 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_APPWORKSPACE)));
35374 }
35375 {
35376 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_HIGHLIGHT)));
35377 }
35378 {
35379 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
35380 }
35381 {
35382 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNFACE)));
35383 }
35384 {
35385 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DFACE)));
35386 }
35387 {
35388 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNSHADOW)));
35389 }
35390 {
35391 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DSHADOW)));
35392 }
35393 {
35394 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_GRAYTEXT)));
35395 }
35396 {
35397 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNTEXT)));
35398 }
35399 {
35400 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
35401 }
35402 {
35403 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
35404 }
35405 {
35406 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNHILIGHT)));
35407 }
35408 {
35409 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DHIGHLIGHT)));
35410 }
35411 {
35412 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DHILIGHT)));
35413 }
35414 {
35415 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DDKSHADOW)));
35416 }
35417 {
35418 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DLIGHT)));
35419 }
35420 {
35421 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INFOTEXT)));
35422 }
35423 {
35424 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INFOBK)));
35425 }
35426 {
35427 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_LISTBOX)));
35428 }
35429 {
35430 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_HOTLIGHT)));
35431 }
35432 {
35433 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
35434 }
35435 {
35436 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
35437 }
35438 {
35439 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MENUHILIGHT)));
35440 }
35441 {
35442 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MENUBAR)));
35443 }
35444 {
35445 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MAX)));
35446 }
35447 {
35448 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int(static_cast<int >(wxSYS_MOUSE_BUTTONS)));
35449 }
35450 {
35451 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int(static_cast<int >(wxSYS_BORDER_X)));
35452 }
35453 {
35454 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int(static_cast<int >(wxSYS_BORDER_Y)));
35455 }
35456 {
35457 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int(static_cast<int >(wxSYS_CURSOR_X)));
35458 }
35459 {
35460 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int(static_cast<int >(wxSYS_CURSOR_Y)));
35461 }
35462 {
35463 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int(static_cast<int >(wxSYS_DCLICK_X)));
35464 }
35465 {
35466 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int(static_cast<int >(wxSYS_DCLICK_Y)));
35467 }
35468 {
35469 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int(static_cast<int >(wxSYS_DRAG_X)));
35470 }
35471 {
35472 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int(static_cast<int >(wxSYS_DRAG_Y)));
35473 }
35474 {
35475 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int(static_cast<int >(wxSYS_EDGE_X)));
35476 }
35477 {
35478 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int(static_cast<int >(wxSYS_EDGE_Y)));
35479 }
35480 {
35481 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int(static_cast<int >(wxSYS_HSCROLL_ARROW_X)));
35482 }
35483 {
35484 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int(static_cast<int >(wxSYS_HSCROLL_ARROW_Y)));
35485 }
35486 {
35487 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int(static_cast<int >(wxSYS_HTHUMB_X)));
35488 }
35489 {
35490 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int(static_cast<int >(wxSYS_ICON_X)));
35491 }
35492 {
35493 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int(static_cast<int >(wxSYS_ICON_Y)));
35494 }
35495 {
35496 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int(static_cast<int >(wxSYS_ICONSPACING_X)));
35497 }
35498 {
35499 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int(static_cast<int >(wxSYS_ICONSPACING_Y)));
35500 }
35501 {
35502 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int(static_cast<int >(wxSYS_WINDOWMIN_X)));
35503 }
35504 {
35505 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int(static_cast<int >(wxSYS_WINDOWMIN_Y)));
35506 }
35507 {
35508 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_X)));
35509 }
35510 {
35511 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_Y)));
35512 }
35513 {
35514 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int(static_cast<int >(wxSYS_FRAMESIZE_X)));
35515 }
35516 {
35517 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int(static_cast<int >(wxSYS_FRAMESIZE_Y)));
35518 }
35519 {
35520 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int(static_cast<int >(wxSYS_SMALLICON_X)));
35521 }
35522 {
35523 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int(static_cast<int >(wxSYS_SMALLICON_Y)));
35524 }
35525 {
35526 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int(static_cast<int >(wxSYS_HSCROLL_Y)));
35527 }
35528 {
35529 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int(static_cast<int >(wxSYS_VSCROLL_X)));
35530 }
35531 {
35532 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int(static_cast<int >(wxSYS_VSCROLL_ARROW_X)));
35533 }
35534 {
35535 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int(static_cast<int >(wxSYS_VSCROLL_ARROW_Y)));
35536 }
35537 {
35538 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int(static_cast<int >(wxSYS_VTHUMB_Y)));
35539 }
35540 {
35541 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int(static_cast<int >(wxSYS_CAPTION_Y)));
35542 }
35543 {
35544 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int(static_cast<int >(wxSYS_MENU_Y)));
35545 }
35546 {
35547 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int(static_cast<int >(wxSYS_NETWORK_PRESENT)));
35548 }
35549 {
35550 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int(static_cast<int >(wxSYS_PENWINDOWS_PRESENT)));
35551 }
35552 {
35553 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int(static_cast<int >(wxSYS_SHOW_SOUNDS)));
35554 }
35555 {
35556 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int(static_cast<int >(wxSYS_SWAP_BUTTONS)));
35557 }
35558 {
35559 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int(static_cast<int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
35560 }
35561 {
35562 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int(static_cast<int >(wxSYS_CAN_ICONIZE_FRAME)));
35563 }
35564 {
35565 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_NONE)));
35566 }
35567 {
35568 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_TINY)));
35569 }
35570 {
35571 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_PDA)));
35572 }
35573 {
35574 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_SMALL)));
35575 }
35576 {
35577 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_DESKTOP)));
35578 }
35579 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
35580 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
35581 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
35582 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
35583 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
35584 {
35585 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int(static_cast<int >(wxSHUTDOWN_POWEROFF)));
35586 }
35587 {
35588 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int(static_cast<int >(wxSHUTDOWN_REBOOT)));
35589 }
35590 {
35591 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int(static_cast<int >(wxTIMER_CONTINUOUS)));
35592 }
35593 {
35594 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int(static_cast<int >(wxTIMER_ONE_SHOT)));
35595 }
35596 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
35597
35598 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
35599
35600 {
35601 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int(static_cast<int >(wxLOG_FatalError)));
35602 }
35603 {
35604 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int(static_cast<int >(wxLOG_Error)));
35605 }
35606 {
35607 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int(static_cast<int >(wxLOG_Warning)));
35608 }
35609 {
35610 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int(static_cast<int >(wxLOG_Message)));
35611 }
35612 {
35613 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int(static_cast<int >(wxLOG_Status)));
35614 }
35615 {
35616 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int(static_cast<int >(wxLOG_Info)));
35617 }
35618 {
35619 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int(static_cast<int >(wxLOG_Debug)));
35620 }
35621 {
35622 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int(static_cast<int >(wxLOG_Trace)));
35623 }
35624 {
35625 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int(static_cast<int >(wxLOG_Progress)));
35626 }
35627 {
35628 PyDict_SetItemString(d,"LOG_User", SWIG_From_int(static_cast<int >(wxLOG_User)));
35629 }
35630 {
35631 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int(static_cast<int >(wxLOG_Max)));
35632 }
35633 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
35634 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
35635 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
35636 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
35637 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
35638 {
35639 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int(static_cast<int >(0x0001)));
35640 }
35641 {
35642 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int(static_cast<int >(0x0002)));
35643 }
35644 {
35645 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int(static_cast<int >(0x0004)));
35646 }
35647 {
35648 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int(static_cast<int >(0x0008)));
35649 }
35650 {
35651 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int(static_cast<int >(0x0100)));
35652 }
35653 {
35654 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int(static_cast<int >(wxPROCESS_DEFAULT)));
35655 }
35656 {
35657 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int(static_cast<int >(wxPROCESS_REDIRECT)));
35658 }
35659 {
35660 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int(static_cast<int >(wxKILL_OK)));
35661 }
35662 {
35663 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int(static_cast<int >(wxKILL_BAD_SIGNAL)));
35664 }
35665 {
35666 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int(static_cast<int >(wxKILL_ACCESS_DENIED)));
35667 }
35668 {
35669 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int(static_cast<int >(wxKILL_NO_PROCESS)));
35670 }
35671 {
35672 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int(static_cast<int >(wxKILL_ERROR)));
35673 }
35674 {
35675 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int(static_cast<int >(wxKILL_NOCHILDREN)));
35676 }
35677 {
35678 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int(static_cast<int >(wxKILL_CHILDREN)));
35679 }
35680 {
35681 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int(static_cast<int >(wxSIGNONE)));
35682 }
35683 {
35684 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int(static_cast<int >(wxSIGHUP)));
35685 }
35686 {
35687 PyDict_SetItemString(d,"SIGINT", SWIG_From_int(static_cast<int >(wxSIGINT)));
35688 }
35689 {
35690 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int(static_cast<int >(wxSIGQUIT)));
35691 }
35692 {
35693 PyDict_SetItemString(d,"SIGILL", SWIG_From_int(static_cast<int >(wxSIGILL)));
35694 }
35695 {
35696 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int(static_cast<int >(wxSIGTRAP)));
35697 }
35698 {
35699 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int(static_cast<int >(wxSIGABRT)));
35700 }
35701 {
35702 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int(static_cast<int >(wxSIGIOT)));
35703 }
35704 {
35705 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int(static_cast<int >(wxSIGEMT)));
35706 }
35707 {
35708 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int(static_cast<int >(wxSIGFPE)));
35709 }
35710 {
35711 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int(static_cast<int >(wxSIGKILL)));
35712 }
35713 {
35714 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int(static_cast<int >(wxSIGBUS)));
35715 }
35716 {
35717 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int(static_cast<int >(wxSIGSEGV)));
35718 }
35719 {
35720 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int(static_cast<int >(wxSIGSYS)));
35721 }
35722 {
35723 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int(static_cast<int >(wxSIGPIPE)));
35724 }
35725 {
35726 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int(static_cast<int >(wxSIGALRM)));
35727 }
35728 {
35729 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int(static_cast<int >(wxSIGTERM)));
35730 }
35731 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
35732 {
35733 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int(static_cast<int >(wxEXEC_ASYNC)));
35734 }
35735 {
35736 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int(static_cast<int >(wxEXEC_SYNC)));
35737 }
35738 {
35739 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int(static_cast<int >(wxEXEC_NOHIDE)));
35740 }
35741 {
35742 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int(static_cast<int >(wxEXEC_MAKE_GROUP_LEADER)));
35743 }
35744 {
35745 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int(static_cast<int >(wxEXEC_NODISABLE)));
35746 }
35747
35748 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
35749
35750 {
35751 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int(static_cast<int >(wxJOYSTICK1)));
35752 }
35753 {
35754 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int(static_cast<int >(wxJOYSTICK2)));
35755 }
35756 {
35757 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int(static_cast<int >(wxJOY_BUTTON_ANY)));
35758 }
35759 {
35760 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int(static_cast<int >(wxJOY_BUTTON1)));
35761 }
35762 {
35763 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int(static_cast<int >(wxJOY_BUTTON2)));
35764 }
35765 {
35766 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int(static_cast<int >(wxJOY_BUTTON3)));
35767 }
35768 {
35769 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int(static_cast<int >(wxJOY_BUTTON4)));
35770 }
35771 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
35772 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
35773 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
35774 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
35775 {
35776 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int(static_cast<int >(wxSOUND_SYNC)));
35777 }
35778 {
35779 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int(static_cast<int >(wxSOUND_ASYNC)));
35780 }
35781 {
35782 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int(static_cast<int >(wxSOUND_LOOP)));
35783 }
35784 {
35785 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int(static_cast<int >(wxMAILCAP_STANDARD)));
35786 }
35787 {
35788 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int(static_cast<int >(wxMAILCAP_NETSCAPE)));
35789 }
35790 {
35791 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int(static_cast<int >(wxMAILCAP_KDE)));
35792 }
35793 {
35794 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int(static_cast<int >(wxMAILCAP_GNOME)));
35795 }
35796 {
35797 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int(static_cast<int >(wxMAILCAP_ALL)));
35798 }
35799 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
35800 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
35801 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
35802 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
35803 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
35804 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
35805 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
35806 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
35807 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
35808 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
35809 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
35810 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
35811 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
35812 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
35813 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
35814 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
35815 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
35816 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
35817 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
35818 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
35819 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
35820 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
35821 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
35822 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
35823 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
35824 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
35825 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
35826 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
35827 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
35828 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
35829 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
35830 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
35831 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
35832 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
35833 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
35834 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
35835 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
35836 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
35837 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
35838 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
35839 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
35840 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
35841 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
35842 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
35843 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
35844 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
35845 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
35846 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
35847 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
35848 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
35849 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
35850 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW",_wrap_ART_NEW_get, _wrap_ART_NEW_set);
35851 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
35852 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
35853 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
35854 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
35855 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
35856
35857 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
35858
35859 {
35860 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int(static_cast<int >(wxCONFIG_USE_LOCAL_FILE)));
35861 }
35862 {
35863 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int(static_cast<int >(wxCONFIG_USE_GLOBAL_FILE)));
35864 }
35865 {
35866 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int(static_cast<int >(wxCONFIG_USE_RELATIVE_PATH)));
35867 }
35868 {
35869 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int(static_cast<int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
35870 }
35871 {
35872 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int(static_cast<int >(wxConfigBase::Type_Unknown)));
35873 }
35874 {
35875 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int(static_cast<int >(wxConfigBase::Type_String)));
35876 }
35877 {
35878 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int(static_cast<int >(wxConfigBase::Type_Boolean)));
35879 }
35880 {
35881 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int(static_cast<int >(wxConfigBase::Type_Integer)));
35882 }
35883 {
35884 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int(static_cast<int >(wxConfigBase::Type_Float)));
35885 }
35886 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
35887 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
35888 {
35889 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int(static_cast<int >(wxDateTime::Local)));
35890 }
35891 {
35892 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int(static_cast<int >(wxDateTime::GMT_12)));
35893 }
35894 {
35895 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int(static_cast<int >(wxDateTime::GMT_11)));
35896 }
35897 {
35898 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int(static_cast<int >(wxDateTime::GMT_10)));
35899 }
35900 {
35901 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int(static_cast<int >(wxDateTime::GMT_9)));
35902 }
35903 {
35904 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int(static_cast<int >(wxDateTime::GMT_8)));
35905 }
35906 {
35907 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int(static_cast<int >(wxDateTime::GMT_7)));
35908 }
35909 {
35910 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int(static_cast<int >(wxDateTime::GMT_6)));
35911 }
35912 {
35913 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int(static_cast<int >(wxDateTime::GMT_5)));
35914 }
35915 {
35916 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int(static_cast<int >(wxDateTime::GMT_4)));
35917 }
35918 {
35919 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int(static_cast<int >(wxDateTime::GMT_3)));
35920 }
35921 {
35922 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int(static_cast<int >(wxDateTime::GMT_2)));
35923 }
35924 {
35925 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int(static_cast<int >(wxDateTime::GMT_1)));
35926 }
35927 {
35928 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int(static_cast<int >(wxDateTime::GMT0)));
35929 }
35930 {
35931 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int(static_cast<int >(wxDateTime::GMT1)));
35932 }
35933 {
35934 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int(static_cast<int >(wxDateTime::GMT2)));
35935 }
35936 {
35937 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int(static_cast<int >(wxDateTime::GMT3)));
35938 }
35939 {
35940 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int(static_cast<int >(wxDateTime::GMT4)));
35941 }
35942 {
35943 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int(static_cast<int >(wxDateTime::GMT5)));
35944 }
35945 {
35946 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int(static_cast<int >(wxDateTime::GMT6)));
35947 }
35948 {
35949 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int(static_cast<int >(wxDateTime::GMT7)));
35950 }
35951 {
35952 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int(static_cast<int >(wxDateTime::GMT8)));
35953 }
35954 {
35955 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int(static_cast<int >(wxDateTime::GMT9)));
35956 }
35957 {
35958 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int(static_cast<int >(wxDateTime::GMT10)));
35959 }
35960 {
35961 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int(static_cast<int >(wxDateTime::GMT11)));
35962 }
35963 {
35964 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int(static_cast<int >(wxDateTime::GMT12)));
35965 }
35966 {
35967 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int(static_cast<int >(wxDateTime::WET)));
35968 }
35969 {
35970 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int(static_cast<int >(wxDateTime::WEST)));
35971 }
35972 {
35973 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int(static_cast<int >(wxDateTime::CET)));
35974 }
35975 {
35976 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int(static_cast<int >(wxDateTime::CEST)));
35977 }
35978 {
35979 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int(static_cast<int >(wxDateTime::EET)));
35980 }
35981 {
35982 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int(static_cast<int >(wxDateTime::EEST)));
35983 }
35984 {
35985 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int(static_cast<int >(wxDateTime::MSK)));
35986 }
35987 {
35988 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int(static_cast<int >(wxDateTime::MSD)));
35989 }
35990 {
35991 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int(static_cast<int >(wxDateTime::AST)));
35992 }
35993 {
35994 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int(static_cast<int >(wxDateTime::ADT)));
35995 }
35996 {
35997 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int(static_cast<int >(wxDateTime::EST)));
35998 }
35999 {
36000 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int(static_cast<int >(wxDateTime::EDT)));
36001 }
36002 {
36003 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int(static_cast<int >(wxDateTime::CST)));
36004 }
36005 {
36006 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int(static_cast<int >(wxDateTime::CDT)));
36007 }
36008 {
36009 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int(static_cast<int >(wxDateTime::MST)));
36010 }
36011 {
36012 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int(static_cast<int >(wxDateTime::MDT)));
36013 }
36014 {
36015 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int(static_cast<int >(wxDateTime::PST)));
36016 }
36017 {
36018 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int(static_cast<int >(wxDateTime::PDT)));
36019 }
36020 {
36021 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int(static_cast<int >(wxDateTime::HST)));
36022 }
36023 {
36024 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int(static_cast<int >(wxDateTime::AKST)));
36025 }
36026 {
36027 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int(static_cast<int >(wxDateTime::AKDT)));
36028 }
36029 {
36030 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int(static_cast<int >(wxDateTime::A_WST)));
36031 }
36032 {
36033 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int(static_cast<int >(wxDateTime::A_CST)));
36034 }
36035 {
36036 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int(static_cast<int >(wxDateTime::A_EST)));
36037 }
36038 {
36039 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int(static_cast<int >(wxDateTime::A_ESST)));
36040 }
36041 {
36042 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int(static_cast<int >(wxDateTime::UTC)));
36043 }
36044 {
36045 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int(static_cast<int >(wxDateTime::Gregorian)));
36046 }
36047 {
36048 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int(static_cast<int >(wxDateTime::Julian)));
36049 }
36050 {
36051 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Unknown)));
36052 }
36053 {
36054 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Standard)));
36055 }
36056 {
36057 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Alaska)));
36058 }
36059 {
36060 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Albania)));
36061 }
36062 {
36063 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria)));
36064 }
36065 {
36066 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Brixen)));
36067 }
36068 {
36069 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Salzburg)));
36070 }
36071 {
36072 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Tyrol)));
36073 }
36074 {
36075 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Carinthia)));
36076 }
36077 {
36078 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Styria)));
36079 }
36080 {
36081 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Belgium)));
36082 }
36083 {
36084 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Bulgaria)));
36085 }
36086 {
36087 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Bulgaria_1)));
36088 }
36089 {
36090 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Bulgaria_2)));
36091 }
36092 {
36093 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Bulgaria_3)));
36094 }
36095 {
36096 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Canada)));
36097 }
36098 {
36099 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int(static_cast<int >(wxDateTime::Gr_China)));
36100 }
36101 {
36102 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int(static_cast<int >(wxDateTime::Gr_China_1)));
36103 }
36104 {
36105 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int(static_cast<int >(wxDateTime::Gr_China_2)));
36106 }
36107 {
36108 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Czechoslovakia)));
36109 }
36110 {
36111 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Denmark)));
36112 }
36113 {
36114 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Egypt)));
36115 }
36116 {
36117 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Estonia)));
36118 }
36119 {
36120 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Finland)));
36121 }
36122 {
36123 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int(static_cast<int >(wxDateTime::Gr_France)));
36124 }
36125 {
36126 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int(static_cast<int >(wxDateTime::Gr_France_Alsace)));
36127 }
36128 {
36129 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int(static_cast<int >(wxDateTime::Gr_France_Lorraine)));
36130 }
36131 {
36132 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int(static_cast<int >(wxDateTime::Gr_France_Strasbourg)));
36133 }
36134 {
36135 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Germany)));
36136 }
36137 {
36138 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Germany_Catholic)));
36139 }
36140 {
36141 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Germany_Prussia)));
36142 }
36143 {
36144 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Germany_Protestant)));
36145 }
36146 {
36147 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int(static_cast<int >(wxDateTime::Gr_GreatBritain)));
36148 }
36149 {
36150 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Greece)));
36151 }
36152 {
36153 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Hungary)));
36154 }
36155 {
36156 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Ireland)));
36157 }
36158 {
36159 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Italy)));
36160 }
36161 {
36162 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Japan)));
36163 }
36164 {
36165 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Japan_1)));
36166 }
36167 {
36168 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Japan_2)));
36169 }
36170 {
36171 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Japan_3)));
36172 }
36173 {
36174 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Latvia)));
36175 }
36176 {
36177 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Lithuania)));
36178 }
36179 {
36180 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Luxemburg)));
36181 }
36182 {
36183 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands)));
36184 }
36185 {
36186 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands_Groningen)));
36187 }
36188 {
36189 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands_Gelderland)));
36190 }
36191 {
36192 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands_Utrecht)));
36193 }
36194 {
36195 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands_Friesland)));
36196 }
36197 {
36198 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Norway)));
36199 }
36200 {
36201 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Poland)));
36202 }
36203 {
36204 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Portugal)));
36205 }
36206 {
36207 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Romania)));
36208 }
36209 {
36210 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Russia)));
36211 }
36212 {
36213 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Scotland)));
36214 }
36215 {
36216 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Spain)));
36217 }
36218 {
36219 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Sweden)));
36220 }
36221 {
36222 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Switzerland)));
36223 }
36224 {
36225 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Switzerland_Catholic)));
36226 }
36227 {
36228 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Switzerland_Protestant)));
36229 }
36230 {
36231 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Turkey)));
36232 }
36233 {
36234 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int(static_cast<int >(wxDateTime::Gr_USA)));
36235 }
36236 {
36237 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Wales)));
36238 }
36239 {
36240 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Yugoslavia)));
36241 }
36242 {
36243 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int(static_cast<int >(wxDateTime::Country_Unknown)));
36244 }
36245 {
36246 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int(static_cast<int >(wxDateTime::Country_Default)));
36247 }
36248 {
36249 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int(static_cast<int >(wxDateTime::Country_WesternEurope_Start)));
36250 }
36251 {
36252 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int(static_cast<int >(wxDateTime::Country_EEC)));
36253 }
36254 {
36255 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int(static_cast<int >(wxDateTime::France)));
36256 }
36257 {
36258 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int(static_cast<int >(wxDateTime::Germany)));
36259 }
36260 {
36261 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int(static_cast<int >(wxDateTime::UK)));
36262 }
36263 {
36264 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int(static_cast<int >(wxDateTime::Country_WesternEurope_End)));
36265 }
36266 {
36267 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int(static_cast<int >(wxDateTime::Russia)));
36268 }
36269 {
36270 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int(static_cast<int >(wxDateTime::USA)));
36271 }
36272 {
36273 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int(static_cast<int >(wxDateTime::Jan)));
36274 }
36275 {
36276 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int(static_cast<int >(wxDateTime::Feb)));
36277 }
36278 {
36279 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int(static_cast<int >(wxDateTime::Mar)));
36280 }
36281 {
36282 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int(static_cast<int >(wxDateTime::Apr)));
36283 }
36284 {
36285 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int(static_cast<int >(wxDateTime::May)));
36286 }
36287 {
36288 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int(static_cast<int >(wxDateTime::Jun)));
36289 }
36290 {
36291 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int(static_cast<int >(wxDateTime::Jul)));
36292 }
36293 {
36294 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int(static_cast<int >(wxDateTime::Aug)));
36295 }
36296 {
36297 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int(static_cast<int >(wxDateTime::Sep)));
36298 }
36299 {
36300 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int(static_cast<int >(wxDateTime::Oct)));
36301 }
36302 {
36303 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int(static_cast<int >(wxDateTime::Nov)));
36304 }
36305 {
36306 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int(static_cast<int >(wxDateTime::Dec)));
36307 }
36308 {
36309 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int(static_cast<int >(wxDateTime::Inv_Month)));
36310 }
36311 {
36312 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int(static_cast<int >(wxDateTime::Sun)));
36313 }
36314 {
36315 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int(static_cast<int >(wxDateTime::Mon)));
36316 }
36317 {
36318 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int(static_cast<int >(wxDateTime::Tue)));
36319 }
36320 {
36321 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int(static_cast<int >(wxDateTime::Wed)));
36322 }
36323 {
36324 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int(static_cast<int >(wxDateTime::Thu)));
36325 }
36326 {
36327 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int(static_cast<int >(wxDateTime::Fri)));
36328 }
36329 {
36330 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int(static_cast<int >(wxDateTime::Sat)));
36331 }
36332 {
36333 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int(static_cast<int >(wxDateTime::Inv_WeekDay)));
36334 }
36335 {
36336 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int(static_cast<int >(wxDateTime::Inv_Year)));
36337 }
36338 {
36339 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int(static_cast<int >(wxDateTime::Name_Full)));
36340 }
36341 {
36342 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int(static_cast<int >(wxDateTime::Name_Abbr)));
36343 }
36344 {
36345 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int(static_cast<int >(wxDateTime::Default_First)));
36346 }
36347 {
36348 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int(static_cast<int >(wxDateTime::Monday_First)));
36349 }
36350 {
36351 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int(static_cast<int >(wxDateTime::Sunday_First)));
36352 }
36353 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
36354 {
36355 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int(static_cast<int >(wxDF_INVALID)));
36356 }
36357 {
36358 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int(static_cast<int >(wxDF_TEXT)));
36359 }
36360 {
36361 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int(static_cast<int >(wxDF_BITMAP)));
36362 }
36363 {
36364 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int(static_cast<int >(wxDF_METAFILE)));
36365 }
36366 {
36367 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int(static_cast<int >(wxDF_SYLK)));
36368 }
36369 {
36370 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int(static_cast<int >(wxDF_DIF)));
36371 }
36372 {
36373 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int(static_cast<int >(wxDF_TIFF)));
36374 }
36375 {
36376 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int(static_cast<int >(wxDF_OEMTEXT)));
36377 }
36378 {
36379 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int(static_cast<int >(wxDF_DIB)));
36380 }
36381 {
36382 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int(static_cast<int >(wxDF_PALETTE)));
36383 }
36384 {
36385 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int(static_cast<int >(wxDF_PENDATA)));
36386 }
36387 {
36388 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int(static_cast<int >(wxDF_RIFF)));
36389 }
36390 {
36391 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int(static_cast<int >(wxDF_WAVE)));
36392 }
36393 {
36394 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int(static_cast<int >(wxDF_UNICODETEXT)));
36395 }
36396 {
36397 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int(static_cast<int >(wxDF_ENHMETAFILE)));
36398 }
36399 {
36400 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int(static_cast<int >(wxDF_FILENAME)));
36401 }
36402 {
36403 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int(static_cast<int >(wxDF_LOCALE)));
36404 }
36405 {
36406 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int(static_cast<int >(wxDF_PRIVATE)));
36407 }
36408 {
36409 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int(static_cast<int >(wxDF_HTML)));
36410 }
36411 {
36412 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int(static_cast<int >(wxDF_MAX)));
36413 }
36414 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
36415 {
36416 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int(static_cast<int >(wxDataObject::Get)));
36417 }
36418 {
36419 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int(static_cast<int >(wxDataObject::Set)));
36420 }
36421 {
36422 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int(static_cast<int >(wxDataObject::Both)));
36423 }
36424 {
36425 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int(static_cast<int >(wxDrag_CopyOnly)));
36426 }
36427 {
36428 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int(static_cast<int >(wxDrag_AllowMove)));
36429 }
36430 {
36431 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int(static_cast<int >(wxDrag_DefaultMove)));
36432 }
36433 {
36434 PyDict_SetItemString(d,"DragError", SWIG_From_int(static_cast<int >(wxDragError)));
36435 }
36436 {
36437 PyDict_SetItemString(d,"DragNone", SWIG_From_int(static_cast<int >(wxDragNone)));
36438 }
36439 {
36440 PyDict_SetItemString(d,"DragCopy", SWIG_From_int(static_cast<int >(wxDragCopy)));
36441 }
36442 {
36443 PyDict_SetItemString(d,"DragMove", SWIG_From_int(static_cast<int >(wxDragMove)));
36444 }
36445 {
36446 PyDict_SetItemString(d,"DragLink", SWIG_From_int(static_cast<int >(wxDragLink)));
36447 }
36448 {
36449 PyDict_SetItemString(d,"DragCancel", SWIG_From_int(static_cast<int >(wxDragCancel)));
36450 }
36451
36452 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
36453 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
36454 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
36455 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
36456
36457 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
36458 }
36459
wxWidgets (Impactor)