]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
more about the downloadable swig
[wxWidgets.git] / wxPython / src / gtk / _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
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29 /***********************************************************************
30 *
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 *
34 ************************************************************************/
35
36 /* template workaround for compilers that cannot correctly implement the C++ standard */
37 #ifndef SWIGTEMPLATEDISAMBIGUATOR
38 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 #endif
44
45 /* inline attribute */
46 #ifndef SWIGINLINE
47 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
48 # define SWIGINLINE inline
49 # else
50 # define SWIGINLINE
51 # endif
52 #endif
53
54 /* attribute recognised by some compilers to avoid 'unused' warnings */
55 #ifndef SWIGUNUSED
56 # if defined(__GNUC__) || defined(__ICC)
57 # define SWIGUNUSED __attribute__ ((unused))
58 # else
59 # define SWIGUNUSED
60 # endif
61 #endif
62
63 /* internal SWIG method */
64 #ifndef SWIGINTERN
65 # define SWIGINTERN static SWIGUNUSED
66 #endif
67
68 /* internal inline SWIG method */
69 #ifndef SWIGINTERNINLINE
70 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
71 #endif
72
73 /* exporting methods for Windows DLLs */
74 #ifndef SWIGEXPORT
75 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
76 # if defined(STATIC_LINKED)
77 # define SWIGEXPORT
78 # else
79 # define SWIGEXPORT __declspec(dllexport)
80 # endif
81 # else
82 # define SWIGEXPORT
83 # endif
84 #endif
85
86 /* calling conventions for Windows */
87 #ifndef SWIGSTDCALL
88 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
89 # define SWIGSTDCALL __stdcall
90 # else
91 # define SWIGSTDCALL
92 # endif
93 #endif
94
95
96
97 #include <Python.h>
98
99 /***********************************************************************
100 * swigrun.swg
101 *
102 * This file contains generic CAPI SWIG runtime support for pointer
103 * type checking.
104 *
105 ************************************************************************/
106
107 /* This should only be incremented when either the layout of swig_type_info changes,
108 or for whatever reason, the runtime changes incompatibly */
109 #define SWIG_RUNTIME_VERSION "2"
110
111 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
112 #ifdef SWIG_TYPE_TABLE
113 # define SWIG_QUOTE_STRING(x) #x
114 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
115 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
116 #else
117 # define SWIG_TYPE_TABLE_NAME
118 #endif
119
120 /*
121 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
122 creating a static or dynamic library from the swig runtime code.
123 In 99.9% of the cases, swig just needs to declare them as 'static'.
124
125 But only do this if is strictly necessary, ie, if you have problems
126 with your compiler or so.
127 */
128
129 #ifndef SWIGRUNTIME
130 # define SWIGRUNTIME SWIGINTERN
131 #endif
132
133 #ifndef SWIGRUNTIMEINLINE
134 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
135 #endif
136
137 #include <string.h>
138
139 #ifdef __cplusplus
140 extern "C" {
141 #endif
142
143 typedef void *(*swig_converter_func)(void *);
144 typedef struct swig_type_info *(*swig_dycast_func)(void **);
145
146 /* Structure to store inforomation on one type */
147 typedef struct swig_type_info {
148 const char *name; /* mangled name of this type */
149 const char *str; /* human readable name of this type */
150 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
151 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
152 void *clientdata; /* language specific type data */
153 } swig_type_info;
154
155 /* Structure to store a type and conversion function used for casting */
156 typedef struct swig_cast_info {
157 swig_type_info *type; /* pointer to type that is equivalent to this type */
158 swig_converter_func converter; /* function to cast the void pointers */
159 struct swig_cast_info *next; /* pointer to next cast in linked list */
160 struct swig_cast_info *prev; /* pointer to the previous cast */
161 } swig_cast_info;
162
163 /* Structure used to store module information
164 * Each module generates one structure like this, and the runtime collects
165 * all of these structures and stores them in a circularly linked list.*/
166 typedef struct swig_module_info {
167 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
168 size_t size; /* Number of types in this module */
169 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
170 swig_type_info **type_initial; /* Array of initially generated type structures */
171 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
172 void *clientdata; /* Language specific module data */
173 } swig_module_info;
174
175
176 /*
177 Compare two type names skipping the space characters, therefore
178 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
179
180 Return 0 when the two name types are equivalent, as in
181 strncmp, but skipping ' '.
182 */
183 SWIGRUNTIME int
184 SWIG_TypeNameComp(const char *f1, const char *l1,
185 const char *f2, const char *l2) {
186 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
187 while ((*f1 == ' ') && (f1 != l1)) ++f1;
188 while ((*f2 == ' ') && (f2 != l2)) ++f2;
189 if (*f1 != *f2) return (int)(*f1 - *f2);
190 }
191 return (l1 - f1) - (l2 - f2);
192 }
193
194 /*
195 Check type equivalence in a name list like <name1>|<name2>|...
196 Return 0 if not equal, 1 if equal
197 */
198 SWIGRUNTIME int
199 SWIG_TypeEquiv(const char *nb, const char *tb) {
200 int equiv = 0;
201 const char* te = tb + strlen(tb);
202 const char* ne = nb;
203 while (!equiv && *ne) {
204 for (nb = ne; *ne; ++ne) {
205 if (*ne == '|') break;
206 }
207 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
208 if (*ne) ++ne;
209 }
210 return equiv;
211 }
212
213 /*
214 Check type equivalence in a name list like <name1>|<name2>|...
215 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
216 */
217 SWIGRUNTIME int
218 SWIG_TypeCompare(const char *nb, const char *tb) {
219 int equiv = 0;
220 const char* te = tb + strlen(tb);
221 const char* ne = nb;
222 while (!equiv && *ne) {
223 for (nb = ne; *ne; ++ne) {
224 if (*ne == '|') break;
225 }
226 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
227 if (*ne) ++ne;
228 }
229 return equiv;
230 }
231
232
233 /* think of this as a c++ template<> or a scheme macro */
234 #define SWIG_TypeCheck_Template(comparison, ty) \
235 if (ty) { \
236 swig_cast_info *iter = ty->cast; \
237 while (iter) { \
238 if (comparison) { \
239 if (iter == ty->cast) return iter; \
240 /* Move iter to the top of the linked list */ \
241 iter->prev->next = iter->next; \
242 if (iter->next) \
243 iter->next->prev = iter->prev; \
244 iter->next = ty->cast; \
245 iter->prev = 0; \
246 if (ty->cast) ty->cast->prev = iter; \
247 ty->cast = iter; \
248 return iter; \
249 } \
250 iter = iter->next; \
251 } \
252 } \
253 return 0
254
255 /*
256 Check the typename
257 */
258 SWIGRUNTIME swig_cast_info *
259 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
260 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
261 }
262
263 /* Same as previous function, except strcmp is replaced with a pointer comparison */
264 SWIGRUNTIME swig_cast_info *
265 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
266 SWIG_TypeCheck_Template(iter->type == from, into);
267 }
268
269 /*
270 Cast a pointer up an inheritance hierarchy
271 */
272 SWIGRUNTIMEINLINE void *
273 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
274 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
275 }
276
277 /*
278 Dynamic pointer casting. Down an inheritance hierarchy
279 */
280 SWIGRUNTIME swig_type_info *
281 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
282 swig_type_info *lastty = ty;
283 if (!ty || !ty->dcast) return ty;
284 while (ty && (ty->dcast)) {
285 ty = (*ty->dcast)(ptr);
286 if (ty) lastty = ty;
287 }
288 return lastty;
289 }
290
291 /*
292 Return the name associated with this type
293 */
294 SWIGRUNTIMEINLINE const char *
295 SWIG_TypeName(const swig_type_info *ty) {
296 return ty->name;
297 }
298
299 /*
300 Return the pretty name associated with this type,
301 that is an unmangled type name in a form presentable to the user.
302 */
303 SWIGRUNTIME const char *
304 SWIG_TypePrettyName(const swig_type_info *type) {
305 /* The "str" field contains the equivalent pretty names of the
306 type, separated by vertical-bar characters. We choose
307 to print the last name, as it is often (?) the most
308 specific. */
309 if (type->str != NULL) {
310 const char *last_name = type->str;
311 const char *s;
312 for (s = type->str; *s; s++)
313 if (*s == '|') last_name = s+1;
314 return last_name;
315 }
316 else
317 return type->name;
318 }
319
320 /*
321 Set the clientdata field for a type
322 */
323 SWIGRUNTIME void
324 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
325 swig_cast_info *cast = ti->cast;
326 /* if (ti->clientdata == clientdata) return; */
327 ti->clientdata = clientdata;
328
329 while (cast) {
330 if (!cast->converter) {
331 swig_type_info *tc = cast->type;
332 if (!tc->clientdata) {
333 SWIG_TypeClientData(tc, clientdata);
334 }
335 }
336 cast = cast->next;
337 }
338 }
339
340 /*
341 Search for a swig_type_info structure only by mangled name
342 Search is a O(log #types)
343
344 We start searching at module start, and finish searching when start == end.
345 Note: if start == end at the beginning of the function, we go all the way around
346 the circular list.
347 */
348 SWIGRUNTIME swig_type_info *
349 SWIG_MangledTypeQueryModule(swig_module_info *start,
350 swig_module_info *end,
351 const char *name) {
352 swig_module_info *iter = start;
353 do {
354 if (iter->size) {
355 register size_t l = 0;
356 register size_t r = iter->size - 1;
357 do {
358 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
359 register size_t i = (l + r) >> 1;
360 const char *iname = iter->types[i]->name;
361 if (iname) {
362 register int compare = strcmp(name, iname);
363 if (compare == 0) {
364 return iter->types[i];
365 } else if (compare < 0) {
366 if (i) {
367 r = i - 1;
368 } else {
369 break;
370 }
371 } else if (compare > 0) {
372 l = i + 1;
373 }
374 } else {
375 break; /* should never happen */
376 }
377 } while (l <= r);
378 }
379 iter = iter->next;
380 } while (iter != end);
381 return 0;
382 }
383
384 /*
385 Search for a swig_type_info structure for either a mangled name or a human readable name.
386 It first searches the mangled names of the types, which is a O(log #types)
387 If a type is not found it then searches the human readable names, which is O(#types).
388
389 We start searching at module start, and finish searching when start == end.
390 Note: if start == end at the beginning of the function, we go all the way around
391 the circular list.
392 */
393 SWIGRUNTIME swig_type_info *
394 SWIG_TypeQueryModule(swig_module_info *start,
395 swig_module_info *end,
396 const char *name) {
397 /* STEP 1: Search the name field using binary search */
398 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
399 if (ret) {
400 return ret;
401 } else {
402 /* STEP 2: If the type hasn't been found, do a complete search
403 of the str field (the human readable name) */
404 swig_module_info *iter = start;
405 do {
406 register size_t i = 0;
407 for (; i < iter->size; ++i) {
408 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
409 return iter->types[i];
410 }
411 iter = iter->next;
412 } while (iter != end);
413 }
414
415 /* neither found a match */
416 return 0;
417 }
418
419
420 /*
421 Pack binary data into a string
422 */
423 SWIGRUNTIME char *
424 SWIG_PackData(char *c, void *ptr, size_t sz) {
425 static const char hex[17] = "0123456789abcdef";
426 register const unsigned char *u = (unsigned char *) ptr;
427 register const unsigned char *eu = u + sz;
428 for (; u != eu; ++u) {
429 register unsigned char uu = *u;
430 *(c++) = hex[(uu & 0xf0) >> 4];
431 *(c++) = hex[uu & 0xf];
432 }
433 return c;
434 }
435
436 /*
437 Unpack binary data from a string
438 */
439 SWIGRUNTIME const char *
440 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
441 register unsigned char *u = (unsigned char *) ptr;
442 register const unsigned char *eu = u + sz;
443 for (; u != eu; ++u) {
444 register char d = *(c++);
445 register unsigned char uu = 0;
446 if ((d >= '0') && (d <= '9'))
447 uu = ((d - '0') << 4);
448 else if ((d >= 'a') && (d <= 'f'))
449 uu = ((d - ('a'-10)) << 4);
450 else
451 return (char *) 0;
452 d = *(c++);
453 if ((d >= '0') && (d <= '9'))
454 uu |= (d - '0');
455 else if ((d >= 'a') && (d <= 'f'))
456 uu |= (d - ('a'-10));
457 else
458 return (char *) 0;
459 *u = uu;
460 }
461 return c;
462 }
463
464 /*
465 Pack 'void *' into a string buffer.
466 */
467 SWIGRUNTIME char *
468 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
469 char *r = buff;
470 if ((2*sizeof(void *) + 2) > bsz) return 0;
471 *(r++) = '_';
472 r = SWIG_PackData(r,&ptr,sizeof(void *));
473 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
474 strcpy(r,name);
475 return buff;
476 }
477
478 SWIGRUNTIME const char *
479 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
480 if (*c != '_') {
481 if (strcmp(c,"NULL") == 0) {
482 *ptr = (void *) 0;
483 return name;
484 } else {
485 return 0;
486 }
487 }
488 return SWIG_UnpackData(++c,ptr,sizeof(void *));
489 }
490
491 SWIGRUNTIME char *
492 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
493 char *r = buff;
494 size_t lname = (name ? strlen(name) : 0);
495 if ((2*sz + 2 + lname) > bsz) return 0;
496 *(r++) = '_';
497 r = SWIG_PackData(r,ptr,sz);
498 if (lname) {
499 strncpy(r,name,lname+1);
500 } else {
501 *r = 0;
502 }
503 return buff;
504 }
505
506 SWIGRUNTIME const char *
507 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
508 if (*c != '_') {
509 if (strcmp(c,"NULL") == 0) {
510 memset(ptr,0,sz);
511 return name;
512 } else {
513 return 0;
514 }
515 }
516 return SWIG_UnpackData(++c,ptr,sz);
517 }
518
519 #ifdef __cplusplus
520 }
521 #endif
522
523 /* -----------------------------------------------------------------------------
524 * SWIG API. Portion that goes into the runtime
525 * ----------------------------------------------------------------------------- */
526
527 #ifdef __cplusplus
528 extern "C" {
529 #endif
530
531 /* -----------------------------------------------------------------------------
532 * for internal method declarations
533 * ----------------------------------------------------------------------------- */
534
535 #ifndef SWIGINTERN
536 # define SWIGINTERN static SWIGUNUSED
537 #endif
538
539 #ifndef SWIGINTERNINLINE
540 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
541 #endif
542
543 /*
544 Exception handling in wrappers
545 */
546 #define SWIG_fail goto fail
547 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
548 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
549 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
550 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
551 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
552
553 /*
554 Contract support
555 */
556 #define SWIG_contract_assert(expr, msg) \
557 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
558
559 /* -----------------------------------------------------------------------------
560 * Constant declarations
561 * ----------------------------------------------------------------------------- */
562
563 /* Constant Types */
564 #define SWIG_PY_INT 1
565 #define SWIG_PY_FLOAT 2
566 #define SWIG_PY_STRING 3
567 #define SWIG_PY_POINTER 4
568 #define SWIG_PY_BINARY 5
569
570 /* Constant information structure */
571 typedef struct swig_const_info {
572 int type;
573 char *name;
574 long lvalue;
575 double dvalue;
576 void *pvalue;
577 swig_type_info **ptype;
578 } swig_const_info;
579
580
581 /* -----------------------------------------------------------------------------
582 * Alloc. memory flags
583 * ----------------------------------------------------------------------------- */
584 #define SWIG_OLDOBJ 1
585 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
586 #define SWIG_PYSTR SWIG_NEWOBJ + 1
587
588 #ifdef __cplusplus
589 }
590 #endif
591
592
593 /***********************************************************************
594 * pyrun.swg
595 *
596 * This file contains the runtime support for Python modules
597 * and includes code for managing global variables and pointer
598 * type checking.
599 *
600 * Author : David Beazley (beazley@cs.uchicago.edu)
601 ************************************************************************/
602
603 /* Common SWIG API */
604 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
605 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
606 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
607
608
609 /* Python-specific SWIG API */
610 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
611 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
612
613 /* Runtime API */
614 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
615 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
616
617 /* -----------------------------------------------------------------------------
618 * Pointer declarations
619 * ----------------------------------------------------------------------------- */
620 /*
621 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
622 C/C++ pointers in the python side. Very useful for debugging, but
623 not always safe.
624 */
625 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
626 # define SWIG_COBJECT_TYPES
627 #endif
628
629 /* Flags for pointer conversion */
630 #define SWIG_POINTER_EXCEPTION 0x1
631 #define SWIG_POINTER_DISOWN 0x2
632
633
634 /* Add PyOS_snprintf for old Pythons */
635 #if PY_VERSION_HEX < 0x02020000
636 #define PyOS_snprintf snprintf
637 #endif
638
639 #ifdef __cplusplus
640 extern "C" {
641 #endif
642
643 /* -----------------------------------------------------------------------------
644 * Create a new pointer string
645 * ----------------------------------------------------------------------------- */
646 #ifndef SWIG_BUFFER_SIZE
647 #define SWIG_BUFFER_SIZE 1024
648 #endif
649
650 /* A crude PyString_FromFormat implementation for old Pythons */
651 #if PY_VERSION_HEX < 0x02020000
652 static PyObject *
653 PyString_FromFormat(const char *fmt, ...) {
654 va_list ap;
655 char buf[SWIG_BUFFER_SIZE * 2];
656 int res;
657 va_start(ap, fmt);
658 res = vsnprintf(buf, sizeof(buf), fmt, ap);
659 va_end(ap);
660 return (res < 0 || res >= sizeof(buf)) ? 0 : PyString_FromString(buf);
661 }
662 #endif
663
664 #if PY_VERSION_HEX < 0x01060000
665 #define PyObject_Del(op) PyMem_DEL((op))
666 #endif
667
668 #if defined(SWIG_COBJECT_TYPES)
669 #if !defined(SWIG_COBJECT_PYTHON)
670 /* -----------------------------------------------------------------------------
671 * Implements a simple Swig Object type, and use it instead of PyCObject
672 * ----------------------------------------------------------------------------- */
673
674 typedef struct {
675 PyObject_HEAD
676 void *ptr;
677 const char *desc;
678 } PySwigObject;
679
680 /* Declarations for objects of type PySwigObject */
681
682 SWIGRUNTIME int
683 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
684 {
685 char result[SWIG_BUFFER_SIZE];
686 flags = flags;
687 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
688 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
689 return 0;
690 } else {
691 return 1;
692 }
693 }
694
695 SWIGRUNTIME PyObject *
696 PySwigObject_repr(PySwigObject *v)
697 {
698 char result[SWIG_BUFFER_SIZE];
699 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
700 PyString_FromFormat("<Swig Object at %s>", result) : 0;
701 }
702
703 SWIGRUNTIME PyObject *
704 PySwigObject_str(PySwigObject *v)
705 {
706 char result[SWIG_BUFFER_SIZE];
707 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
708 PyString_FromString(result) : 0;
709 }
710
711 SWIGRUNTIME PyObject *
712 PySwigObject_long(PySwigObject *v)
713 {
714 return PyLong_FromVoidPtr(v->ptr);
715 }
716
717 SWIGRUNTIME PyObject *
718 PySwigObject_format(const char* fmt, PySwigObject *v)
719 {
720 PyObject *res = NULL;
721 PyObject *args = PyTuple_New(1);
722 if (args && (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0)) {
723 PyObject *ofmt = PyString_FromString(fmt);
724 if (ofmt) {
725 res = PyString_Format(ofmt,args);
726 Py_DECREF(ofmt);
727 }
728 Py_DECREF(args);
729 }
730 return res;
731 }
732
733 SWIGRUNTIME PyObject *
734 PySwigObject_oct(PySwigObject *v)
735 {
736 return PySwigObject_format("%o",v);
737 }
738
739 SWIGRUNTIME PyObject *
740 PySwigObject_hex(PySwigObject *v)
741 {
742 return PySwigObject_format("%x",v);
743 }
744
745 SWIGRUNTIME int
746 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
747 {
748 int c = strcmp(v->desc, w->desc);
749 if (c) {
750 return (c > 0) ? 1 : -1;
751 } else {
752 void *i = v->ptr;
753 void *j = w->ptr;
754 return (i < j) ? -1 : ((i > j) ? 1 : 0);
755 }
756 }
757
758 SWIGRUNTIME void
759 PySwigObject_dealloc(PySwigObject *self)
760 {
761 PyObject_Del(self);
762 }
763
764 SWIGRUNTIME PyTypeObject*
765 PySwigObject_type(void) {
766 static char pyswigobject_type__doc__[] =
767 "Swig object carries a C/C++ instance pointer";
768
769 static PyNumberMethods PySwigObject_as_number = {
770 (binaryfunc)0, /*nb_add*/
771 (binaryfunc)0, /*nb_subtract*/
772 (binaryfunc)0, /*nb_multiply*/
773 (binaryfunc)0, /*nb_divide*/
774 (binaryfunc)0, /*nb_remainder*/
775 (binaryfunc)0, /*nb_divmod*/
776 (ternaryfunc)0,/*nb_power*/
777 (unaryfunc)0, /*nb_negative*/
778 (unaryfunc)0, /*nb_positive*/
779 (unaryfunc)0, /*nb_absolute*/
780 (inquiry)0, /*nb_nonzero*/
781 0, /*nb_invert*/
782 0, /*nb_lshift*/
783 0, /*nb_rshift*/
784 0, /*nb_and*/
785 0, /*nb_xor*/
786 0, /*nb_or*/
787 (coercion)0, /*nb_coerce*/
788 (unaryfunc)PySwigObject_long, /*nb_int*/
789 (unaryfunc)PySwigObject_long, /*nb_long*/
790 (unaryfunc)0, /*nb_float*/
791 (unaryfunc)PySwigObject_oct, /*nb_oct*/
792 (unaryfunc)PySwigObject_hex, /*nb_hex*/
793 #if PY_VERSION_HEX >= 0x02020000
794 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
795 #elif PY_VERSION_HEX >= 0x02000000
796 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
797 #endif
798 };
799
800 static PyTypeObject pyswigobject_type
801 #if !defined(__cplusplus)
802 ;
803 static int type_init = 0;
804 if (!type_init) {
805 PyTypeObject tmp
806 #endif
807 = {
808 PyObject_HEAD_INIT(&PyType_Type)
809 0, /*ob_size*/
810 (char *)"PySwigObject", /*tp_name*/
811 sizeof(PySwigObject), /*tp_basicsize*/
812 0, /*tp_itemsize*/
813 /* methods */
814 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
815 (printfunc)PySwigObject_print, /*tp_print*/
816 (getattrfunc)0, /*tp_getattr*/
817 (setattrfunc)0, /*tp_setattr*/
818 (cmpfunc)PySwigObject_compare, /*tp_compare*/
819 (reprfunc)PySwigObject_repr, /*tp_repr*/
820 &PySwigObject_as_number, /*tp_as_number*/
821 0, /*tp_as_sequence*/
822 0, /*tp_as_mapping*/
823 (hashfunc)0, /*tp_hash*/
824 (ternaryfunc)0, /*tp_call*/
825 (reprfunc)PySwigObject_str, /*tp_str*/
826 /* Space for future expansion */
827 0,0,0,0,
828 pyswigobject_type__doc__, /* Documentation string */
829 #if PY_VERSION_HEX >= 0x02000000
830 0, /* tp_traverse */
831 0, /* tp_clear */
832 #endif
833 #if PY_VERSION_HEX >= 0x02010000
834 0, /* tp_richcompare */
835 0, /* tp_weaklistoffset */
836 #endif
837 #if PY_VERSION_HEX >= 0x02020000
838 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
839 #endif
840 #if PY_VERSION_HEX >= 0x02030000
841 0, /* tp_del */
842 #endif
843 #ifdef COUNT_ALLOCS
844 0,0,0,0 /* tp_alloc -> tp_next */
845 #endif
846 };
847 #if !defined(__cplusplus)
848 pyswigobject_type = tmp;
849 type_init = 1;
850 }
851 #endif
852 return &pyswigobject_type;
853 }
854
855 SWIGRUNTIME PyObject *
856 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
857 {
858 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_type());
859 if (self) {
860 self->ptr = ptr;
861 self->desc = desc;
862 }
863 return (PyObject *)self;
864 }
865
866 SWIGRUNTIMEINLINE void *
867 PySwigObject_AsVoidPtr(PyObject *self)
868 {
869 return ((PySwigObject *)self)->ptr;
870 }
871
872 SWIGRUNTIMEINLINE const char *
873 PySwigObject_GetDesc(PyObject *self)
874 {
875 return ((PySwigObject *)self)->desc;
876 }
877
878 SWIGRUNTIMEINLINE int
879 PySwigObject_Check(PyObject *op) {
880 return ((op)->ob_type == PySwigObject_type())
881 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
882 }
883
884 /* -----------------------------------------------------------------------------
885 * Implements a simple Swig Packed type, and use it instead of string
886 * ----------------------------------------------------------------------------- */
887
888 typedef struct {
889 PyObject_HEAD
890 void *pack;
891 const char *desc;
892 size_t size;
893 } PySwigPacked;
894
895 SWIGRUNTIME int
896 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
897 {
898 char result[SWIG_BUFFER_SIZE];
899 flags = flags;
900 fputs("<Swig Packed ", fp);
901 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
902 fputs("at ", fp);
903 fputs(result, fp);
904 }
905 fputs(v->desc,fp);
906 fputs(">", fp);
907 return 0;
908 }
909
910 SWIGRUNTIME PyObject *
911 PySwigPacked_repr(PySwigPacked *v)
912 {
913 char result[SWIG_BUFFER_SIZE];
914 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
915 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
916 } else {
917 return PyString_FromFormat("<Swig Packed %s>", v->desc);
918 }
919 }
920
921 SWIGRUNTIME PyObject *
922 PySwigPacked_str(PySwigPacked *v)
923 {
924 char result[SWIG_BUFFER_SIZE];
925 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
926 return PyString_FromFormat("%s%s", result, v->desc);
927 } else {
928 return PyString_FromString(v->desc);
929 }
930 }
931
932 SWIGRUNTIME int
933 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
934 {
935 int c = strcmp(v->desc, w->desc);
936 if (c) {
937 return (c > 0) ? 1 : -1;
938 } else {
939 size_t i = v->size;
940 size_t j = w->size;
941 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
942 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
943 }
944 }
945
946 SWIGRUNTIME void
947 PySwigPacked_dealloc(PySwigPacked *self)
948 {
949 free(self->pack);
950 PyObject_Del(self);
951 }
952
953 SWIGRUNTIME PyTypeObject*
954 PySwigPacked_type(void) {
955 static char pyswigpacked_type__doc__[] =
956 "Swig object carries a C/C++ instance pointer";
957 static PyTypeObject pyswigpacked_type
958 #if !defined(__cplusplus)
959 ;
960 static int type_init = 0;
961 if (!type_init) {
962 PyTypeObject tmp
963 #endif
964 = {
965 PyObject_HEAD_INIT(&PyType_Type)
966 0, /*ob_size*/
967 (char *)"PySwigPacked", /*tp_name*/
968 sizeof(PySwigPacked), /*tp_basicsize*/
969 0, /*tp_itemsize*/
970 /* methods */
971 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
972 (printfunc)PySwigPacked_print, /*tp_print*/
973 (getattrfunc)0, /*tp_getattr*/
974 (setattrfunc)0, /*tp_setattr*/
975 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
976 (reprfunc)PySwigPacked_repr, /*tp_repr*/
977 0, /*tp_as_number*/
978 0, /*tp_as_sequence*/
979 0, /*tp_as_mapping*/
980 (hashfunc)0, /*tp_hash*/
981 (ternaryfunc)0, /*tp_call*/
982 (reprfunc)PySwigPacked_str, /*tp_str*/
983 /* Space for future expansion */
984 0,0,0,0,
985 pyswigpacked_type__doc__, /* Documentation string */
986 #if PY_VERSION_HEX >= 0x02000000
987 0, /* tp_traverse */
988 0, /* tp_clear */
989 #endif
990 #if PY_VERSION_HEX >= 0x02010000
991 0, /* tp_richcompare */
992 0, /* tp_weaklistoffset */
993 #endif
994 #if PY_VERSION_HEX >= 0x02020000
995 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
996 #endif
997 #if PY_VERSION_HEX >= 0x02030000
998 0, /* tp_del */
999 #endif
1000 #ifdef COUNT_ALLOCS
1001 0,0,0,0 /* tp_alloc -> tp_next */
1002 #endif
1003 };
1004 #if !defined(__cplusplus)
1005 pyswigpacked_type = tmp;
1006 type_init = 1;
1007 }
1008 #endif
1009 return &pyswigpacked_type;
1010 }
1011
1012 SWIGRUNTIME PyObject *
1013 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
1014 {
1015 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1016 if (self == NULL) {
1017 return NULL;
1018 } else {
1019 void *pack = malloc(size);
1020 if (pack) {
1021 memcpy(pack, ptr, size);
1022 self->pack = pack;
1023 self->desc = desc;
1024 self->size = size;
1025 return (PyObject *) self;
1026 }
1027 return NULL;
1028 }
1029 }
1030
1031 SWIGRUNTIMEINLINE const char *
1032 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1033 {
1034 PySwigPacked *self = (PySwigPacked *)obj;
1035 if (self->size != size) return 0;
1036 memcpy(ptr, self->pack, size);
1037 return self->desc;
1038 }
1039
1040 SWIGRUNTIMEINLINE const char *
1041 PySwigPacked_GetDesc(PyObject *self)
1042 {
1043 return ((PySwigPacked *)self)->desc;
1044 }
1045
1046 SWIGRUNTIMEINLINE int
1047 PySwigPacked_Check(PyObject *op) {
1048 return ((op)->ob_type == PySwigPacked_type())
1049 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1050 }
1051
1052 #else
1053 /* -----------------------------------------------------------------------------
1054 * Use the old Python PyCObject instead of PySwigObject
1055 * ----------------------------------------------------------------------------- */
1056
1057 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1058 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1059 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1060 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1061
1062 #endif
1063
1064 #endif
1065
1066 /* -----------------------------------------------------------------------------
1067 * errors manipulation
1068 * ----------------------------------------------------------------------------- */
1069
1070 SWIGRUNTIME void
1071 SWIG_Python_TypeError(const char *type, PyObject *obj)
1072 {
1073 if (type) {
1074 #if defined(SWIG_COBJECT_TYPES)
1075 if (obj && PySwigObject_Check(obj)) {
1076 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1077 if (otype) {
1078 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1079 type, otype);
1080 return;
1081 }
1082 } else
1083 #endif
1084 {
1085 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1086 if (otype) {
1087 PyObject *str = PyObject_Str(obj);
1088 const char *cstr = str ? PyString_AsString(str) : 0;
1089 if (cstr) {
1090 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1091 type, otype, cstr);
1092 } else {
1093 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1094 type, otype);
1095 }
1096 Py_XDECREF(str);
1097 return;
1098 }
1099 }
1100 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1101 } else {
1102 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1103 }
1104 }
1105
1106 SWIGRUNTIMEINLINE void
1107 SWIG_Python_NullRef(const char *type)
1108 {
1109 if (type) {
1110 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1111 } else {
1112 PyErr_Format(PyExc_TypeError, "null reference was received");
1113 }
1114 }
1115
1116 SWIGRUNTIME int
1117 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1118 {
1119 if (PyErr_Occurred()) {
1120 PyObject *type = 0;
1121 PyObject *value = 0;
1122 PyObject *traceback = 0;
1123 PyErr_Fetch(&type, &value, &traceback);
1124 if (value) {
1125 PyObject *old_str = PyObject_Str(value);
1126 Py_XINCREF(type);
1127 PyErr_Clear();
1128 if (infront) {
1129 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1130 } else {
1131 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1132 }
1133 Py_DECREF(old_str);
1134 }
1135 return 1;
1136 } else {
1137 return 0;
1138 }
1139 }
1140
1141 SWIGRUNTIME int
1142 SWIG_Python_ArgFail(int argnum)
1143 {
1144 if (PyErr_Occurred()) {
1145 /* add information about failing argument */
1146 char mesg[256];
1147 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
1148 return SWIG_Python_AddErrMesg(mesg, 1);
1149 } else {
1150 return 0;
1151 }
1152 }
1153
1154
1155 /* -----------------------------------------------------------------------------
1156 * pointers/data manipulation
1157 * ----------------------------------------------------------------------------- */
1158
1159 /* Convert a pointer value */
1160 SWIGRUNTIME int
1161 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1162 swig_cast_info *tc;
1163 const char *c = 0;
1164 static PyObject *SWIG_this = 0;
1165 int newref = 0;
1166 PyObject *pyobj = 0;
1167 void *vptr;
1168
1169 if (!obj) return 0;
1170 if (obj == Py_None) {
1171 *ptr = 0;
1172 return 0;
1173 }
1174
1175 #ifdef SWIG_COBJECT_TYPES
1176 if (!(PySwigObject_Check(obj))) {
1177 if (!SWIG_this)
1178 SWIG_this = PyString_FromString("this");
1179 pyobj = obj;
1180 obj = PyObject_GetAttr(obj,SWIG_this);
1181 newref = 1;
1182 if (!obj) goto type_error;
1183 if (!PySwigObject_Check(obj)) {
1184 Py_DECREF(obj);
1185 goto type_error;
1186 }
1187 }
1188 vptr = PySwigObject_AsVoidPtr(obj);
1189 c = (const char *) PySwigObject_GetDesc(obj);
1190 if (newref) { Py_DECREF(obj); }
1191 goto type_check;
1192 #else
1193 if (!(PyString_Check(obj))) {
1194 if (!SWIG_this)
1195 SWIG_this = PyString_FromString("this");
1196 pyobj = obj;
1197 obj = PyObject_GetAttr(obj,SWIG_this);
1198 newref = 1;
1199 if (!obj) goto type_error;
1200 if (!PyString_Check(obj)) {
1201 Py_DECREF(obj);
1202 goto type_error;
1203 }
1204 }
1205 c = PyString_AsString(obj);
1206 /* Pointer values must start with leading underscore */
1207 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1208 if (newref) { Py_DECREF(obj); }
1209 if (!c) goto type_error;
1210 #endif
1211
1212 type_check:
1213 if (ty) {
1214 tc = SWIG_TypeCheck(c,ty);
1215 if (!tc) goto type_error;
1216 *ptr = SWIG_TypeCast(tc,vptr);
1217 } else {
1218 *ptr = vptr;
1219 }
1220 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1221 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1222 }
1223 return 0;
1224
1225 type_error:
1226 PyErr_Clear();
1227 if (pyobj && !obj) {
1228 obj = pyobj;
1229 if (PyCFunction_Check(obj)) {
1230 /* here we get the method pointer for callbacks */
1231 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1232 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1233 if (c) {
1234 c = ty ? SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name) : 0;
1235 if (!c) goto type_error;
1236 goto type_check;
1237 }
1238 }
1239 }
1240 if (flags & SWIG_POINTER_EXCEPTION) {
1241 if (ty) {
1242 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1243 } else {
1244 SWIG_Python_TypeError("C/C++ pointer", obj);
1245 }
1246 }
1247 return -1;
1248 }
1249
1250 /* Convert a pointer value, signal an exception on a type mismatch */
1251 SWIGRUNTIME void *
1252 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1253 void *result;
1254 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1255 PyErr_Clear();
1256 if (flags & SWIG_POINTER_EXCEPTION) {
1257 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1258 SWIG_Python_ArgFail(argnum);
1259 }
1260 }
1261 return result;
1262 }
1263
1264 /* Convert a packed value value */
1265 SWIGRUNTIME int
1266 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1267 swig_cast_info *tc;
1268 const char *c = 0;
1269
1270 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1271 c = PySwigPacked_UnpackData(obj, ptr, sz);
1272 #else
1273 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1274 c = PyString_AsString(obj);
1275 /* Pointer values must start with leading underscore */
1276 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1277 #endif
1278 if (!c) goto type_error;
1279 if (ty) {
1280 tc = SWIG_TypeCheck(c,ty);
1281 if (!tc) goto type_error;
1282 }
1283 return 0;
1284
1285 type_error:
1286 PyErr_Clear();
1287 if (flags & SWIG_POINTER_EXCEPTION) {
1288 if (ty) {
1289 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1290 } else {
1291 SWIG_Python_TypeError("C/C++ packed data", obj);
1292 }
1293 }
1294 return -1;
1295 }
1296
1297 /* Create a new array object */
1298 SWIGRUNTIME PyObject *
1299 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1300 PyObject *robj = 0;
1301 if (!type) {
1302 if (!PyErr_Occurred()) {
1303 PyErr_Format(PyExc_TypeError, "Swig: null type passed to NewPointerObj");
1304 }
1305 return robj;
1306 }
1307 if (!ptr) {
1308 Py_INCREF(Py_None);
1309 return Py_None;
1310 }
1311 #ifdef SWIG_COBJECT_TYPES
1312 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1313 #else
1314 {
1315 char result[SWIG_BUFFER_SIZE];
1316 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1317 PyString_FromString(result) : 0;
1318 }
1319 #endif
1320 if (!robj || (robj == Py_None)) return robj;
1321 if (type->clientdata) {
1322 PyObject *inst;
1323 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1324 Py_DECREF(robj);
1325 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1326 Py_DECREF(args);
1327 if (inst) {
1328 if (own) {
1329 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1330 }
1331 robj = inst;
1332 }
1333 }
1334 return robj;
1335 }
1336
1337 SWIGRUNTIME PyObject *
1338 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1339 PyObject *robj = 0;
1340 if (!ptr) {
1341 Py_INCREF(Py_None);
1342 return Py_None;
1343 }
1344 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1345 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1346 #else
1347 {
1348 char result[SWIG_BUFFER_SIZE];
1349 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1350 PyString_FromString(result) : 0;
1351 }
1352 #endif
1353 return robj;
1354 }
1355
1356 /* -----------------------------------------------------------------------------*
1357 * Get type list
1358 * -----------------------------------------------------------------------------*/
1359
1360 #ifdef SWIG_LINK_RUNTIME
1361 void *SWIG_ReturnGlobalTypeList(void *);
1362 #endif
1363
1364 SWIGRUNTIME swig_module_info *
1365 SWIG_Python_GetModule(void) {
1366 static void *type_pointer = (void *)0;
1367 /* first check if module already created */
1368 if (!type_pointer) {
1369 #ifdef SWIG_LINK_RUNTIME
1370 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1371 #else
1372 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1373 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1374 if (PyErr_Occurred()) {
1375 PyErr_Clear();
1376 type_pointer = (void *)0;
1377 }
1378 #endif
1379 }
1380 return (swig_module_info *) type_pointer;
1381 }
1382
1383 #if PY_MAJOR_VERSION < 2
1384 /* PyModule_AddObject function was introduced in Python 2.0. The following function
1385 is copied out of Python/modsupport.c in python version 2.3.4 */
1386 SWIGINTERN int
1387 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
1388 {
1389 PyObject *dict;
1390 if (!PyModule_Check(m)) {
1391 PyErr_SetString(PyExc_TypeError,
1392 "PyModule_AddObject() needs module as first arg");
1393 return -1;
1394 }
1395 if (!o) {
1396 PyErr_SetString(PyExc_TypeError,
1397 "PyModule_AddObject() needs non-NULL value");
1398 return -1;
1399 }
1400
1401 dict = PyModule_GetDict(m);
1402 if (dict == NULL) {
1403 /* Internal error -- modules must have a dict! */
1404 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
1405 PyModule_GetName(m));
1406 return -1;
1407 }
1408 if (PyDict_SetItemString(dict, name, o))
1409 return -1;
1410 Py_DECREF(o);
1411 return 0;
1412 }
1413 #endif
1414
1415 SWIGRUNTIME void
1416 SWIG_Python_SetModule(swig_module_info *swig_module) {
1417 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
1418
1419 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1420 swig_empty_runtime_method_table);
1421 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, NULL);
1422 if (pointer && module) {
1423 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
1424 }
1425 }
1426
1427 #ifdef __cplusplus
1428 }
1429 #endif
1430
1431
1432 /* -------- TYPES TABLE (BEGIN) -------- */
1433
1434 #define SWIGTYPE_p_char swig_types[0]
1435 #define SWIGTYPE_p_form_ops_t swig_types[1]
1436 #define SWIGTYPE_p_int swig_types[2]
1437 #define SWIGTYPE_p_unsigned_char swig_types[3]
1438 #define SWIGTYPE_p_unsigned_int swig_types[4]
1439 #define SWIGTYPE_p_unsigned_long swig_types[5]
1440 #define SWIGTYPE_p_void swig_types[6]
1441 #define SWIGTYPE_p_wxANIHandler swig_types[7]
1442 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
1443 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
1444 #define SWIGTYPE_p_wxArrayString swig_types[10]
1445 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
1446 #define SWIGTYPE_p_wxBitmap swig_types[12]
1447 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
1448 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
1449 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
1450 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
1451 #define SWIGTYPE_p_wxCURHandler swig_types[17]
1452 #define SWIGTYPE_p_wxCaret swig_types[18]
1453 #define SWIGTYPE_p_wxChar swig_types[19]
1454 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
1455 #define SWIGTYPE_p_wxClipboard swig_types[21]
1456 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
1457 #define SWIGTYPE_p_wxCloseEvent swig_types[23]
1458 #define SWIGTYPE_p_wxColour swig_types[24]
1459 #define SWIGTYPE_p_wxCommandEvent swig_types[25]
1460 #define SWIGTYPE_p_wxConfig swig_types[26]
1461 #define SWIGTYPE_p_wxConfigBase swig_types[27]
1462 #define SWIGTYPE_p_wxConfigPathChanger swig_types[28]
1463 #define SWIGTYPE_p_wxContextMenuEvent swig_types[29]
1464 #define SWIGTYPE_p_wxControl swig_types[30]
1465 #define SWIGTYPE_p_wxControlWithItems swig_types[31]
1466 #define SWIGTYPE_p_wxCursor swig_types[32]
1467 #define SWIGTYPE_p_wxCustomDataObject swig_types[33]
1468 #define SWIGTYPE_p_wxDC swig_types[34]
1469 #define SWIGTYPE_p_wxDataFormat swig_types[35]
1470 #define SWIGTYPE_p_wxDataObject swig_types[36]
1471 #define SWIGTYPE_p_wxDataObjectComposite swig_types[37]
1472 #define SWIGTYPE_p_wxDataObjectSimple swig_types[38]
1473 #define SWIGTYPE_p_wxDateEvent swig_types[39]
1474 #define SWIGTYPE_p_wxDateSpan swig_types[40]
1475 #define SWIGTYPE_p_wxDateTime swig_types[41]
1476 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[42]
1477 #define SWIGTYPE_p_wxDisplay swig_types[43]
1478 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[44]
1479 #define SWIGTYPE_p_wxDropFilesEvent swig_types[45]
1480 #define SWIGTYPE_p_wxDuplexMode swig_types[46]
1481 #define SWIGTYPE_p_wxEraseEvent swig_types[47]
1482 #define SWIGTYPE_p_wxEvent swig_types[48]
1483 #define SWIGTYPE_p_wxEvtHandler swig_types[49]
1484 #define SWIGTYPE_p_wxFSFile swig_types[50]
1485 #define SWIGTYPE_p_wxFileConfig swig_types[51]
1486 #define SWIGTYPE_p_wxFileDataObject swig_types[52]
1487 #define SWIGTYPE_p_wxFileHistory swig_types[53]
1488 #define SWIGTYPE_p_wxFileSystem swig_types[54]
1489 #define SWIGTYPE_p_wxFileType swig_types[55]
1490 #define SWIGTYPE_p_wxFileTypeInfo swig_types[56]
1491 #define SWIGTYPE_p_wxFlexGridSizer swig_types[57]
1492 #define SWIGTYPE_p_wxFocusEvent swig_types[58]
1493 #define SWIGTYPE_p_wxFont swig_types[59]
1494 #define SWIGTYPE_p_wxFrame swig_types[60]
1495 #define SWIGTYPE_p_wxGBSizerItem swig_types[61]
1496 #define SWIGTYPE_p_wxGIFHandler swig_types[62]
1497 #define SWIGTYPE_p_wxGridBagSizer swig_types[63]
1498 #define SWIGTYPE_p_wxGridSizer swig_types[64]
1499 #define SWIGTYPE_p_wxICOHandler swig_types[65]
1500 #define SWIGTYPE_p_wxIcon swig_types[66]
1501 #define SWIGTYPE_p_wxIconizeEvent swig_types[67]
1502 #define SWIGTYPE_p_wxIdleEvent swig_types[68]
1503 #define SWIGTYPE_p_wxImage swig_types[69]
1504 #define SWIGTYPE_p_wxImageHandler swig_types[70]
1505 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[71]
1506 #define SWIGTYPE_p_wxInitDialogEvent swig_types[72]
1507 #define SWIGTYPE_p_wxJPEGHandler swig_types[73]
1508 #define SWIGTYPE_p_wxJoystick swig_types[74]
1509 #define SWIGTYPE_p_wxJoystickEvent swig_types[75]
1510 #define SWIGTYPE_p_wxKeyEvent swig_types[76]
1511 #define SWIGTYPE_p_wxKillError swig_types[77]
1512 #define SWIGTYPE_p_wxLayoutConstraints swig_types[78]
1513 #define SWIGTYPE_p_wxLog swig_types[79]
1514 #define SWIGTYPE_p_wxLogBuffer swig_types[80]
1515 #define SWIGTYPE_p_wxLogChain swig_types[81]
1516 #define SWIGTYPE_p_wxLogGui swig_types[82]
1517 #define SWIGTYPE_p_wxLogNull swig_types[83]
1518 #define SWIGTYPE_p_wxLogStderr swig_types[84]
1519 #define SWIGTYPE_p_wxLogTextCtrl swig_types[85]
1520 #define SWIGTYPE_p_wxLogWindow swig_types[86]
1521 #define SWIGTYPE_p_wxMaximizeEvent swig_types[87]
1522 #define SWIGTYPE_p_wxMemorySize swig_types[88]
1523 #define SWIGTYPE_p_wxMenu swig_types[89]
1524 #define SWIGTYPE_p_wxMenuBar swig_types[90]
1525 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
1526 #define SWIGTYPE_p_wxMenuItem swig_types[92]
1527 #define SWIGTYPE_p_wxMetafileDataObject swig_types[93]
1528 #define SWIGTYPE_p_wxMimeTypesManager swig_types[94]
1529 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[95]
1530 #define SWIGTYPE_p_wxMouseEvent swig_types[96]
1531 #define SWIGTYPE_p_wxMouseState swig_types[97]
1532 #define SWIGTYPE_p_wxMoveEvent swig_types[98]
1533 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[99]
1534 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
1535 #define SWIGTYPE_p_wxNcPaintEvent swig_types[101]
1536 #define SWIGTYPE_p_wxNotifyEvent swig_types[102]
1537 #define SWIGTYPE_p_wxObject swig_types[103]
1538 #define SWIGTYPE_p_wxOutputStream swig_types[104]
1539 #define SWIGTYPE_p_wxPCXHandler swig_types[105]
1540 #define SWIGTYPE_p_wxPNGHandler swig_types[106]
1541 #define SWIGTYPE_p_wxPNMHandler swig_types[107]
1542 #define SWIGTYPE_p_wxPaintEvent swig_types[108]
1543 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[109]
1544 #define SWIGTYPE_p_wxPaperSize swig_types[110]
1545 #define SWIGTYPE_p_wxPoint swig_types[111]
1546 #define SWIGTYPE_p_wxProcessEvent swig_types[112]
1547 #define SWIGTYPE_p_wxPyApp swig_types[113]
1548 #define SWIGTYPE_p_wxPyArtProvider swig_types[114]
1549 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[115]
1550 #define SWIGTYPE_p_wxPyCommandEvent swig_types[116]
1551 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[117]
1552 #define SWIGTYPE_p_wxPyDropSource swig_types[118]
1553 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
1554 #define SWIGTYPE_p_wxPyEvent swig_types[120]
1555 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[121]
1556 #define SWIGTYPE_p_wxPyImageHandler swig_types[122]
1557 #define SWIGTYPE_p_wxPyLog swig_types[123]
1558 #define SWIGTYPE_p_wxPyProcess swig_types[124]
1559 #define SWIGTYPE_p_wxPySizer swig_types[125]
1560 #define SWIGTYPE_p_wxPyTextDataObject swig_types[126]
1561 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[127]
1562 #define SWIGTYPE_p_wxPyTimer swig_types[128]
1563 #define SWIGTYPE_p_wxPyTipProvider swig_types[129]
1564 #define SWIGTYPE_p_wxPyValidator swig_types[130]
1565 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[131]
1566 #define SWIGTYPE_p_wxRect swig_types[132]
1567 #define SWIGTYPE_p_wxScrollEvent swig_types[133]
1568 #define SWIGTYPE_p_wxScrollWinEvent swig_types[134]
1569 #define SWIGTYPE_p_wxSetCursorEvent swig_types[135]
1570 #define SWIGTYPE_p_wxShowEvent swig_types[136]
1571 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[137]
1572 #define SWIGTYPE_p_wxSize swig_types[138]
1573 #define SWIGTYPE_p_wxSizeEvent swig_types[139]
1574 #define SWIGTYPE_p_wxSizer swig_types[140]
1575 #define SWIGTYPE_p_wxSizerItem swig_types[141]
1576 #define SWIGTYPE_p_wxSound swig_types[142]
1577 #define SWIGTYPE_p_wxStandardPaths swig_types[143]
1578 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[144]
1579 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[145]
1580 #define SWIGTYPE_p_wxStopWatch swig_types[146]
1581 #define SWIGTYPE_p_wxString swig_types[147]
1582 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[148]
1583 #define SWIGTYPE_p_wxSystemOptions swig_types[149]
1584 #define SWIGTYPE_p_wxSystemSettings swig_types[150]
1585 #define SWIGTYPE_p_wxTIFFHandler swig_types[151]
1586 #define SWIGTYPE_p_wxTextCtrl swig_types[152]
1587 #define SWIGTYPE_p_wxTextDataObject swig_types[153]
1588 #define SWIGTYPE_p_wxTimeSpan swig_types[154]
1589 #define SWIGTYPE_p_wxTimer swig_types[155]
1590 #define SWIGTYPE_p_wxTimerEvent swig_types[156]
1591 #define SWIGTYPE_p_wxTimerRunner swig_types[157]
1592 #define SWIGTYPE_p_wxTipProvider swig_types[158]
1593 #define SWIGTYPE_p_wxToolTip swig_types[159]
1594 #define SWIGTYPE_p_wxURLDataObject swig_types[160]
1595 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[161]
1596 #define SWIGTYPE_p_wxValidator swig_types[162]
1597 #define SWIGTYPE_p_wxVideoMode swig_types[163]
1598 #define SWIGTYPE_p_wxWindow swig_types[164]
1599 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[165]
1600 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[166]
1601 #define SWIGTYPE_p_wxWindowDisabler swig_types[167]
1602 #define SWIGTYPE_p_wxXPMHandler swig_types[168]
1603 #define SWIGTYPE_ptrdiff_t swig_types[169]
1604 #define SWIGTYPE_std__ptrdiff_t swig_types[170]
1605 #define SWIGTYPE_unsigned_int swig_types[171]
1606 static swig_type_info *swig_types[173];
1607 static swig_module_info swig_module = {swig_types, 172, 0, 0, 0, 0};
1608 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1609 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1610
1611 /* -------- TYPES TABLE (END) -------- */
1612
1613
1614 /*-----------------------------------------------
1615 @(target):= _misc_.so
1616 ------------------------------------------------*/
1617 #define SWIG_init init_misc_
1618
1619 #define SWIG_name "_misc_"
1620
1621 #include "wx/wxPython/wxPython.h"
1622 #include "wx/wxPython/pyclasses.h"
1623 #include "wx/wxPython/pyistream.h"
1624
1625 static const wxString wxPyEmptyString(wxEmptyString);
1626
1627
1628
1629 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
1630 #define SWIG_From_int PyInt_FromLong
1631 /*@@*/
1632
1633
1634 #include <limits.h>
1635
1636
1637 SWIGINTERN int
1638 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1639 const char *errmsg)
1640 {
1641 if (value < min_value) {
1642 if (errmsg) {
1643 PyErr_Format(PyExc_OverflowError,
1644 "value %ld is less than '%s' minimum %ld",
1645 value, errmsg, min_value);
1646 }
1647 return 0;
1648 } else if (value > max_value) {
1649 if (errmsg) {
1650 PyErr_Format(PyExc_OverflowError,
1651 "value %ld is greater than '%s' maximum %ld",
1652 value, errmsg, max_value);
1653 }
1654 return 0;
1655 }
1656 return 1;
1657 }
1658
1659
1660 SWIGINTERN int
1661 SWIG_AsVal_long(PyObject* obj, long* val)
1662 {
1663 if (PyNumber_Check(obj)) {
1664 if (val) *val = PyInt_AsLong(obj);
1665 return 1;
1666 }
1667 else {
1668 SWIG_type_error("number", obj);
1669 }
1670 return 0;
1671 }
1672
1673
1674 #if INT_MAX != LONG_MAX
1675 SWIGINTERN int
1676 SWIG_AsVal_int(PyObject *obj, int *val)
1677 {
1678 const char* errmsg = val ? "int" : (char*)0;
1679 long v;
1680 if (SWIG_AsVal_long(obj, &v)) {
1681 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1682 if (val) *val = static_cast<int >(v);
1683 return 1;
1684 } else {
1685 return 0;
1686 }
1687 } else {
1688 PyErr_Clear();
1689 }
1690 if (val) {
1691 SWIG_type_error(errmsg, obj);
1692 }
1693 return 0;
1694 }
1695 #else
1696 SWIGINTERNINLINE int
1697 SWIG_AsVal_int(PyObject *obj, int *val)
1698 {
1699 return SWIG_AsVal_long(obj,(long*)val);
1700 }
1701 #endif
1702
1703
1704 SWIGINTERNINLINE int
1705 SWIG_As_int(PyObject* obj)
1706 {
1707 int v;
1708 if (!SWIG_AsVal_int(obj, &v)) {
1709 /*
1710 this is needed to make valgrind/purify happier.
1711 */
1712 memset((void*)&v, 0, sizeof(int));
1713 }
1714 return v;
1715 }
1716
1717
1718 SWIGINTERNINLINE int
1719 SWIG_Check_int(PyObject* obj)
1720 {
1721 return SWIG_AsVal_int(obj, (int*)0);
1722 }
1723
1724 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1725
1726 #include <wx/stockitem.h>
1727
1728 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1729 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1730 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1731
1732 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
1733 #define SWIG_From_long PyInt_FromLong
1734 /*@@*/
1735
1736
1737 SWIGINTERNINLINE long
1738 SWIG_As_long(PyObject* obj)
1739 {
1740 long v;
1741 if (!SWIG_AsVal_long(obj, &v)) {
1742 /*
1743 this is needed to make valgrind/purify happier.
1744 */
1745 memset((void*)&v, 0, sizeof(long));
1746 }
1747 return v;
1748 }
1749
1750
1751 SWIGINTERNINLINE int
1752 SWIG_Check_long(PyObject* obj)
1753 {
1754 return SWIG_AsVal_long(obj, (long*)0);
1755 }
1756
1757
1758 SWIGINTERN int
1759 SWIG_AsVal_bool(PyObject *obj, bool *val)
1760 {
1761 if (obj == Py_True) {
1762 if (val) *val = true;
1763 return 1;
1764 }
1765 if (obj == Py_False) {
1766 if (val) *val = false;
1767 return 1;
1768 }
1769 int res = 0;
1770 if (SWIG_AsVal_int(obj, &res)) {
1771 if (val) *val = res ? true : false;
1772 return 1;
1773 } else {
1774 PyErr_Clear();
1775 }
1776 if (val) {
1777 SWIG_type_error("bool", obj);
1778 }
1779 return 0;
1780 }
1781
1782
1783 SWIGINTERNINLINE bool
1784 SWIG_As_bool(PyObject* obj)
1785 {
1786 bool v;
1787 if (!SWIG_AsVal_bool(obj, &v)) {
1788 /*
1789 this is needed to make valgrind/purify happier.
1790 */
1791 memset((void*)&v, 0, sizeof(bool));
1792 }
1793 return v;
1794 }
1795
1796
1797 SWIGINTERNINLINE int
1798 SWIG_Check_bool(PyObject* obj)
1799 {
1800 return SWIG_AsVal_bool(obj, (bool*)0);
1801 }
1802
1803
1804 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1805 PyObject* o2;
1806 PyObject* o3;
1807
1808 if (!target) {
1809 target = o;
1810 } else if (target == Py_None) {
1811 Py_DECREF(Py_None);
1812 target = o;
1813 } else {
1814 if (!PyTuple_Check(target)) {
1815 o2 = target;
1816 target = PyTuple_New(1);
1817 PyTuple_SetItem(target, 0, o2);
1818 }
1819 o3 = PyTuple_New(1);
1820 PyTuple_SetItem(o3, 0, o);
1821
1822 o2 = target;
1823 target = PySequence_Concat(o2, o3);
1824 Py_DECREF(o2);
1825 Py_DECREF(o3);
1826 }
1827 return target;
1828 }
1829
1830
1831
1832 wxMemorySize wxGetFreeMemory()
1833 { wxPyRaiseNotImplemented(); return 0; }
1834
1835
1836 SWIGINTERN int
1837 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1838 {
1839 long v = 0;
1840 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1841 SWIG_type_error("unsigned number", obj);
1842 }
1843 else if (val)
1844 *val = (unsigned long)v;
1845 return 1;
1846 }
1847
1848
1849 SWIGINTERNINLINE unsigned long
1850 SWIG_As_unsigned_SS_long(PyObject* obj)
1851 {
1852 unsigned long v;
1853 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1854 /*
1855 this is needed to make valgrind/purify happier.
1856 */
1857 memset((void*)&v, 0, sizeof(unsigned long));
1858 }
1859 return v;
1860 }
1861
1862
1863 SWIGINTERNINLINE int
1864 SWIG_Check_unsigned_SS_long(PyObject* obj)
1865 {
1866 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1867 }
1868
1869
1870 SWIGINTERNINLINE PyObject*
1871 SWIG_From_unsigned_SS_long(unsigned long value)
1872 {
1873 return (value > LONG_MAX) ?
1874 PyLong_FromUnsignedLong(value)
1875 : PyInt_FromLong(static_cast<long >(value));
1876 }
1877
1878
1879 void* wxGetXDisplay()
1880 {
1881 #ifdef __WXGTK__
1882 return wxGetDisplay();
1883 #else
1884 return NULL;
1885 #endif
1886 }
1887
1888
1889 wxWindow* FindWindowAtPointer() {
1890 wxPoint unused;
1891 return wxFindWindowAtPointer(unused);
1892 }
1893
1894
1895 void wxWakeUpMainThread() {}
1896
1897
1898 bool wxThread_IsMain() {
1899 #ifdef WXP_WITH_THREAD
1900 return wxThread::IsMain();
1901 #else
1902 return true;
1903 #endif
1904 }
1905
1906 static void wxCaret_Destroy(wxCaret *self){
1907 delete self;
1908 }
1909
1910 #include <wx/snglinst.h>
1911
1912
1913 #ifdef __WXMSW__
1914 #include <wx/msw/private.h>
1915 #include <wx/dynload.h>
1916 #endif
1917
1918
1919
1920 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1921 #if 0
1922 , int method
1923 #endif
1924 )
1925 {
1926 #ifdef __WXMSW__
1927 #if 0
1928 switch (method)
1929 {
1930 case 1:
1931 // This one only partially works. Appears to be an undocumented
1932 // "standard" convention that not all widgets adhear to. For
1933 // example, for some widgets backgrounds or non-client areas may
1934 // not be painted.
1935 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1936 break;
1937
1938 case 2:
1939 #endif
1940 // This one works much better, nearly all widgets and their
1941 // children are captured correctly[**]. Prior to the big
1942 // background erase changes that Vadim did in 2004-2005 this
1943 // method failed badly on XP with Themes activated, most native
1944 // widgets draw only partially, if at all. Without themes it
1945 // worked just like on Win2k. After those changes this method
1946 // works very well.
1947 //
1948 // ** For example the radio buttons in a wxRadioBox are not its
1949 // children by default, but you can capture it via the panel
1950 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1951 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1952 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1953 PRF_ERASEBKGND | PRF_OWNED );
1954 return true;
1955 #if 0
1956 break;
1957
1958 case 3:
1959 // This one is only defined in the latest SDK and is only
1960 // available on XP. MSDN says it is similar to sending WM_PRINT
1961 // so I expect that it will work similar to the above. Since it
1962 // is avaialble only on XP, it can't be compiled like this and
1963 // will have to be loaded dynamically.
1964 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1965
1966 // fall through
1967
1968 case 4:
1969 // Use PrintWindow if available, or fallback to WM_PRINT
1970 // otherwise. Unfortunately using PrintWindow is even worse than
1971 // WM_PRINT. For most native widgets nothing is drawn to the dc
1972 // at all, with or without Themes.
1973 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1974 static bool s_triedToLoad = false;
1975 static PrintWindow_t pfnPrintWindow = NULL;
1976 if ( !s_triedToLoad )
1977 {
1978
1979 s_triedToLoad = true;
1980 wxDynamicLibrary dllUser32(_T("user32.dll"));
1981 if ( dllUser32.IsLoaded() )
1982 {
1983 wxLogNull nolog; // Don't report errors here
1984 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1985 }
1986 }
1987 if (pfnPrintWindow)
1988 {
1989 //printf("Using PrintWindow\n");
1990 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1991 }
1992 else
1993 {
1994 //printf("Using WM_PRINT\n");
1995 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1996 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1997 PRF_ERASEBKGND | PRF_OWNED );
1998 }
1999 }
2000 #endif // 0
2001 #else
2002 return false;
2003 #endif // __WXMSW__
2004 }
2005
2006
2007
2008 #include <wx/tipdlg.h>
2009
2010
2011 class wxPyTipProvider : public wxTipProvider {
2012 public:
2013 wxPyTipProvider(size_t currentTip)
2014 : wxTipProvider(currentTip) {}
2015
2016 DEC_PYCALLBACK_STRING__pure(GetTip);
2017 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2018 PYPRIVATE;
2019 };
2020
2021 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2022 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2023
2024
2025 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
2026
2027 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
2028
2029 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
2030 : wxTimer(owner, id)
2031 {
2032 if (owner == NULL) SetOwner(this);
2033 }
2034
2035
2036 void wxPyTimer::Notify() {
2037 bool found;
2038 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2039 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
2040 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
2041 wxPyEndBlockThreads(blocked);
2042 if (! found)
2043 wxTimer::Notify();
2044 }
2045 void wxPyTimer::base_Notify() {
2046 wxTimer::Notify();
2047 }
2048
2049
2050
2051 SWIGINTERN PyObject *
2052 SWIG_FromCharPtr(const char* cptr)
2053 {
2054 if (cptr) {
2055 size_t size = strlen(cptr);
2056 if (size > INT_MAX) {
2057 return SWIG_NewPointerObj(const_cast<char* >(cptr),
2058 SWIG_TypeQuery("char *"), 0);
2059 } else {
2060 if (size != 0) {
2061 return PyString_FromStringAndSize(cptr, size);
2062 } else {
2063 return PyString_FromString(cptr);
2064 }
2065 }
2066 }
2067 Py_INCREF(Py_None);
2068 return Py_None;
2069 }
2070
2071
2072 SWIGINTERNINLINE int
2073 SWIG_CheckUnsignedLongInRange(unsigned long value,
2074 unsigned long max_value,
2075 const char *errmsg)
2076 {
2077 if (value > max_value) {
2078 if (errmsg) {
2079 PyErr_Format(PyExc_OverflowError,
2080 "value %lu is greater than '%s' minimum %lu",
2081 value, errmsg, max_value);
2082 }
2083 return 0;
2084 }
2085 return 1;
2086 }
2087
2088
2089 #if UINT_MAX != ULONG_MAX
2090 SWIGINTERN int
2091 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2092 {
2093 const char* errmsg = val ? "unsigned int" : (char*)0;
2094 unsigned long v;
2095 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2096 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2097 if (val) *val = static_cast<unsigned int >(v);
2098 return 1;
2099 }
2100 } else {
2101 PyErr_Clear();
2102 }
2103 if (val) {
2104 SWIG_type_error(errmsg, obj);
2105 }
2106 return 0;
2107 }
2108 #else
2109 SWIGINTERNINLINE unsigned int
2110 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2111 {
2112 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2113 }
2114 #endif
2115
2116
2117 SWIGINTERNINLINE unsigned int
2118 SWIG_As_unsigned_SS_int(PyObject* obj)
2119 {
2120 unsigned int v;
2121 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2122 /*
2123 this is needed to make valgrind/purify happier.
2124 */
2125 memset((void*)&v, 0, sizeof(unsigned int));
2126 }
2127 return v;
2128 }
2129
2130
2131 SWIGINTERNINLINE int
2132 SWIG_Check_unsigned_SS_int(PyObject* obj)
2133 {
2134 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2135 }
2136
2137 static wxString wxLog_TimeStamp(){
2138 wxString msg;
2139 wxLog::TimeStamp(&msg);
2140 return msg;
2141 }
2142 static void wxLog_Destroy(wxLog *self){ delete self; }
2143 // Make somce wrappers that double any % signs so they are 'escaped'
2144 void wxPyLogFatalError(const wxString& msg)
2145 {
2146 wxString m(msg);
2147 m.Replace(wxT("%"), wxT("%%"));
2148 wxLogFatalError(m);
2149 }
2150
2151 void wxPyLogError(const wxString& msg)
2152 {
2153 wxString m(msg);
2154 m.Replace(wxT("%"), wxT("%%"));
2155 wxLogError(m);
2156 }
2157
2158 void wxPyLogWarning(const wxString& msg)
2159 {
2160 wxString m(msg);
2161 m.Replace(wxT("%"), wxT("%%"));
2162 wxLogWarning(m);
2163 }
2164
2165 void wxPyLogMessage(const wxString& msg)
2166 {
2167 wxString m(msg);
2168 m.Replace(wxT("%"), wxT("%%"));
2169 wxLogMessage(m);
2170 }
2171
2172 void wxPyLogInfo(const wxString& msg)
2173 {
2174 wxString m(msg);
2175 m.Replace(wxT("%"), wxT("%%"));
2176 wxLogInfo(m);
2177 }
2178
2179 void wxPyLogDebug(const wxString& msg)
2180 {
2181 wxString m(msg);
2182 m.Replace(wxT("%"), wxT("%%"));
2183 wxLogDebug(m);
2184 }
2185
2186 void wxPyLogVerbose(const wxString& msg)
2187 {
2188 wxString m(msg);
2189 m.Replace(wxT("%"), wxT("%%"));
2190 wxLogVerbose(m);
2191 }
2192
2193 void wxPyLogStatus(const wxString& msg)
2194 {
2195 wxString m(msg);
2196 m.Replace(wxT("%"), wxT("%%"));
2197 wxLogStatus(m);
2198 }
2199
2200 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2201 {
2202 wxString m(msg);
2203 m.Replace(wxT("%"), wxT("%%"));
2204 wxLogStatus(pFrame, m);
2205 }
2206
2207 void wxPyLogSysError(const wxString& msg)
2208 {
2209 wxString m(msg);
2210 m.Replace(wxT("%"), wxT("%%"));
2211 wxLogSysError(m);
2212 }
2213
2214 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2215 {
2216 wxString m(msg);
2217 m.Replace(wxT("%"), wxT("%%"));
2218 wxLogGeneric(level, m);
2219 }
2220
2221 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2222 {
2223 wxString m(msg);
2224 m.Replace(wxT("%"), wxT("%%"));
2225 wxLogTrace(mask, m);
2226 }
2227
2228 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2229 {
2230 wxString m(msg);
2231 m.Replace(wxT("%"), wxT("%%"));
2232 wxLogTrace(mask, m);
2233 }
2234
2235
2236
2237 // A wxLog class that can be derived from in wxPython
2238 class wxPyLog : public wxLog {
2239 public:
2240 wxPyLog() : wxLog() {}
2241
2242 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2243 bool found;
2244 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2245 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2246 PyObject* s = wx2PyString(szString);
2247 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2248 Py_DECREF(s);
2249 }
2250 wxPyEndBlockThreads(blocked);
2251 if (! found)
2252 wxLog::DoLog(level, szString, t);
2253 }
2254
2255 virtual void DoLogString(const wxChar *szString, time_t t) {
2256 bool found;
2257 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2258 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2259 PyObject* s = wx2PyString(szString);
2260 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2261 Py_DECREF(s);
2262 }
2263 wxPyEndBlockThreads(blocked);
2264 if (! found)
2265 wxLog::DoLogString(szString, t);
2266 }
2267
2268 PYPRIVATE;
2269 };
2270
2271
2272
2273
2274 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2275
2276
2277 #include <wx/joystick.h>
2278
2279
2280 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2281 // A C++ stub class for wxJoystick for platforms that don't have it.
2282 class wxJoystick : public wxObject {
2283 public:
2284 wxJoystick(int joystick = wxJOYSTICK1) {
2285 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2286 PyErr_SetString(PyExc_NotImplementedError,
2287 "wxJoystick is not available on this platform.");
2288 wxPyEndBlockThreads(blocked);
2289 }
2290 wxPoint GetPosition() { return wxPoint(-1,-1); }
2291 int GetZPosition() { return -1; }
2292 int GetButtonState() { return -1; }
2293 int GetPOVPosition() { return -1; }
2294 int GetPOVCTSPosition() { return -1; }
2295 int GetRudderPosition() { return -1; }
2296 int GetUPosition() { return -1; }
2297 int GetVPosition() { return -1; }
2298 int GetMovementThreshold() { return -1; }
2299 void SetMovementThreshold(int threshold) {}
2300
2301 bool IsOk(void) { return false; }
2302 int GetNumberJoysticks() { return -1; }
2303 int GetManufacturerId() { return -1; }
2304 int GetProductId() { return -1; }
2305 wxString GetProductName() { return wxEmptyString; }
2306 int GetXMin() { return -1; }
2307 int GetYMin() { return -1; }
2308 int GetZMin() { return -1; }
2309 int GetXMax() { return -1; }
2310 int GetYMax() { return -1; }
2311 int GetZMax() { return -1; }
2312 int GetNumberButtons() { return -1; }
2313 int GetNumberAxes() { return -1; }
2314 int GetMaxButtons() { return -1; }
2315 int GetMaxAxes() { return -1; }
2316 int GetPollingMin() { return -1; }
2317 int GetPollingMax() { return -1; }
2318 int GetRudderMin() { return -1; }
2319 int GetRudderMax() { return -1; }
2320 int GetUMin() { return -1; }
2321 int GetUMax() { return -1; }
2322 int GetVMin() { return -1; }
2323 int GetVMax() { return -1; }
2324
2325 bool HasRudder() { return false; }
2326 bool HasZ() { return false; }
2327 bool HasU() { return false; }
2328 bool HasV() { return false; }
2329 bool HasPOV() { return false; }
2330 bool HasPOV4Dir() { return false; }
2331 bool HasPOVCTS() { return false; }
2332
2333 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2334 bool ReleaseCapture() { return false; }
2335 };
2336 #endif
2337
2338
2339 #include <wx/sound.h>
2340
2341
2342 #if !wxUSE_SOUND
2343 // A C++ stub class for wxWave for platforms that don't have it.
2344 class wxSound : public wxObject
2345 {
2346 public:
2347 wxSound() {
2348 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2349 PyErr_SetString(PyExc_NotImplementedError,
2350 "wxSound is not available on this platform.");
2351 wxPyEndBlockThreads(blocked);
2352 }
2353 wxSound(const wxString&/*, bool*/) {
2354 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2355 PyErr_SetString(PyExc_NotImplementedError,
2356 "wxSound is not available on this platform.");
2357 wxPyEndBlockThreads(blocked);
2358 }
2359 wxSound(int, const wxByte*) {
2360 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2361 PyErr_SetString(PyExc_NotImplementedError,
2362 "wxSound is not available on this platform.");
2363 wxPyEndBlockThreads(blocked);
2364 }
2365
2366 ~wxSound() {};
2367
2368 bool Create(const wxString&/*, bool*/) { return false; }
2369 bool Create(int, const wxByte*) { return false; };
2370 bool IsOk() { return false; };
2371 bool Play(unsigned) const { return false; }
2372 static bool Play(const wxString&, unsigned) { return false; }
2373 static void Stop() {}
2374 };
2375
2376 #endif
2377
2378 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2379 if (fileName.Length() == 0)
2380 return new wxSound;
2381 else
2382 return new wxSound(fileName);
2383 }
2384 static wxSound *new_wxSound(PyObject *data){
2385 unsigned char* buffer; int size;
2386 wxSound *sound = NULL;
2387
2388 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2389 if (!PyArg_Parse(data, "t#", &buffer, &size))
2390 goto done;
2391 sound = new wxSound(size, buffer);
2392 done:
2393 wxPyEndBlockThreads(blocked);
2394 return sound;
2395 }
2396 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2397 #ifndef __WXMAC__
2398 unsigned char* buffer;
2399 int size;
2400 bool rv = false;
2401
2402 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2403 if (!PyArg_Parse(data, "t#", &buffer, &size))
2404 goto done;
2405 rv = self->Create(size, buffer);
2406 done:
2407 wxPyEndBlockThreads(blocked);
2408 return rv;
2409 #else
2410 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2411 PyErr_SetString(PyExc_NotImplementedError,
2412 "Create from data is not available on this platform.");
2413 wxPyEndBlockThreads(blocked);
2414 return false;
2415 #endif
2416 }
2417
2418 #include <wx/mimetype.h>
2419
2420 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2421 wxString str;
2422 if (self->GetMimeType(&str))
2423 return wx2PyString(str);
2424 else
2425 RETURN_NONE();
2426 }
2427 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2428 wxArrayString arr;
2429 if (self->GetMimeTypes(arr))
2430 return wxArrayString2PyList_helper(arr);
2431 else
2432 RETURN_NONE();
2433 }
2434 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2435 wxArrayString arr;
2436 if (self->GetExtensions(arr))
2437 return wxArrayString2PyList_helper(arr);
2438 else
2439 RETURN_NONE();
2440 }
2441 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2442 wxIconLocation loc;
2443 if (self->GetIcon(&loc))
2444 return new wxIcon(loc);
2445 else
2446 return NULL;
2447 }
2448 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2449 wxIconLocation loc;
2450 if (self->GetIcon(&loc)) {
2451 wxString iconFile = loc.GetFileName();
2452 int iconIndex = -1;
2453
2454
2455
2456 // Make a tuple and put the values in it
2457 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2458 PyObject* tuple = PyTuple_New(3);
2459 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2460 wxT("wxIcon"), true));
2461 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2462 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2463 wxPyEndBlockThreads(blocked);
2464 return tuple;
2465 }
2466 else
2467 RETURN_NONE();
2468 }
2469 static PyObject *wxFileType_GetDescription(wxFileType *self){
2470 wxString str;
2471 if (self->GetDescription(&str))
2472 return wx2PyString(str);
2473 else
2474 RETURN_NONE();
2475 }
2476 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2477 wxString str;
2478 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2479 return wx2PyString(str);
2480 else
2481 RETURN_NONE();
2482 }
2483 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2484 wxString str;
2485 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2486 return wx2PyString(str);
2487 else
2488 RETURN_NONE();
2489 }
2490 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2491 wxArrayString verbs;
2492 wxArrayString commands;
2493 if (self->GetAllCommands(&verbs, &commands,
2494 wxFileType::MessageParameters(filename, mimetype))) {
2495 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2496 PyObject* tuple = PyTuple_New(2);
2497 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2498 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2499 wxPyEndBlockThreads(blocked);
2500 return tuple;
2501 }
2502 else
2503 RETURN_NONE();
2504 }
2505 static wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2506 return wxFileType::ExpandCommand(command,
2507 wxFileType::MessageParameters(filename, mimetype));
2508 }
2509 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2510 wxArrayString arr;
2511 self->EnumAllFileTypes(arr);
2512 return wxArrayString2PyList_helper(arr);
2513 }
2514
2515 #include <wx/artprov.h>
2516
2517 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2518 static const wxString wxPyART_MENU(wxART_MENU);
2519 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2520 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2521 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2522 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2523 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2524 static const wxString wxPyART_OTHER(wxART_OTHER);
2525 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2526 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2527 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2528 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2529 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2530 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2531 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2532 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2533 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2534 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2535 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2536 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2537 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2538 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2539 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2540 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2541 static const wxString wxPyART_PRINT(wxART_PRINT);
2542 static const wxString wxPyART_HELP(wxART_HELP);
2543 static const wxString wxPyART_TIP(wxART_TIP);
2544 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2545 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2546 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2547 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2548 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2549 static const wxString wxPyART_CDROM(wxART_CDROM);
2550 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2551 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2552 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2553 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2554 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2555 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2556 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2557 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2558 static const wxString wxPyART_ERROR(wxART_ERROR);
2559 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2560 static const wxString wxPyART_WARNING(wxART_WARNING);
2561 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2562 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2563 static const wxString wxPyART_COPY(wxART_COPY);
2564 static const wxString wxPyART_CUT(wxART_CUT);
2565 static const wxString wxPyART_PASTE(wxART_PASTE);
2566 static const wxString wxPyART_DELETE(wxART_DELETE);
2567 static const wxString wxPyART_NEW(wxART_NEW);
2568 static const wxString wxPyART_UNDO(wxART_UNDO);
2569 static const wxString wxPyART_REDO(wxART_REDO);
2570 static const wxString wxPyART_QUIT(wxART_QUIT);
2571 static const wxString wxPyART_FIND(wxART_FIND);
2572 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2573 // Python aware wxArtProvider
2574 class wxPyArtProvider : public wxArtProvider {
2575 public:
2576
2577 virtual wxBitmap CreateBitmap(const wxArtID& id,
2578 const wxArtClient& client,
2579 const wxSize& size) {
2580 wxBitmap rval = wxNullBitmap;
2581 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2582 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2583 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2584 PyObject* ro;
2585 wxBitmap* ptr;
2586 PyObject* s1, *s2;
2587 s1 = wx2PyString(id);
2588 s2 = wx2PyString(client);
2589 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2590 Py_DECREF(so);
2591 Py_DECREF(s1);
2592 Py_DECREF(s2);
2593 if (ro) {
2594 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2595 rval = *ptr;
2596 Py_DECREF(ro);
2597 }
2598 }
2599 wxPyEndBlockThreads(blocked);
2600 return rval;
2601 }
2602
2603 PYPRIVATE;
2604 };
2605
2606 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2607
2608
2609
2610 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2611 PyObject* ret = PyTuple_New(3);
2612 if (ret) {
2613 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2614 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2615 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2616 }
2617 return ret;
2618 }
2619
2620 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2621 bool cont;
2622 long index = 0;
2623 wxString value;
2624
2625 cont = self->GetFirstGroup(value, index);
2626 return __EnumerationHelper(cont, value, index);
2627 }
2628 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2629 bool cont;
2630 wxString value;
2631
2632 cont = self->GetNextGroup(value, index);
2633 return __EnumerationHelper(cont, value, index);
2634 }
2635 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2636 bool cont;
2637 long index = 0;
2638 wxString value;
2639
2640 cont = self->GetFirstEntry(value, index);
2641 return __EnumerationHelper(cont, value, index);
2642 }
2643 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2644 bool cont;
2645 wxString value;
2646
2647 cont = self->GetNextEntry(value, index);
2648 return __EnumerationHelper(cont, value, index);
2649 }
2650 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2651 long rv;
2652 self->Read(key, &rv, defaultVal);
2653 return rv;
2654 }
2655
2656 SWIGINTERN int
2657 SWIG_AsVal_double(PyObject *obj, double* val)
2658 {
2659 if (PyNumber_Check(obj)) {
2660 if (val) *val = PyFloat_AsDouble(obj);
2661 return 1;
2662 }
2663 else {
2664 SWIG_type_error("number", obj);
2665 }
2666 return 0;
2667 }
2668
2669
2670 SWIGINTERNINLINE double
2671 SWIG_As_double(PyObject* obj)
2672 {
2673 double v;
2674 if (!SWIG_AsVal_double(obj, &v)) {
2675 /*
2676 this is needed to make valgrind/purify happier.
2677 */
2678 memset((void*)&v, 0, sizeof(double));
2679 }
2680 return v;
2681 }
2682
2683
2684 SWIGINTERNINLINE int
2685 SWIG_Check_double(PyObject* obj)
2686 {
2687 return SWIG_AsVal_double(obj, (double*)0);
2688 }
2689
2690 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2691 double rv;
2692 self->Read(key, &rv, defaultVal);
2693 return rv;
2694 }
2695
2696 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2697 #define SWIG_From_double PyFloat_FromDouble
2698 /*@@*/
2699
2700 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2701 bool rv;
2702 self->Read(key, &rv, defaultVal);
2703 return rv;
2704 }
2705
2706 #include <wx/datetime.h>
2707
2708 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2709 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2710
2711 #define LOCAL_TZ wxDateTime::Local
2712
2713 static PyObject *wxDateTime_GetAmPmStrings(){
2714 wxString am;
2715 wxString pm;
2716 wxDateTime::GetAmPmStrings(&am, &pm);
2717 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2718 PyObject* tup = PyTuple_New(2);
2719 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2720 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2721 wxPyEndBlockThreads(blocked);
2722 return tup;
2723 }
2724
2725 #if UINT_MAX < LONG_MAX
2726 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2727 #define SWIG_From_unsigned_SS_int SWIG_From_long
2728 /*@@*/
2729 #else
2730 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2731 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2732 /*@@*/
2733 #endif
2734
2735 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2736 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2737 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2738 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2739 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2740 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2741 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2742 return (*self < *other);
2743 }
2744 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2745 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2746 return (*self <= *other);
2747 }
2748 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2749 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2750 return (*self > *other);
2751 }
2752 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2753 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2754 return (*self >= *other);
2755 }
2756 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2757 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2758 return (*self == *other);
2759 }
2760 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2761 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2762 return (*self != *other);
2763 }
2764 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2765 const wxChar* rv;
2766 const wxChar* _date = date;
2767 rv = self->ParseRfc822Date(_date);
2768 if (rv == NULL) return -1;
2769 return rv - _date;
2770 }
2771 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2772 const wxChar* rv;
2773 const wxChar* _date = date;
2774 rv = self->ParseFormat(_date, format, dateDef);
2775 if (rv == NULL) return -1;
2776 return rv - _date;
2777 }
2778 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2779 const wxChar* rv;
2780 const wxChar* _datetime = datetime;
2781 rv = self->ParseDateTime(_datetime);
2782 if (rv == NULL) return -1;
2783 return rv - _datetime;
2784 }
2785 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2786 const wxChar* rv;
2787 const wxChar* _date = date;
2788 rv = self->ParseDate(_date);
2789 if (rv == NULL) return -1;
2790 return rv - _date;
2791 }
2792 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2793 const wxChar* rv;
2794 const wxChar* _time = time;
2795 rv = self->ParseTime(_time);
2796 if (rv == NULL) return -1;
2797 return rv - _time;
2798 }
2799 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2800 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2801 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2802 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2803 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2804 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2805 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2806 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2807 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2808 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2809 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2810 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2811 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2812 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2813 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2814 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2815
2816 #include <wx/dataobj.h>
2817
2818 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2819 size_t count = self->GetFormatCount(dir);
2820 wxDataFormat* formats = new wxDataFormat[count];
2821 self->GetAllFormats(formats, dir);
2822
2823 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2824 PyObject* list = PyList_New(count);
2825 for (size_t i=0; i<count; i++) {
2826 wxDataFormat* format = new wxDataFormat(formats[i]);
2827 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2828 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
2829 }
2830 wxPyEndBlockThreads(blocked);
2831 delete [] formats;
2832 return list;
2833 }
2834 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2835 PyObject* rval = NULL;
2836 size_t size = self->GetDataSize(format);
2837 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2838 if (size) {
2839 char* buf = new char[size];
2840 if (self->GetDataHere(format, buf))
2841 rval = PyString_FromStringAndSize(buf, size);
2842 delete [] buf;
2843 }
2844 if (! rval) {
2845 rval = Py_None;
2846 Py_INCREF(rval);
2847 }
2848 wxPyEndBlockThreads(blocked);
2849 return rval;
2850 }
2851 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2852 bool rval;
2853 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2854 if (PyString_Check(data)) {
2855 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2856 }
2857 else {
2858 // raise a TypeError if not a string
2859 PyErr_SetString(PyExc_TypeError, "String expected.");
2860 rval = false;
2861 }
2862 wxPyEndBlockThreads(blocked);
2863 return rval;
2864 }
2865 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2866 PyObject* rval = NULL;
2867 size_t size = self->GetDataSize();
2868 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2869 if (size) {
2870 char* buf = new char[size];
2871 if (self->GetDataHere(buf))
2872 rval = PyString_FromStringAndSize(buf, size);
2873 delete [] buf;
2874 }
2875 if (! rval) {
2876 rval = Py_None;
2877 Py_INCREF(rval);
2878 }
2879 wxPyEndBlockThreads(blocked);
2880 return rval;
2881 }
2882 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2883 bool rval;
2884 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2885 if (PyString_Check(data)) {
2886 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2887 }
2888 else {
2889 // raise a TypeError if not a string
2890 PyErr_SetString(PyExc_TypeError, "String expected.");
2891 rval = false;
2892 }
2893 wxPyEndBlockThreads(blocked);
2894 return rval;
2895 }
2896 // Create a new class for wxPython to use
2897 class wxPyDataObjectSimple : public wxDataObjectSimple {
2898 public:
2899 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2900 : wxDataObjectSimple(format) {}
2901
2902 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2903 bool GetDataHere(void *buf) const;
2904 bool SetData(size_t len, const void *buf) const;
2905 PYPRIVATE;
2906 };
2907
2908 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2909
2910 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2911 // We need to get the data for this object and write it to buf. I think
2912 // the best way to do this for wxPython is to have the Python method
2913 // return either a string or None and then act appropriately with the
2914 // C++ version.
2915
2916 bool rval = false;
2917 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2918 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2919 PyObject* ro;
2920 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2921 if (ro) {
2922 rval = (ro != Py_None && PyString_Check(ro));
2923 if (rval)
2924 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2925 Py_DECREF(ro);
2926 }
2927 }
2928 wxPyEndBlockThreads(blocked);
2929 return rval;
2930 }
2931
2932 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2933 // For this one we simply need to make a string from buf and len
2934 // and send it to the Python method.
2935 bool rval = false;
2936 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2937 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2938 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2939 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2940 Py_DECREF(data);
2941 }
2942 wxPyEndBlockThreads(blocked);
2943 return rval;
2944 }
2945
2946 // Create a new class for wxPython to use
2947 class wxPyTextDataObject : public wxTextDataObject {
2948 public:
2949 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2950 : wxTextDataObject(text) {}
2951
2952 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2953 DEC_PYCALLBACK_STRING__const(GetText);
2954 DEC_PYCALLBACK__STRING(SetText);
2955 PYPRIVATE;
2956 };
2957
2958 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2959 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2960 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2961
2962
2963 // Create a new class for wxPython to use
2964 class wxPyBitmapDataObject : public wxBitmapDataObject {
2965 public:
2966 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2967 : wxBitmapDataObject(bitmap) {}
2968
2969 wxBitmap GetBitmap() const;
2970 void SetBitmap(const wxBitmap& bitmap);
2971 PYPRIVATE;
2972 };
2973
2974 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2975 wxBitmap* rval = &wxNullBitmap;
2976 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2977 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2978 PyObject* ro;
2979 wxBitmap* ptr;
2980 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2981 if (ro) {
2982 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2983 rval = ptr;
2984 Py_DECREF(ro);
2985 }
2986 }
2987 wxPyEndBlockThreads(blocked);
2988 return *rval;
2989 }
2990
2991 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2993 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2994 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2995 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2996 Py_DECREF(bo);
2997 }
2998 wxPyEndBlockThreads(blocked);
2999 }
3000
3001 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3002 return new wxCustomDataObject(wxDataFormat(formatName));
3003 }
3004 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3005 bool rval;
3006 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3007 if (PyString_Check(data)) {
3008 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3009 }
3010 else {
3011 // raise a TypeError if not a string
3012 PyErr_SetString(PyExc_TypeError, "String expected.");
3013 rval = false;
3014 }
3015 wxPyEndBlockThreads(blocked);
3016 return rval;
3017 }
3018 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3019 PyObject* obj;
3020 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3021 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3022 wxPyEndBlockThreads(blocked);
3023 return obj;
3024 }
3025
3026 class wxMetafileDataObject : public wxDataObjectSimple
3027 {
3028 public:
3029 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3030 };
3031
3032
3033 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3034
3035
3036 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3037 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3038 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3039 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3040 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3041
3042
3043 class wxPyTextDropTarget : public wxTextDropTarget {
3044 public:
3045 wxPyTextDropTarget() {}
3046
3047 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3048
3049 DEC_PYCALLBACK__(OnLeave);
3050 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3051 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3052 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3053 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3054
3055 PYPRIVATE;
3056 };
3057
3058 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3059 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3060 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3061 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3062 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3063 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3064
3065
3066
3067 class wxPyFileDropTarget : public wxFileDropTarget {
3068 public:
3069 wxPyFileDropTarget() {}
3070
3071 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3072
3073 DEC_PYCALLBACK__(OnLeave);
3074 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3075 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3076 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3077 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3078
3079 PYPRIVATE;
3080 };
3081
3082 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3083 const wxArrayString& filenames) {
3084 bool rval = false;
3085 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3086 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3087 PyObject* list = wxArrayString2PyList_helper(filenames);
3088 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3089 Py_DECREF(list);
3090 }
3091 wxPyEndBlockThreads(blocked);
3092 return rval;
3093 }
3094
3095
3096
3097 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3098 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3099 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3100 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3101 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
3102
3103
3104
3105
3106 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
3107
3108 #include <wx/display.h>
3109
3110 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
3111 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
3112
3113 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
3114 #if !wxUSE_DISPLAY
3115 #include <wx/dynarray.h>
3116 #include <wx/vidmode.h>
3117
3118 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
3119 #include "wx/arrimpl.cpp"
3120 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
3121 const wxVideoMode wxDefaultVideoMode;
3122
3123 class wxDisplay
3124 {
3125 public:
3126 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
3127 ~wxDisplay() {}
3128
3129 static size_t GetCount()
3130 { wxPyRaiseNotImplemented(); return 0; }
3131
3132 static int GetFromPoint(const wxPoint& pt)
3133 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
3134 static int GetFromWindow(wxWindow *window)
3135 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
3136
3137 virtual bool IsOk() const { return false; }
3138 virtual wxRect GetGeometry() const { wxRect r; return r; }
3139 virtual wxString GetName() const { return wxEmptyString; }
3140 bool IsPrimary() const { return false; }
3141
3142 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
3143 { wxArrayVideoModes a; return a; }
3144
3145 virtual wxVideoMode GetCurrentMode() const
3146 { return wxDefaultVideoMode; }
3147
3148 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
3149 { return false; }
3150
3151 void ResetMode() {}
3152 };
3153 #endif
3154
3155 static int wxDisplay_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
3156 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
3157 PyObject* pyList = NULL;
3158 wxArrayVideoModes arr = self->GetModes(mode);
3159 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3160 pyList = PyList_New(0);
3161 for (int i=0; i < arr.GetCount(); i++) {
3162 wxVideoMode* m = new wxVideoMode(arr.Item(i));
3163 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
3164 PyList_Append(pyList, pyObj);
3165 Py_DECREF(pyObj);
3166 }
3167 wxPyEndBlockThreads(blocked);
3168 return pyList;
3169 }
3170
3171 #include <wx/stdpaths.h>
3172
3173 static wxStandardPaths *wxStandardPaths_Get(){
3174 return (wxStandardPaths*) &wxStandardPaths::Get();
3175 }
3176 #ifdef __cplusplus
3177 extern "C" {
3178 #endif
3179 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3180 PyObject *resultobj = NULL;
3181 wxSystemColour arg1 ;
3182 wxColour result;
3183 PyObject * obj0 = 0 ;
3184 char *kwnames[] = {
3185 (char *) "index", NULL
3186 };
3187
3188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3189 {
3190 arg1 = static_cast<wxSystemColour >(SWIG_As_int(obj0));
3191 if (SWIG_arg_fail(1)) SWIG_fail;
3192 }
3193 {
3194 if (!wxPyCheckForApp()) SWIG_fail;
3195 PyThreadState* __tstate = wxPyBeginAllowThreads();
3196 result = wxSystemSettings::GetColour(arg1);
3197
3198 wxPyEndAllowThreads(__tstate);
3199 if (PyErr_Occurred()) SWIG_fail;
3200 }
3201 {
3202 wxColour * resultptr;
3203 resultptr = new wxColour(static_cast<wxColour & >(result));
3204 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3205 }
3206 return resultobj;
3207 fail:
3208 return NULL;
3209 }
3210
3211
3212 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3213 PyObject *resultobj = NULL;
3214 wxSystemFont arg1 ;
3215 wxFont result;
3216 PyObject * obj0 = 0 ;
3217 char *kwnames[] = {
3218 (char *) "index", NULL
3219 };
3220
3221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3222 {
3223 arg1 = static_cast<wxSystemFont >(SWIG_As_int(obj0));
3224 if (SWIG_arg_fail(1)) SWIG_fail;
3225 }
3226 {
3227 if (!wxPyCheckForApp()) SWIG_fail;
3228 PyThreadState* __tstate = wxPyBeginAllowThreads();
3229 result = wxSystemSettings::GetFont(arg1);
3230
3231 wxPyEndAllowThreads(__tstate);
3232 if (PyErr_Occurred()) SWIG_fail;
3233 }
3234 {
3235 wxFont * resultptr;
3236 resultptr = new wxFont(static_cast<wxFont & >(result));
3237 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3238 }
3239 return resultobj;
3240 fail:
3241 return NULL;
3242 }
3243
3244
3245 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3246 PyObject *resultobj = NULL;
3247 wxSystemMetric arg1 ;
3248 wxWindow *arg2 = (wxWindow *) NULL ;
3249 int result;
3250 PyObject * obj0 = 0 ;
3251 PyObject * obj1 = 0 ;
3252 char *kwnames[] = {
3253 (char *) "index",(char *) "win", NULL
3254 };
3255
3256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3257 {
3258 arg1 = static_cast<wxSystemMetric >(SWIG_As_int(obj0));
3259 if (SWIG_arg_fail(1)) SWIG_fail;
3260 }
3261 if (obj1) {
3262 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3263 if (SWIG_arg_fail(2)) SWIG_fail;
3264 }
3265 {
3266 if (!wxPyCheckForApp()) SWIG_fail;
3267 PyThreadState* __tstate = wxPyBeginAllowThreads();
3268 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
3269
3270 wxPyEndAllowThreads(__tstate);
3271 if (PyErr_Occurred()) SWIG_fail;
3272 }
3273 {
3274 resultobj = SWIG_From_int(static_cast<int >(result));
3275 }
3276 return resultobj;
3277 fail:
3278 return NULL;
3279 }
3280
3281
3282 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3283 PyObject *resultobj = NULL;
3284 wxSystemFeature arg1 ;
3285 bool result;
3286 PyObject * obj0 = 0 ;
3287 char *kwnames[] = {
3288 (char *) "index", NULL
3289 };
3290
3291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3292 {
3293 arg1 = static_cast<wxSystemFeature >(SWIG_As_int(obj0));
3294 if (SWIG_arg_fail(1)) SWIG_fail;
3295 }
3296 {
3297 if (!wxPyCheckForApp()) SWIG_fail;
3298 PyThreadState* __tstate = wxPyBeginAllowThreads();
3299 result = (bool)wxSystemSettings::HasFeature(arg1);
3300
3301 wxPyEndAllowThreads(__tstate);
3302 if (PyErr_Occurred()) SWIG_fail;
3303 }
3304 {
3305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3306 }
3307 return resultobj;
3308 fail:
3309 return NULL;
3310 }
3311
3312
3313 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3314 PyObject *resultobj = NULL;
3315 wxSystemScreenType result;
3316 char *kwnames[] = {
3317 NULL
3318 };
3319
3320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3321 {
3322 if (!wxPyCheckForApp()) SWIG_fail;
3323 PyThreadState* __tstate = wxPyBeginAllowThreads();
3324 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3325
3326 wxPyEndAllowThreads(__tstate);
3327 if (PyErr_Occurred()) SWIG_fail;
3328 }
3329 resultobj = SWIG_From_int((result));
3330 return resultobj;
3331 fail:
3332 return NULL;
3333 }
3334
3335
3336 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3337 PyObject *resultobj = NULL;
3338 wxSystemScreenType arg1 ;
3339 PyObject * obj0 = 0 ;
3340 char *kwnames[] = {
3341 (char *) "screen", NULL
3342 };
3343
3344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3345 {
3346 arg1 = static_cast<wxSystemScreenType >(SWIG_As_int(obj0));
3347 if (SWIG_arg_fail(1)) SWIG_fail;
3348 }
3349 {
3350 if (!wxPyCheckForApp()) SWIG_fail;
3351 PyThreadState* __tstate = wxPyBeginAllowThreads();
3352 wxSystemSettings::SetScreenType(arg1);
3353
3354 wxPyEndAllowThreads(__tstate);
3355 if (PyErr_Occurred()) SWIG_fail;
3356 }
3357 Py_INCREF(Py_None); resultobj = Py_None;
3358 return resultobj;
3359 fail:
3360 return NULL;
3361 }
3362
3363
3364 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3365 PyObject *obj;
3366 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3367 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3368 Py_INCREF(obj);
3369 return Py_BuildValue((char *)"");
3370 }
3371 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3372 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3373 return 1;
3374 }
3375
3376
3377 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3378 PyObject *pyobj = NULL;
3379
3380 {
3381 #if wxUSE_UNICODE
3382 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3383 #else
3384 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3385 #endif
3386 }
3387 return pyobj;
3388 }
3389
3390
3391 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3392 PyObject *resultobj = NULL;
3393 wxSystemOptions *result;
3394 char *kwnames[] = {
3395 NULL
3396 };
3397
3398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3399 {
3400 PyThreadState* __tstate = wxPyBeginAllowThreads();
3401 result = (wxSystemOptions *)new wxSystemOptions();
3402
3403 wxPyEndAllowThreads(__tstate);
3404 if (PyErr_Occurred()) SWIG_fail;
3405 }
3406 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3407 return resultobj;
3408 fail:
3409 return NULL;
3410 }
3411
3412
3413 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3414 PyObject *resultobj = NULL;
3415 wxString *arg1 = 0 ;
3416 wxString *arg2 = 0 ;
3417 bool temp1 = false ;
3418 bool temp2 = false ;
3419 PyObject * obj0 = 0 ;
3420 PyObject * obj1 = 0 ;
3421 char *kwnames[] = {
3422 (char *) "name",(char *) "value", NULL
3423 };
3424
3425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3426 {
3427 arg1 = wxString_in_helper(obj0);
3428 if (arg1 == NULL) SWIG_fail;
3429 temp1 = true;
3430 }
3431 {
3432 arg2 = wxString_in_helper(obj1);
3433 if (arg2 == NULL) SWIG_fail;
3434 temp2 = true;
3435 }
3436 {
3437 PyThreadState* __tstate = wxPyBeginAllowThreads();
3438 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3439
3440 wxPyEndAllowThreads(__tstate);
3441 if (PyErr_Occurred()) SWIG_fail;
3442 }
3443 Py_INCREF(Py_None); resultobj = Py_None;
3444 {
3445 if (temp1)
3446 delete arg1;
3447 }
3448 {
3449 if (temp2)
3450 delete arg2;
3451 }
3452 return resultobj;
3453 fail:
3454 {
3455 if (temp1)
3456 delete arg1;
3457 }
3458 {
3459 if (temp2)
3460 delete arg2;
3461 }
3462 return NULL;
3463 }
3464
3465
3466 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3467 PyObject *resultobj = NULL;
3468 wxString *arg1 = 0 ;
3469 int arg2 ;
3470 bool temp1 = false ;
3471 PyObject * obj0 = 0 ;
3472 PyObject * obj1 = 0 ;
3473 char *kwnames[] = {
3474 (char *) "name",(char *) "value", NULL
3475 };
3476
3477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3478 {
3479 arg1 = wxString_in_helper(obj0);
3480 if (arg1 == NULL) SWIG_fail;
3481 temp1 = true;
3482 }
3483 {
3484 arg2 = static_cast<int >(SWIG_As_int(obj1));
3485 if (SWIG_arg_fail(2)) SWIG_fail;
3486 }
3487 {
3488 PyThreadState* __tstate = wxPyBeginAllowThreads();
3489 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3490
3491 wxPyEndAllowThreads(__tstate);
3492 if (PyErr_Occurred()) SWIG_fail;
3493 }
3494 Py_INCREF(Py_None); resultobj = Py_None;
3495 {
3496 if (temp1)
3497 delete arg1;
3498 }
3499 return resultobj;
3500 fail:
3501 {
3502 if (temp1)
3503 delete arg1;
3504 }
3505 return NULL;
3506 }
3507
3508
3509 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3510 PyObject *resultobj = NULL;
3511 wxString *arg1 = 0 ;
3512 wxString result;
3513 bool temp1 = false ;
3514 PyObject * obj0 = 0 ;
3515 char *kwnames[] = {
3516 (char *) "name", NULL
3517 };
3518
3519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3520 {
3521 arg1 = wxString_in_helper(obj0);
3522 if (arg1 == NULL) SWIG_fail;
3523 temp1 = true;
3524 }
3525 {
3526 PyThreadState* __tstate = wxPyBeginAllowThreads();
3527 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3528
3529 wxPyEndAllowThreads(__tstate);
3530 if (PyErr_Occurred()) SWIG_fail;
3531 }
3532 {
3533 #if wxUSE_UNICODE
3534 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3535 #else
3536 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3537 #endif
3538 }
3539 {
3540 if (temp1)
3541 delete arg1;
3542 }
3543 return resultobj;
3544 fail:
3545 {
3546 if (temp1)
3547 delete arg1;
3548 }
3549 return NULL;
3550 }
3551
3552
3553 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3554 PyObject *resultobj = NULL;
3555 wxString *arg1 = 0 ;
3556 int result;
3557 bool temp1 = false ;
3558 PyObject * obj0 = 0 ;
3559 char *kwnames[] = {
3560 (char *) "name", NULL
3561 };
3562
3563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3564 {
3565 arg1 = wxString_in_helper(obj0);
3566 if (arg1 == NULL) SWIG_fail;
3567 temp1 = true;
3568 }
3569 {
3570 PyThreadState* __tstate = wxPyBeginAllowThreads();
3571 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3572
3573 wxPyEndAllowThreads(__tstate);
3574 if (PyErr_Occurred()) SWIG_fail;
3575 }
3576 {
3577 resultobj = SWIG_From_int(static_cast<int >(result));
3578 }
3579 {
3580 if (temp1)
3581 delete arg1;
3582 }
3583 return resultobj;
3584 fail:
3585 {
3586 if (temp1)
3587 delete arg1;
3588 }
3589 return NULL;
3590 }
3591
3592
3593 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3594 PyObject *resultobj = NULL;
3595 wxString *arg1 = 0 ;
3596 bool result;
3597 bool temp1 = false ;
3598 PyObject * obj0 = 0 ;
3599 char *kwnames[] = {
3600 (char *) "name", NULL
3601 };
3602
3603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3604 {
3605 arg1 = wxString_in_helper(obj0);
3606 if (arg1 == NULL) SWIG_fail;
3607 temp1 = true;
3608 }
3609 {
3610 PyThreadState* __tstate = wxPyBeginAllowThreads();
3611 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3612
3613 wxPyEndAllowThreads(__tstate);
3614 if (PyErr_Occurred()) SWIG_fail;
3615 }
3616 {
3617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3618 }
3619 {
3620 if (temp1)
3621 delete arg1;
3622 }
3623 return resultobj;
3624 fail:
3625 {
3626 if (temp1)
3627 delete arg1;
3628 }
3629 return NULL;
3630 }
3631
3632
3633 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3634 PyObject *resultobj = NULL;
3635 wxString *arg1 = 0 ;
3636 bool result;
3637 bool temp1 = false ;
3638 PyObject * obj0 = 0 ;
3639 char *kwnames[] = {
3640 (char *) "name", NULL
3641 };
3642
3643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3644 {
3645 arg1 = wxString_in_helper(obj0);
3646 if (arg1 == NULL) SWIG_fail;
3647 temp1 = true;
3648 }
3649 {
3650 PyThreadState* __tstate = wxPyBeginAllowThreads();
3651 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3652
3653 wxPyEndAllowThreads(__tstate);
3654 if (PyErr_Occurred()) SWIG_fail;
3655 }
3656 {
3657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3658 }
3659 {
3660 if (temp1)
3661 delete arg1;
3662 }
3663 return resultobj;
3664 fail:
3665 {
3666 if (temp1)
3667 delete arg1;
3668 }
3669 return NULL;
3670 }
3671
3672
3673 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3674 PyObject *obj;
3675 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3676 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3677 Py_INCREF(obj);
3678 return Py_BuildValue((char *)"");
3679 }
3680 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3681 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3682 return 1;
3683 }
3684
3685
3686 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3687 PyObject *pyobj = NULL;
3688
3689 {
3690 #if wxUSE_UNICODE
3691 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3692 #else
3693 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3694 #endif
3695 }
3696 return pyobj;
3697 }
3698
3699
3700 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3701 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3702 return 1;
3703 }
3704
3705
3706 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3707 PyObject *pyobj = NULL;
3708
3709 {
3710 #if wxUSE_UNICODE
3711 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3712 #else
3713 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3714 #endif
3715 }
3716 return pyobj;
3717 }
3718
3719
3720 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3721 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3722 return 1;
3723 }
3724
3725
3726 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3727 PyObject *pyobj = NULL;
3728
3729 {
3730 #if wxUSE_UNICODE
3731 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3732 #else
3733 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3734 #endif
3735 }
3736 return pyobj;
3737 }
3738
3739
3740 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3741 PyObject *resultobj = NULL;
3742 long result;
3743 char *kwnames[] = {
3744 NULL
3745 };
3746
3747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3748 {
3749 PyThreadState* __tstate = wxPyBeginAllowThreads();
3750 result = (long)wxNewId();
3751
3752 wxPyEndAllowThreads(__tstate);
3753 if (PyErr_Occurred()) SWIG_fail;
3754 }
3755 {
3756 resultobj = SWIG_From_long(static_cast<long >(result));
3757 }
3758 return resultobj;
3759 fail:
3760 return NULL;
3761 }
3762
3763
3764 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3765 PyObject *resultobj = NULL;
3766 long arg1 ;
3767 PyObject * obj0 = 0 ;
3768 char *kwnames[] = {
3769 (char *) "id", NULL
3770 };
3771
3772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3773 {
3774 arg1 = static_cast<long >(SWIG_As_long(obj0));
3775 if (SWIG_arg_fail(1)) SWIG_fail;
3776 }
3777 {
3778 PyThreadState* __tstate = wxPyBeginAllowThreads();
3779 wxRegisterId(arg1);
3780
3781 wxPyEndAllowThreads(__tstate);
3782 if (PyErr_Occurred()) SWIG_fail;
3783 }
3784 Py_INCREF(Py_None); resultobj = Py_None;
3785 return resultobj;
3786 fail:
3787 return NULL;
3788 }
3789
3790
3791 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3792 PyObject *resultobj = NULL;
3793 long result;
3794 char *kwnames[] = {
3795 NULL
3796 };
3797
3798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3799 {
3800 PyThreadState* __tstate = wxPyBeginAllowThreads();
3801 result = (long)wxGetCurrentId();
3802
3803 wxPyEndAllowThreads(__tstate);
3804 if (PyErr_Occurred()) SWIG_fail;
3805 }
3806 {
3807 resultobj = SWIG_From_long(static_cast<long >(result));
3808 }
3809 return resultobj;
3810 fail:
3811 return NULL;
3812 }
3813
3814
3815 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3816 PyObject *resultobj = NULL;
3817 int arg1 ;
3818 bool result;
3819 PyObject * obj0 = 0 ;
3820 char *kwnames[] = {
3821 (char *) "id", NULL
3822 };
3823
3824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3825 {
3826 arg1 = static_cast<int >(SWIG_As_int(obj0));
3827 if (SWIG_arg_fail(1)) SWIG_fail;
3828 }
3829 {
3830 PyThreadState* __tstate = wxPyBeginAllowThreads();
3831 result = (bool)wxIsStockID(arg1);
3832
3833 wxPyEndAllowThreads(__tstate);
3834 if (PyErr_Occurred()) SWIG_fail;
3835 }
3836 {
3837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3838 }
3839 return resultobj;
3840 fail:
3841 return NULL;
3842 }
3843
3844
3845 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3846 PyObject *resultobj = NULL;
3847 int arg1 ;
3848 wxString *arg2 = 0 ;
3849 bool result;
3850 bool temp2 = false ;
3851 PyObject * obj0 = 0 ;
3852 PyObject * obj1 = 0 ;
3853 char *kwnames[] = {
3854 (char *) "id",(char *) "label", NULL
3855 };
3856
3857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3858 {
3859 arg1 = static_cast<int >(SWIG_As_int(obj0));
3860 if (SWIG_arg_fail(1)) SWIG_fail;
3861 }
3862 {
3863 arg2 = wxString_in_helper(obj1);
3864 if (arg2 == NULL) SWIG_fail;
3865 temp2 = true;
3866 }
3867 {
3868 PyThreadState* __tstate = wxPyBeginAllowThreads();
3869 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3870
3871 wxPyEndAllowThreads(__tstate);
3872 if (PyErr_Occurred()) SWIG_fail;
3873 }
3874 {
3875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3876 }
3877 {
3878 if (temp2)
3879 delete arg2;
3880 }
3881 return resultobj;
3882 fail:
3883 {
3884 if (temp2)
3885 delete arg2;
3886 }
3887 return NULL;
3888 }
3889
3890
3891 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3892 PyObject *resultobj = NULL;
3893 int arg1 ;
3894 bool arg2 = (bool) true ;
3895 wxString arg3 = (wxString) wxPyEmptyString ;
3896 wxString result;
3897 PyObject * obj0 = 0 ;
3898 PyObject * obj1 = 0 ;
3899 PyObject * obj2 = 0 ;
3900 char *kwnames[] = {
3901 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3902 };
3903
3904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3905 {
3906 arg1 = static_cast<int >(SWIG_As_int(obj0));
3907 if (SWIG_arg_fail(1)) SWIG_fail;
3908 }
3909 if (obj1) {
3910 {
3911 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
3912 if (SWIG_arg_fail(2)) SWIG_fail;
3913 }
3914 }
3915 if (obj2) {
3916 {
3917 wxString* sptr = wxString_in_helper(obj2);
3918 if (sptr == NULL) SWIG_fail;
3919 arg3 = *sptr;
3920 delete sptr;
3921 }
3922 }
3923 {
3924 PyThreadState* __tstate = wxPyBeginAllowThreads();
3925 result = wxGetStockLabel(arg1,arg2,arg3);
3926
3927 wxPyEndAllowThreads(__tstate);
3928 if (PyErr_Occurred()) SWIG_fail;
3929 }
3930 {
3931 #if wxUSE_UNICODE
3932 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3933 #else
3934 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3935 #endif
3936 }
3937 return resultobj;
3938 fail:
3939 return NULL;
3940 }
3941
3942
3943 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3944 PyObject *resultobj = NULL;
3945 char *kwnames[] = {
3946 NULL
3947 };
3948
3949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3950 {
3951 if (!wxPyCheckForApp()) SWIG_fail;
3952 PyThreadState* __tstate = wxPyBeginAllowThreads();
3953 wxBell();
3954
3955 wxPyEndAllowThreads(__tstate);
3956 if (PyErr_Occurred()) SWIG_fail;
3957 }
3958 Py_INCREF(Py_None); resultobj = Py_None;
3959 return resultobj;
3960 fail:
3961 return NULL;
3962 }
3963
3964
3965 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3966 PyObject *resultobj = NULL;
3967 char *kwnames[] = {
3968 NULL
3969 };
3970
3971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3972 {
3973 if (!wxPyCheckForApp()) SWIG_fail;
3974 PyThreadState* __tstate = wxPyBeginAllowThreads();
3975 wxEndBusyCursor();
3976
3977 wxPyEndAllowThreads(__tstate);
3978 if (PyErr_Occurred()) SWIG_fail;
3979 }
3980 Py_INCREF(Py_None); resultobj = Py_None;
3981 return resultobj;
3982 fail:
3983 return NULL;
3984 }
3985
3986
3987 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3988 PyObject *resultobj = NULL;
3989 bool arg1 = (bool) true ;
3990 long result;
3991 PyObject * obj0 = 0 ;
3992 char *kwnames[] = {
3993 (char *) "resetTimer", NULL
3994 };
3995
3996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3997 if (obj0) {
3998 {
3999 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
4000 if (SWIG_arg_fail(1)) SWIG_fail;
4001 }
4002 }
4003 {
4004 PyThreadState* __tstate = wxPyBeginAllowThreads();
4005 result = (long)wxGetElapsedTime(arg1);
4006
4007 wxPyEndAllowThreads(__tstate);
4008 if (PyErr_Occurred()) SWIG_fail;
4009 }
4010 {
4011 resultobj = SWIG_From_long(static_cast<long >(result));
4012 }
4013 return resultobj;
4014 fail:
4015 return NULL;
4016 }
4017
4018
4019 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
4020 PyObject *resultobj = NULL;
4021 bool result;
4022 char *kwnames[] = {
4023 NULL
4024 };
4025
4026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
4027 {
4028 PyThreadState* __tstate = wxPyBeginAllowThreads();
4029 result = (bool)wxIsBusy();
4030
4031 wxPyEndAllowThreads(__tstate);
4032 if (PyErr_Occurred()) SWIG_fail;
4033 }
4034 {
4035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4036 }
4037 return resultobj;
4038 fail:
4039 return NULL;
4040 }
4041
4042
4043 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
4044 PyObject *resultobj = NULL;
4045 wxString result;
4046 char *kwnames[] = {
4047 NULL
4048 };
4049
4050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
4051 {
4052 PyThreadState* __tstate = wxPyBeginAllowThreads();
4053 result = wxNow();
4054
4055 wxPyEndAllowThreads(__tstate);
4056 if (PyErr_Occurred()) SWIG_fail;
4057 }
4058 {
4059 #if wxUSE_UNICODE
4060 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4061 #else
4062 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4063 #endif
4064 }
4065 return resultobj;
4066 fail:
4067 return NULL;
4068 }
4069
4070
4071 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
4072 PyObject *resultobj = NULL;
4073 wxString const &arg1_defvalue = wxPyEmptyString ;
4074 wxString *arg1 = (wxString *) &arg1_defvalue ;
4075 bool result;
4076 bool temp1 = false ;
4077 PyObject * obj0 = 0 ;
4078 char *kwnames[] = {
4079 (char *) "command", NULL
4080 };
4081
4082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
4083 if (obj0) {
4084 {
4085 arg1 = wxString_in_helper(obj0);
4086 if (arg1 == NULL) SWIG_fail;
4087 temp1 = true;
4088 }
4089 }
4090 {
4091 PyThreadState* __tstate = wxPyBeginAllowThreads();
4092 result = (bool)wxShell((wxString const &)*arg1);
4093
4094 wxPyEndAllowThreads(__tstate);
4095 if (PyErr_Occurred()) SWIG_fail;
4096 }
4097 {
4098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4099 }
4100 {
4101 if (temp1)
4102 delete arg1;
4103 }
4104 return resultobj;
4105 fail:
4106 {
4107 if (temp1)
4108 delete arg1;
4109 }
4110 return NULL;
4111 }
4112
4113
4114 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
4115 PyObject *resultobj = NULL;
4116 char *kwnames[] = {
4117 NULL
4118 };
4119
4120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
4121 {
4122 PyThreadState* __tstate = wxPyBeginAllowThreads();
4123 wxStartTimer();
4124
4125 wxPyEndAllowThreads(__tstate);
4126 if (PyErr_Occurred()) SWIG_fail;
4127 }
4128 Py_INCREF(Py_None); resultobj = Py_None;
4129 return resultobj;
4130 fail:
4131 return NULL;
4132 }
4133
4134
4135 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
4136 PyObject *resultobj = NULL;
4137 int *arg1 = (int *) 0 ;
4138 int *arg2 = (int *) 0 ;
4139 int result;
4140 int temp1 ;
4141 int res1 = 0 ;
4142 int temp2 ;
4143 int res2 = 0 ;
4144 char *kwnames[] = {
4145 NULL
4146 };
4147
4148 arg1 = &temp1; res1 = SWIG_NEWOBJ;
4149 arg2 = &temp2; res2 = SWIG_NEWOBJ;
4150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
4151 {
4152 PyThreadState* __tstate = wxPyBeginAllowThreads();
4153 result = (int)wxGetOsVersion(arg1,arg2);
4154
4155 wxPyEndAllowThreads(__tstate);
4156 if (PyErr_Occurred()) SWIG_fail;
4157 }
4158 {
4159 resultobj = SWIG_From_int(static_cast<int >(result));
4160 }
4161 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4162 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4163 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4164 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4165 return resultobj;
4166 fail:
4167 return NULL;
4168 }
4169
4170
4171 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4172 PyObject *resultobj = NULL;
4173 wxString result;
4174 char *kwnames[] = {
4175 NULL
4176 };
4177
4178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4179 {
4180 PyThreadState* __tstate = wxPyBeginAllowThreads();
4181 result = wxGetOsDescription();
4182
4183 wxPyEndAllowThreads(__tstate);
4184 if (PyErr_Occurred()) SWIG_fail;
4185 }
4186 {
4187 #if wxUSE_UNICODE
4188 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4189 #else
4190 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4191 #endif
4192 }
4193 return resultobj;
4194 fail:
4195 return NULL;
4196 }
4197
4198
4199 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4200 PyObject *resultobj = NULL;
4201 wxMemorySize result;
4202 char *kwnames[] = {
4203 NULL
4204 };
4205
4206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4207 {
4208 PyThreadState* __tstate = wxPyBeginAllowThreads();
4209 result = wxGetFreeMemory();
4210
4211 wxPyEndAllowThreads(__tstate);
4212 if (PyErr_Occurred()) SWIG_fail;
4213 }
4214 {
4215 wxMemorySize * resultptr;
4216 resultptr = new wxMemorySize(static_cast<wxMemorySize & >(result));
4217 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMemorySize, 1);
4218 }
4219 return resultobj;
4220 fail:
4221 return NULL;
4222 }
4223
4224
4225 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4226 PyObject *resultobj = NULL;
4227 wxShutdownFlags arg1 ;
4228 bool result;
4229 PyObject * obj0 = 0 ;
4230 char *kwnames[] = {
4231 (char *) "wFlags", NULL
4232 };
4233
4234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4235 {
4236 arg1 = static_cast<wxShutdownFlags >(SWIG_As_int(obj0));
4237 if (SWIG_arg_fail(1)) SWIG_fail;
4238 }
4239 {
4240 if (!wxPyCheckForApp()) SWIG_fail;
4241 PyThreadState* __tstate = wxPyBeginAllowThreads();
4242 result = (bool)wxShutdown(arg1);
4243
4244 wxPyEndAllowThreads(__tstate);
4245 if (PyErr_Occurred()) SWIG_fail;
4246 }
4247 {
4248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4249 }
4250 return resultobj;
4251 fail:
4252 return NULL;
4253 }
4254
4255
4256 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4257 PyObject *resultobj = NULL;
4258 int arg1 ;
4259 PyObject * obj0 = 0 ;
4260 char *kwnames[] = {
4261 (char *) "secs", NULL
4262 };
4263
4264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4265 {
4266 arg1 = static_cast<int >(SWIG_As_int(obj0));
4267 if (SWIG_arg_fail(1)) SWIG_fail;
4268 }
4269 {
4270 PyThreadState* __tstate = wxPyBeginAllowThreads();
4271 wxSleep(arg1);
4272
4273 wxPyEndAllowThreads(__tstate);
4274 if (PyErr_Occurred()) SWIG_fail;
4275 }
4276 Py_INCREF(Py_None); resultobj = Py_None;
4277 return resultobj;
4278 fail:
4279 return NULL;
4280 }
4281
4282
4283 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4284 PyObject *resultobj = NULL;
4285 unsigned long arg1 ;
4286 PyObject * obj0 = 0 ;
4287 char *kwnames[] = {
4288 (char *) "milliseconds", NULL
4289 };
4290
4291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4292 {
4293 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
4294 if (SWIG_arg_fail(1)) SWIG_fail;
4295 }
4296 {
4297 PyThreadState* __tstate = wxPyBeginAllowThreads();
4298 wxMilliSleep(arg1);
4299
4300 wxPyEndAllowThreads(__tstate);
4301 if (PyErr_Occurred()) SWIG_fail;
4302 }
4303 Py_INCREF(Py_None); resultobj = Py_None;
4304 return resultobj;
4305 fail:
4306 return NULL;
4307 }
4308
4309
4310 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4311 PyObject *resultobj = NULL;
4312 unsigned long arg1 ;
4313 PyObject * obj0 = 0 ;
4314 char *kwnames[] = {
4315 (char *) "microseconds", NULL
4316 };
4317
4318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4319 {
4320 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
4321 if (SWIG_arg_fail(1)) SWIG_fail;
4322 }
4323 {
4324 PyThreadState* __tstate = wxPyBeginAllowThreads();
4325 wxMicroSleep(arg1);
4326
4327 wxPyEndAllowThreads(__tstate);
4328 if (PyErr_Occurred()) SWIG_fail;
4329 }
4330 Py_INCREF(Py_None); resultobj = Py_None;
4331 return resultobj;
4332 fail:
4333 return NULL;
4334 }
4335
4336
4337 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4338 PyObject *resultobj = NULL;
4339 bool arg1 ;
4340 PyObject * obj0 = 0 ;
4341 char *kwnames[] = {
4342 (char *) "enable", NULL
4343 };
4344
4345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4346 {
4347 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
4348 if (SWIG_arg_fail(1)) SWIG_fail;
4349 }
4350 {
4351 PyThreadState* __tstate = wxPyBeginAllowThreads();
4352 wxEnableTopLevelWindows(arg1);
4353
4354 wxPyEndAllowThreads(__tstate);
4355 if (PyErr_Occurred()) SWIG_fail;
4356 }
4357 Py_INCREF(Py_None); resultobj = Py_None;
4358 return resultobj;
4359 fail:
4360 return NULL;
4361 }
4362
4363
4364 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4365 PyObject *resultobj = NULL;
4366 wxString *arg1 = 0 ;
4367 wxString result;
4368 bool temp1 = false ;
4369 PyObject * obj0 = 0 ;
4370 char *kwnames[] = {
4371 (char *) "in", NULL
4372 };
4373
4374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4375 {
4376 arg1 = wxString_in_helper(obj0);
4377 if (arg1 == NULL) SWIG_fail;
4378 temp1 = true;
4379 }
4380 {
4381 PyThreadState* __tstate = wxPyBeginAllowThreads();
4382 result = wxStripMenuCodes((wxString const &)*arg1);
4383
4384 wxPyEndAllowThreads(__tstate);
4385 if (PyErr_Occurred()) SWIG_fail;
4386 }
4387 {
4388 #if wxUSE_UNICODE
4389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4390 #else
4391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4392 #endif
4393 }
4394 {
4395 if (temp1)
4396 delete arg1;
4397 }
4398 return resultobj;
4399 fail:
4400 {
4401 if (temp1)
4402 delete arg1;
4403 }
4404 return NULL;
4405 }
4406
4407
4408 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4409 PyObject *resultobj = NULL;
4410 wxString result;
4411 char *kwnames[] = {
4412 NULL
4413 };
4414
4415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4416 {
4417 PyThreadState* __tstate = wxPyBeginAllowThreads();
4418 result = wxGetEmailAddress();
4419
4420 wxPyEndAllowThreads(__tstate);
4421 if (PyErr_Occurred()) SWIG_fail;
4422 }
4423 {
4424 #if wxUSE_UNICODE
4425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4426 #else
4427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4428 #endif
4429 }
4430 return resultobj;
4431 fail:
4432 return NULL;
4433 }
4434
4435
4436 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4437 PyObject *resultobj = NULL;
4438 wxString result;
4439 char *kwnames[] = {
4440 NULL
4441 };
4442
4443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4444 {
4445 PyThreadState* __tstate = wxPyBeginAllowThreads();
4446 result = wxGetHostName();
4447
4448 wxPyEndAllowThreads(__tstate);
4449 if (PyErr_Occurred()) SWIG_fail;
4450 }
4451 {
4452 #if wxUSE_UNICODE
4453 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4454 #else
4455 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4456 #endif
4457 }
4458 return resultobj;
4459 fail:
4460 return NULL;
4461 }
4462
4463
4464 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4465 PyObject *resultobj = NULL;
4466 wxString result;
4467 char *kwnames[] = {
4468 NULL
4469 };
4470
4471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4472 {
4473 PyThreadState* __tstate = wxPyBeginAllowThreads();
4474 result = wxGetFullHostName();
4475
4476 wxPyEndAllowThreads(__tstate);
4477 if (PyErr_Occurred()) SWIG_fail;
4478 }
4479 {
4480 #if wxUSE_UNICODE
4481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4482 #else
4483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4484 #endif
4485 }
4486 return resultobj;
4487 fail:
4488 return NULL;
4489 }
4490
4491
4492 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4493 PyObject *resultobj = NULL;
4494 wxString result;
4495 char *kwnames[] = {
4496 NULL
4497 };
4498
4499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4500 {
4501 PyThreadState* __tstate = wxPyBeginAllowThreads();
4502 result = wxGetUserId();
4503
4504 wxPyEndAllowThreads(__tstate);
4505 if (PyErr_Occurred()) SWIG_fail;
4506 }
4507 {
4508 #if wxUSE_UNICODE
4509 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4510 #else
4511 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4512 #endif
4513 }
4514 return resultobj;
4515 fail:
4516 return NULL;
4517 }
4518
4519
4520 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4521 PyObject *resultobj = NULL;
4522 wxString result;
4523 char *kwnames[] = {
4524 NULL
4525 };
4526
4527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4528 {
4529 PyThreadState* __tstate = wxPyBeginAllowThreads();
4530 result = wxGetUserName();
4531
4532 wxPyEndAllowThreads(__tstate);
4533 if (PyErr_Occurred()) SWIG_fail;
4534 }
4535 {
4536 #if wxUSE_UNICODE
4537 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4538 #else
4539 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4540 #endif
4541 }
4542 return resultobj;
4543 fail:
4544 return NULL;
4545 }
4546
4547
4548 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4549 PyObject *resultobj = NULL;
4550 wxString result;
4551 char *kwnames[] = {
4552 NULL
4553 };
4554
4555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4556 {
4557 PyThreadState* __tstate = wxPyBeginAllowThreads();
4558 result = wxGetHomeDir();
4559
4560 wxPyEndAllowThreads(__tstate);
4561 if (PyErr_Occurred()) SWIG_fail;
4562 }
4563 {
4564 #if wxUSE_UNICODE
4565 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4566 #else
4567 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4568 #endif
4569 }
4570 return resultobj;
4571 fail:
4572 return NULL;
4573 }
4574
4575
4576 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4577 PyObject *resultobj = NULL;
4578 wxString const &arg1_defvalue = wxPyEmptyString ;
4579 wxString *arg1 = (wxString *) &arg1_defvalue ;
4580 wxString result;
4581 bool temp1 = false ;
4582 PyObject * obj0 = 0 ;
4583 char *kwnames[] = {
4584 (char *) "user", NULL
4585 };
4586
4587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4588 if (obj0) {
4589 {
4590 arg1 = wxString_in_helper(obj0);
4591 if (arg1 == NULL) SWIG_fail;
4592 temp1 = true;
4593 }
4594 }
4595 {
4596 PyThreadState* __tstate = wxPyBeginAllowThreads();
4597 result = wxGetUserHome((wxString const &)*arg1);
4598
4599 wxPyEndAllowThreads(__tstate);
4600 if (PyErr_Occurred()) SWIG_fail;
4601 }
4602 {
4603 #if wxUSE_UNICODE
4604 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4605 #else
4606 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4607 #endif
4608 }
4609 {
4610 if (temp1)
4611 delete arg1;
4612 }
4613 return resultobj;
4614 fail:
4615 {
4616 if (temp1)
4617 delete arg1;
4618 }
4619 return NULL;
4620 }
4621
4622
4623 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4624 PyObject *resultobj = NULL;
4625 unsigned long result;
4626 char *kwnames[] = {
4627 NULL
4628 };
4629
4630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4631 {
4632 PyThreadState* __tstate = wxPyBeginAllowThreads();
4633 result = (unsigned long)wxGetProcessId();
4634
4635 wxPyEndAllowThreads(__tstate);
4636 if (PyErr_Occurred()) SWIG_fail;
4637 }
4638 {
4639 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
4640 }
4641 return resultobj;
4642 fail:
4643 return NULL;
4644 }
4645
4646
4647 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4648 PyObject *resultobj = NULL;
4649 char *kwnames[] = {
4650 NULL
4651 };
4652
4653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4654 {
4655 PyThreadState* __tstate = wxPyBeginAllowThreads();
4656 wxTrap();
4657
4658 wxPyEndAllowThreads(__tstate);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 Py_INCREF(Py_None); resultobj = Py_None;
4662 return resultobj;
4663 fail:
4664 return NULL;
4665 }
4666
4667
4668 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4669 PyObject *resultobj = NULL;
4670 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4671 wxString *arg1 = (wxString *) &arg1_defvalue ;
4672 wxString const &arg2_defvalue = wxPyEmptyString ;
4673 wxString *arg2 = (wxString *) &arg2_defvalue ;
4674 wxString const &arg3_defvalue = wxPyEmptyString ;
4675 wxString *arg3 = (wxString *) &arg3_defvalue ;
4676 wxString const &arg4_defvalue = wxPyEmptyString ;
4677 wxString *arg4 = (wxString *) &arg4_defvalue ;
4678 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4679 wxString *arg5 = (wxString *) &arg5_defvalue ;
4680 int arg6 = (int) 0 ;
4681 wxWindow *arg7 = (wxWindow *) NULL ;
4682 int arg8 = (int) -1 ;
4683 int arg9 = (int) -1 ;
4684 wxString result;
4685 bool temp1 = false ;
4686 bool temp2 = false ;
4687 bool temp3 = false ;
4688 bool temp4 = false ;
4689 bool temp5 = false ;
4690 PyObject * obj0 = 0 ;
4691 PyObject * obj1 = 0 ;
4692 PyObject * obj2 = 0 ;
4693 PyObject * obj3 = 0 ;
4694 PyObject * obj4 = 0 ;
4695 PyObject * obj5 = 0 ;
4696 PyObject * obj6 = 0 ;
4697 PyObject * obj7 = 0 ;
4698 PyObject * obj8 = 0 ;
4699 char *kwnames[] = {
4700 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4701 };
4702
4703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4704 if (obj0) {
4705 {
4706 arg1 = wxString_in_helper(obj0);
4707 if (arg1 == NULL) SWIG_fail;
4708 temp1 = true;
4709 }
4710 }
4711 if (obj1) {
4712 {
4713 arg2 = wxString_in_helper(obj1);
4714 if (arg2 == NULL) SWIG_fail;
4715 temp2 = true;
4716 }
4717 }
4718 if (obj2) {
4719 {
4720 arg3 = wxString_in_helper(obj2);
4721 if (arg3 == NULL) SWIG_fail;
4722 temp3 = true;
4723 }
4724 }
4725 if (obj3) {
4726 {
4727 arg4 = wxString_in_helper(obj3);
4728 if (arg4 == NULL) SWIG_fail;
4729 temp4 = true;
4730 }
4731 }
4732 if (obj4) {
4733 {
4734 arg5 = wxString_in_helper(obj4);
4735 if (arg5 == NULL) SWIG_fail;
4736 temp5 = true;
4737 }
4738 }
4739 if (obj5) {
4740 {
4741 arg6 = static_cast<int >(SWIG_As_int(obj5));
4742 if (SWIG_arg_fail(6)) SWIG_fail;
4743 }
4744 }
4745 if (obj6) {
4746 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4747 if (SWIG_arg_fail(7)) SWIG_fail;
4748 }
4749 if (obj7) {
4750 {
4751 arg8 = static_cast<int >(SWIG_As_int(obj7));
4752 if (SWIG_arg_fail(8)) SWIG_fail;
4753 }
4754 }
4755 if (obj8) {
4756 {
4757 arg9 = static_cast<int >(SWIG_As_int(obj8));
4758 if (SWIG_arg_fail(9)) SWIG_fail;
4759 }
4760 }
4761 {
4762 if (!wxPyCheckForApp()) SWIG_fail;
4763 PyThreadState* __tstate = wxPyBeginAllowThreads();
4764 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4765
4766 wxPyEndAllowThreads(__tstate);
4767 if (PyErr_Occurred()) SWIG_fail;
4768 }
4769 {
4770 #if wxUSE_UNICODE
4771 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4772 #else
4773 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4774 #endif
4775 }
4776 {
4777 if (temp1)
4778 delete arg1;
4779 }
4780 {
4781 if (temp2)
4782 delete arg2;
4783 }
4784 {
4785 if (temp3)
4786 delete arg3;
4787 }
4788 {
4789 if (temp4)
4790 delete arg4;
4791 }
4792 {
4793 if (temp5)
4794 delete arg5;
4795 }
4796 return resultobj;
4797 fail:
4798 {
4799 if (temp1)
4800 delete arg1;
4801 }
4802 {
4803 if (temp2)
4804 delete arg2;
4805 }
4806 {
4807 if (temp3)
4808 delete arg3;
4809 }
4810 {
4811 if (temp4)
4812 delete arg4;
4813 }
4814 {
4815 if (temp5)
4816 delete arg5;
4817 }
4818 return NULL;
4819 }
4820
4821
4822 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4823 PyObject *resultobj = NULL;
4824 wxString *arg1 = 0 ;
4825 wxString *arg2 = 0 ;
4826 wxString const &arg3_defvalue = wxPyEmptyString ;
4827 wxString *arg3 = (wxString *) &arg3_defvalue ;
4828 wxWindow *arg4 = (wxWindow *) NULL ;
4829 wxString result;
4830 bool temp1 = false ;
4831 bool temp2 = false ;
4832 bool temp3 = false ;
4833 PyObject * obj0 = 0 ;
4834 PyObject * obj1 = 0 ;
4835 PyObject * obj2 = 0 ;
4836 PyObject * obj3 = 0 ;
4837 char *kwnames[] = {
4838 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4839 };
4840
4841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4842 {
4843 arg1 = wxString_in_helper(obj0);
4844 if (arg1 == NULL) SWIG_fail;
4845 temp1 = true;
4846 }
4847 {
4848 arg2 = wxString_in_helper(obj1);
4849 if (arg2 == NULL) SWIG_fail;
4850 temp2 = true;
4851 }
4852 if (obj2) {
4853 {
4854 arg3 = wxString_in_helper(obj2);
4855 if (arg3 == NULL) SWIG_fail;
4856 temp3 = true;
4857 }
4858 }
4859 if (obj3) {
4860 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4861 if (SWIG_arg_fail(4)) SWIG_fail;
4862 }
4863 {
4864 if (!wxPyCheckForApp()) SWIG_fail;
4865 PyThreadState* __tstate = wxPyBeginAllowThreads();
4866 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4867
4868 wxPyEndAllowThreads(__tstate);
4869 if (PyErr_Occurred()) SWIG_fail;
4870 }
4871 {
4872 #if wxUSE_UNICODE
4873 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4874 #else
4875 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4876 #endif
4877 }
4878 {
4879 if (temp1)
4880 delete arg1;
4881 }
4882 {
4883 if (temp2)
4884 delete arg2;
4885 }
4886 {
4887 if (temp3)
4888 delete arg3;
4889 }
4890 return resultobj;
4891 fail:
4892 {
4893 if (temp1)
4894 delete arg1;
4895 }
4896 {
4897 if (temp2)
4898 delete arg2;
4899 }
4900 {
4901 if (temp3)
4902 delete arg3;
4903 }
4904 return NULL;
4905 }
4906
4907
4908 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4909 PyObject *resultobj = NULL;
4910 wxString *arg1 = 0 ;
4911 wxString *arg2 = 0 ;
4912 wxString const &arg3_defvalue = wxPyEmptyString ;
4913 wxString *arg3 = (wxString *) &arg3_defvalue ;
4914 wxWindow *arg4 = (wxWindow *) NULL ;
4915 wxString result;
4916 bool temp1 = false ;
4917 bool temp2 = false ;
4918 bool temp3 = false ;
4919 PyObject * obj0 = 0 ;
4920 PyObject * obj1 = 0 ;
4921 PyObject * obj2 = 0 ;
4922 PyObject * obj3 = 0 ;
4923 char *kwnames[] = {
4924 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4925 };
4926
4927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4928 {
4929 arg1 = wxString_in_helper(obj0);
4930 if (arg1 == NULL) SWIG_fail;
4931 temp1 = true;
4932 }
4933 {
4934 arg2 = wxString_in_helper(obj1);
4935 if (arg2 == NULL) SWIG_fail;
4936 temp2 = true;
4937 }
4938 if (obj2) {
4939 {
4940 arg3 = wxString_in_helper(obj2);
4941 if (arg3 == NULL) SWIG_fail;
4942 temp3 = true;
4943 }
4944 }
4945 if (obj3) {
4946 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4947 if (SWIG_arg_fail(4)) SWIG_fail;
4948 }
4949 {
4950 if (!wxPyCheckForApp()) SWIG_fail;
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4953
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 {
4958 #if wxUSE_UNICODE
4959 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4960 #else
4961 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4962 #endif
4963 }
4964 {
4965 if (temp1)
4966 delete arg1;
4967 }
4968 {
4969 if (temp2)
4970 delete arg2;
4971 }
4972 {
4973 if (temp3)
4974 delete arg3;
4975 }
4976 return resultobj;
4977 fail:
4978 {
4979 if (temp1)
4980 delete arg1;
4981 }
4982 {
4983 if (temp2)
4984 delete arg2;
4985 }
4986 {
4987 if (temp3)
4988 delete arg3;
4989 }
4990 return NULL;
4991 }
4992
4993
4994 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4995 PyObject *resultobj = NULL;
4996 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4997 wxString *arg1 = (wxString *) &arg1_defvalue ;
4998 wxString const &arg2_defvalue = wxPyEmptyString ;
4999 wxString *arg2 = (wxString *) &arg2_defvalue ;
5000 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5001 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5002 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5003 wxWindow *arg5 = (wxWindow *) NULL ;
5004 wxString result;
5005 bool temp1 = false ;
5006 bool temp2 = false ;
5007 wxPoint temp4 ;
5008 PyObject * obj0 = 0 ;
5009 PyObject * obj1 = 0 ;
5010 PyObject * obj2 = 0 ;
5011 PyObject * obj3 = 0 ;
5012 PyObject * obj4 = 0 ;
5013 char *kwnames[] = {
5014 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5015 };
5016
5017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5018 if (obj0) {
5019 {
5020 arg1 = wxString_in_helper(obj0);
5021 if (arg1 == NULL) SWIG_fail;
5022 temp1 = true;
5023 }
5024 }
5025 if (obj1) {
5026 {
5027 arg2 = wxString_in_helper(obj1);
5028 if (arg2 == NULL) SWIG_fail;
5029 temp2 = true;
5030 }
5031 }
5032 if (obj2) {
5033 {
5034 arg3 = static_cast<long >(SWIG_As_long(obj2));
5035 if (SWIG_arg_fail(3)) SWIG_fail;
5036 }
5037 }
5038 if (obj3) {
5039 {
5040 arg4 = &temp4;
5041 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5042 }
5043 }
5044 if (obj4) {
5045 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5046 if (SWIG_arg_fail(5)) SWIG_fail;
5047 }
5048 {
5049 if (!wxPyCheckForApp()) SWIG_fail;
5050 PyThreadState* __tstate = wxPyBeginAllowThreads();
5051 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5052
5053 wxPyEndAllowThreads(__tstate);
5054 if (PyErr_Occurred()) SWIG_fail;
5055 }
5056 {
5057 #if wxUSE_UNICODE
5058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5059 #else
5060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5061 #endif
5062 }
5063 {
5064 if (temp1)
5065 delete arg1;
5066 }
5067 {
5068 if (temp2)
5069 delete arg2;
5070 }
5071 return resultobj;
5072 fail:
5073 {
5074 if (temp1)
5075 delete arg1;
5076 }
5077 {
5078 if (temp2)
5079 delete arg2;
5080 }
5081 return NULL;
5082 }
5083
5084
5085 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5086 PyObject *resultobj = NULL;
5087 wxString *arg1 = 0 ;
5088 wxString const &arg2_defvalue = wxPyEmptyString ;
5089 wxString *arg2 = (wxString *) &arg2_defvalue ;
5090 wxString const &arg3_defvalue = wxPyEmptyString ;
5091 wxString *arg3 = (wxString *) &arg3_defvalue ;
5092 wxWindow *arg4 = (wxWindow *) NULL ;
5093 int arg5 = (int) -1 ;
5094 int arg6 = (int) -1 ;
5095 bool arg7 = (bool) true ;
5096 wxString result;
5097 bool temp1 = false ;
5098 bool temp2 = false ;
5099 bool temp3 = false ;
5100 PyObject * obj0 = 0 ;
5101 PyObject * obj1 = 0 ;
5102 PyObject * obj2 = 0 ;
5103 PyObject * obj3 = 0 ;
5104 PyObject * obj4 = 0 ;
5105 PyObject * obj5 = 0 ;
5106 PyObject * obj6 = 0 ;
5107 char *kwnames[] = {
5108 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5109 };
5110
5111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
5112 {
5113 arg1 = wxString_in_helper(obj0);
5114 if (arg1 == NULL) SWIG_fail;
5115 temp1 = true;
5116 }
5117 if (obj1) {
5118 {
5119 arg2 = wxString_in_helper(obj1);
5120 if (arg2 == NULL) SWIG_fail;
5121 temp2 = true;
5122 }
5123 }
5124 if (obj2) {
5125 {
5126 arg3 = wxString_in_helper(obj2);
5127 if (arg3 == NULL) SWIG_fail;
5128 temp3 = true;
5129 }
5130 }
5131 if (obj3) {
5132 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5133 if (SWIG_arg_fail(4)) SWIG_fail;
5134 }
5135 if (obj4) {
5136 {
5137 arg5 = static_cast<int >(SWIG_As_int(obj4));
5138 if (SWIG_arg_fail(5)) SWIG_fail;
5139 }
5140 }
5141 if (obj5) {
5142 {
5143 arg6 = static_cast<int >(SWIG_As_int(obj5));
5144 if (SWIG_arg_fail(6)) SWIG_fail;
5145 }
5146 }
5147 if (obj6) {
5148 {
5149 arg7 = static_cast<bool >(SWIG_As_bool(obj6));
5150 if (SWIG_arg_fail(7)) SWIG_fail;
5151 }
5152 }
5153 {
5154 if (!wxPyCheckForApp()) SWIG_fail;
5155 PyThreadState* __tstate = wxPyBeginAllowThreads();
5156 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
5157
5158 wxPyEndAllowThreads(__tstate);
5159 if (PyErr_Occurred()) SWIG_fail;
5160 }
5161 {
5162 #if wxUSE_UNICODE
5163 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5164 #else
5165 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5166 #endif
5167 }
5168 {
5169 if (temp1)
5170 delete arg1;
5171 }
5172 {
5173 if (temp2)
5174 delete arg2;
5175 }
5176 {
5177 if (temp3)
5178 delete arg3;
5179 }
5180 return resultobj;
5181 fail:
5182 {
5183 if (temp1)
5184 delete arg1;
5185 }
5186 {
5187 if (temp2)
5188 delete arg2;
5189 }
5190 {
5191 if (temp3)
5192 delete arg3;
5193 }
5194 return NULL;
5195 }
5196
5197
5198 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5199 PyObject *resultobj = NULL;
5200 wxString *arg1 = 0 ;
5201 wxString const &arg2_defvalue = wxPyEmptyString ;
5202 wxString *arg2 = (wxString *) &arg2_defvalue ;
5203 wxString const &arg3_defvalue = wxPyEmptyString ;
5204 wxString *arg3 = (wxString *) &arg3_defvalue ;
5205 wxWindow *arg4 = (wxWindow *) NULL ;
5206 wxString result;
5207 bool temp1 = false ;
5208 bool temp2 = false ;
5209 bool temp3 = false ;
5210 PyObject * obj0 = 0 ;
5211 PyObject * obj1 = 0 ;
5212 PyObject * obj2 = 0 ;
5213 PyObject * obj3 = 0 ;
5214 char *kwnames[] = {
5215 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5216 };
5217
5218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5219 {
5220 arg1 = wxString_in_helper(obj0);
5221 if (arg1 == NULL) SWIG_fail;
5222 temp1 = true;
5223 }
5224 if (obj1) {
5225 {
5226 arg2 = wxString_in_helper(obj1);
5227 if (arg2 == NULL) SWIG_fail;
5228 temp2 = true;
5229 }
5230 }
5231 if (obj2) {
5232 {
5233 arg3 = wxString_in_helper(obj2);
5234 if (arg3 == NULL) SWIG_fail;
5235 temp3 = true;
5236 }
5237 }
5238 if (obj3) {
5239 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5240 if (SWIG_arg_fail(4)) SWIG_fail;
5241 }
5242 {
5243 if (!wxPyCheckForApp()) SWIG_fail;
5244 PyThreadState* __tstate = wxPyBeginAllowThreads();
5245 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5246
5247 wxPyEndAllowThreads(__tstate);
5248 if (PyErr_Occurred()) SWIG_fail;
5249 }
5250 {
5251 #if wxUSE_UNICODE
5252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5253 #else
5254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5255 #endif
5256 }
5257 {
5258 if (temp1)
5259 delete arg1;
5260 }
5261 {
5262 if (temp2)
5263 delete arg2;
5264 }
5265 {
5266 if (temp3)
5267 delete arg3;
5268 }
5269 return resultobj;
5270 fail:
5271 {
5272 if (temp1)
5273 delete arg1;
5274 }
5275 {
5276 if (temp2)
5277 delete arg2;
5278 }
5279 {
5280 if (temp3)
5281 delete arg3;
5282 }
5283 return NULL;
5284 }
5285
5286
5287 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5288 PyObject *resultobj = NULL;
5289 wxString *arg1 = 0 ;
5290 wxString *arg2 = 0 ;
5291 int arg3 ;
5292 wxString *arg4 = (wxString *) 0 ;
5293 wxWindow *arg5 = (wxWindow *) NULL ;
5294 int arg6 = (int) -1 ;
5295 int arg7 = (int) -1 ;
5296 bool arg8 = (bool) true ;
5297 int arg9 = (int) 150 ;
5298 int arg10 = (int) 200 ;
5299 wxString result;
5300 bool temp1 = false ;
5301 bool temp2 = false ;
5302 PyObject * obj0 = 0 ;
5303 PyObject * obj1 = 0 ;
5304 PyObject * obj2 = 0 ;
5305 PyObject * obj3 = 0 ;
5306 PyObject * obj4 = 0 ;
5307 PyObject * obj5 = 0 ;
5308 PyObject * obj6 = 0 ;
5309 PyObject * obj7 = 0 ;
5310 PyObject * obj8 = 0 ;
5311 char *kwnames[] = {
5312 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5313 };
5314
5315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5316 {
5317 arg1 = wxString_in_helper(obj0);
5318 if (arg1 == NULL) SWIG_fail;
5319 temp1 = true;
5320 }
5321 {
5322 arg2 = wxString_in_helper(obj1);
5323 if (arg2 == NULL) SWIG_fail;
5324 temp2 = true;
5325 }
5326 {
5327 arg3 = PyList_Size(obj2);
5328 arg4 = wxString_LIST_helper(obj2);
5329 if (arg4 == NULL) SWIG_fail;
5330 }
5331 if (obj3) {
5332 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5333 if (SWIG_arg_fail(5)) SWIG_fail;
5334 }
5335 if (obj4) {
5336 {
5337 arg6 = static_cast<int >(SWIG_As_int(obj4));
5338 if (SWIG_arg_fail(6)) SWIG_fail;
5339 }
5340 }
5341 if (obj5) {
5342 {
5343 arg7 = static_cast<int >(SWIG_As_int(obj5));
5344 if (SWIG_arg_fail(7)) SWIG_fail;
5345 }
5346 }
5347 if (obj6) {
5348 {
5349 arg8 = static_cast<bool >(SWIG_As_bool(obj6));
5350 if (SWIG_arg_fail(8)) SWIG_fail;
5351 }
5352 }
5353 if (obj7) {
5354 {
5355 arg9 = static_cast<int >(SWIG_As_int(obj7));
5356 if (SWIG_arg_fail(9)) SWIG_fail;
5357 }
5358 }
5359 if (obj8) {
5360 {
5361 arg10 = static_cast<int >(SWIG_As_int(obj8));
5362 if (SWIG_arg_fail(10)) SWIG_fail;
5363 }
5364 }
5365 {
5366 if (!wxPyCheckForApp()) SWIG_fail;
5367 PyThreadState* __tstate = wxPyBeginAllowThreads();
5368 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5369
5370 wxPyEndAllowThreads(__tstate);
5371 if (PyErr_Occurred()) SWIG_fail;
5372 }
5373 {
5374 #if wxUSE_UNICODE
5375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5376 #else
5377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5378 #endif
5379 }
5380 {
5381 if (temp1)
5382 delete arg1;
5383 }
5384 {
5385 if (temp2)
5386 delete arg2;
5387 }
5388 {
5389 if (arg4) delete [] arg4;
5390 }
5391 return resultobj;
5392 fail:
5393 {
5394 if (temp1)
5395 delete arg1;
5396 }
5397 {
5398 if (temp2)
5399 delete arg2;
5400 }
5401 {
5402 if (arg4) delete [] arg4;
5403 }
5404 return NULL;
5405 }
5406
5407
5408 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5409 PyObject *resultobj = NULL;
5410 wxString *arg1 = 0 ;
5411 wxString *arg2 = 0 ;
5412 int arg3 ;
5413 wxString *arg4 = (wxString *) 0 ;
5414 wxWindow *arg5 = (wxWindow *) NULL ;
5415 int arg6 = (int) -1 ;
5416 int arg7 = (int) -1 ;
5417 bool arg8 = (bool) true ;
5418 int arg9 = (int) 150 ;
5419 int arg10 = (int) 200 ;
5420 int result;
5421 bool temp1 = false ;
5422 bool temp2 = false ;
5423 PyObject * obj0 = 0 ;
5424 PyObject * obj1 = 0 ;
5425 PyObject * obj2 = 0 ;
5426 PyObject * obj3 = 0 ;
5427 PyObject * obj4 = 0 ;
5428 PyObject * obj5 = 0 ;
5429 PyObject * obj6 = 0 ;
5430 PyObject * obj7 = 0 ;
5431 PyObject * obj8 = 0 ;
5432 char *kwnames[] = {
5433 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5434 };
5435
5436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5437 {
5438 arg1 = wxString_in_helper(obj0);
5439 if (arg1 == NULL) SWIG_fail;
5440 temp1 = true;
5441 }
5442 {
5443 arg2 = wxString_in_helper(obj1);
5444 if (arg2 == NULL) SWIG_fail;
5445 temp2 = true;
5446 }
5447 {
5448 arg3 = PyList_Size(obj2);
5449 arg4 = wxString_LIST_helper(obj2);
5450 if (arg4 == NULL) SWIG_fail;
5451 }
5452 if (obj3) {
5453 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5454 if (SWIG_arg_fail(5)) SWIG_fail;
5455 }
5456 if (obj4) {
5457 {
5458 arg6 = static_cast<int >(SWIG_As_int(obj4));
5459 if (SWIG_arg_fail(6)) SWIG_fail;
5460 }
5461 }
5462 if (obj5) {
5463 {
5464 arg7 = static_cast<int >(SWIG_As_int(obj5));
5465 if (SWIG_arg_fail(7)) SWIG_fail;
5466 }
5467 }
5468 if (obj6) {
5469 {
5470 arg8 = static_cast<bool >(SWIG_As_bool(obj6));
5471 if (SWIG_arg_fail(8)) SWIG_fail;
5472 }
5473 }
5474 if (obj7) {
5475 {
5476 arg9 = static_cast<int >(SWIG_As_int(obj7));
5477 if (SWIG_arg_fail(9)) SWIG_fail;
5478 }
5479 }
5480 if (obj8) {
5481 {
5482 arg10 = static_cast<int >(SWIG_As_int(obj8));
5483 if (SWIG_arg_fail(10)) SWIG_fail;
5484 }
5485 }
5486 {
5487 if (!wxPyCheckForApp()) SWIG_fail;
5488 PyThreadState* __tstate = wxPyBeginAllowThreads();
5489 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5490
5491 wxPyEndAllowThreads(__tstate);
5492 if (PyErr_Occurred()) SWIG_fail;
5493 }
5494 {
5495 resultobj = SWIG_From_int(static_cast<int >(result));
5496 }
5497 {
5498 if (temp1)
5499 delete arg1;
5500 }
5501 {
5502 if (temp2)
5503 delete arg2;
5504 }
5505 {
5506 if (arg4) delete [] arg4;
5507 }
5508 return resultobj;
5509 fail:
5510 {
5511 if (temp1)
5512 delete arg1;
5513 }
5514 {
5515 if (temp2)
5516 delete arg2;
5517 }
5518 {
5519 if (arg4) delete [] arg4;
5520 }
5521 return NULL;
5522 }
5523
5524
5525 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5526 PyObject *resultobj = NULL;
5527 wxString *arg1 = 0 ;
5528 wxString const &arg2_defvalue = wxPyEmptyString ;
5529 wxString *arg2 = (wxString *) &arg2_defvalue ;
5530 int arg3 = (int) wxOK|wxCENTRE ;
5531 wxWindow *arg4 = (wxWindow *) NULL ;
5532 int arg5 = (int) -1 ;
5533 int arg6 = (int) -1 ;
5534 int result;
5535 bool temp1 = false ;
5536 bool temp2 = false ;
5537 PyObject * obj0 = 0 ;
5538 PyObject * obj1 = 0 ;
5539 PyObject * obj2 = 0 ;
5540 PyObject * obj3 = 0 ;
5541 PyObject * obj4 = 0 ;
5542 PyObject * obj5 = 0 ;
5543 char *kwnames[] = {
5544 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5545 };
5546
5547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5548 {
5549 arg1 = wxString_in_helper(obj0);
5550 if (arg1 == NULL) SWIG_fail;
5551 temp1 = true;
5552 }
5553 if (obj1) {
5554 {
5555 arg2 = wxString_in_helper(obj1);
5556 if (arg2 == NULL) SWIG_fail;
5557 temp2 = true;
5558 }
5559 }
5560 if (obj2) {
5561 {
5562 arg3 = static_cast<int >(SWIG_As_int(obj2));
5563 if (SWIG_arg_fail(3)) SWIG_fail;
5564 }
5565 }
5566 if (obj3) {
5567 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5568 if (SWIG_arg_fail(4)) SWIG_fail;
5569 }
5570 if (obj4) {
5571 {
5572 arg5 = static_cast<int >(SWIG_As_int(obj4));
5573 if (SWIG_arg_fail(5)) SWIG_fail;
5574 }
5575 }
5576 if (obj5) {
5577 {
5578 arg6 = static_cast<int >(SWIG_As_int(obj5));
5579 if (SWIG_arg_fail(6)) SWIG_fail;
5580 }
5581 }
5582 {
5583 if (!wxPyCheckForApp()) SWIG_fail;
5584 PyThreadState* __tstate = wxPyBeginAllowThreads();
5585 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5586
5587 wxPyEndAllowThreads(__tstate);
5588 if (PyErr_Occurred()) SWIG_fail;
5589 }
5590 {
5591 resultobj = SWIG_From_int(static_cast<int >(result));
5592 }
5593 {
5594 if (temp1)
5595 delete arg1;
5596 }
5597 {
5598 if (temp2)
5599 delete arg2;
5600 }
5601 return resultobj;
5602 fail:
5603 {
5604 if (temp1)
5605 delete arg1;
5606 }
5607 {
5608 if (temp2)
5609 delete arg2;
5610 }
5611 return NULL;
5612 }
5613
5614
5615 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5616 PyObject *resultobj = NULL;
5617 bool result;
5618 char *kwnames[] = {
5619 NULL
5620 };
5621
5622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5623 {
5624 if (!wxPyCheckForApp()) SWIG_fail;
5625 PyThreadState* __tstate = wxPyBeginAllowThreads();
5626 result = (bool)wxColourDisplay();
5627
5628 wxPyEndAllowThreads(__tstate);
5629 if (PyErr_Occurred()) SWIG_fail;
5630 }
5631 {
5632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5633 }
5634 return resultobj;
5635 fail:
5636 return NULL;
5637 }
5638
5639
5640 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5641 PyObject *resultobj = NULL;
5642 int result;
5643 char *kwnames[] = {
5644 NULL
5645 };
5646
5647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5648 {
5649 if (!wxPyCheckForApp()) SWIG_fail;
5650 PyThreadState* __tstate = wxPyBeginAllowThreads();
5651 result = (int)wxDisplayDepth();
5652
5653 wxPyEndAllowThreads(__tstate);
5654 if (PyErr_Occurred()) SWIG_fail;
5655 }
5656 {
5657 resultobj = SWIG_From_int(static_cast<int >(result));
5658 }
5659 return resultobj;
5660 fail:
5661 return NULL;
5662 }
5663
5664
5665 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5666 PyObject *resultobj = NULL;
5667 int result;
5668 char *kwnames[] = {
5669 NULL
5670 };
5671
5672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5673 {
5674 if (!wxPyCheckForApp()) SWIG_fail;
5675 PyThreadState* __tstate = wxPyBeginAllowThreads();
5676 result = (int)wxGetDisplayDepth();
5677
5678 wxPyEndAllowThreads(__tstate);
5679 if (PyErr_Occurred()) SWIG_fail;
5680 }
5681 {
5682 resultobj = SWIG_From_int(static_cast<int >(result));
5683 }
5684 return resultobj;
5685 fail:
5686 return NULL;
5687 }
5688
5689
5690 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5691 PyObject *resultobj = NULL;
5692 int *arg1 = (int *) 0 ;
5693 int *arg2 = (int *) 0 ;
5694 int temp1 ;
5695 int res1 = 0 ;
5696 int temp2 ;
5697 int res2 = 0 ;
5698 char *kwnames[] = {
5699 NULL
5700 };
5701
5702 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5703 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5705 {
5706 if (!wxPyCheckForApp()) SWIG_fail;
5707 PyThreadState* __tstate = wxPyBeginAllowThreads();
5708 wxDisplaySize(arg1,arg2);
5709
5710 wxPyEndAllowThreads(__tstate);
5711 if (PyErr_Occurred()) SWIG_fail;
5712 }
5713 Py_INCREF(Py_None); resultobj = Py_None;
5714 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5715 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5716 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5717 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5718 return resultobj;
5719 fail:
5720 return NULL;
5721 }
5722
5723
5724 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5725 PyObject *resultobj = NULL;
5726 wxSize result;
5727 char *kwnames[] = {
5728 NULL
5729 };
5730
5731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5732 {
5733 if (!wxPyCheckForApp()) SWIG_fail;
5734 PyThreadState* __tstate = wxPyBeginAllowThreads();
5735 result = wxGetDisplaySize();
5736
5737 wxPyEndAllowThreads(__tstate);
5738 if (PyErr_Occurred()) SWIG_fail;
5739 }
5740 {
5741 wxSize * resultptr;
5742 resultptr = new wxSize(static_cast<wxSize & >(result));
5743 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5744 }
5745 return resultobj;
5746 fail:
5747 return NULL;
5748 }
5749
5750
5751 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5752 PyObject *resultobj = NULL;
5753 int *arg1 = (int *) 0 ;
5754 int *arg2 = (int *) 0 ;
5755 int temp1 ;
5756 int res1 = 0 ;
5757 int temp2 ;
5758 int res2 = 0 ;
5759 char *kwnames[] = {
5760 NULL
5761 };
5762
5763 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5764 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5766 {
5767 if (!wxPyCheckForApp()) SWIG_fail;
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 wxDisplaySizeMM(arg1,arg2);
5770
5771 wxPyEndAllowThreads(__tstate);
5772 if (PyErr_Occurred()) SWIG_fail;
5773 }
5774 Py_INCREF(Py_None); resultobj = Py_None;
5775 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5776 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5777 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5778 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5779 return resultobj;
5780 fail:
5781 return NULL;
5782 }
5783
5784
5785 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5786 PyObject *resultobj = NULL;
5787 wxSize result;
5788 char *kwnames[] = {
5789 NULL
5790 };
5791
5792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5793 {
5794 if (!wxPyCheckForApp()) SWIG_fail;
5795 PyThreadState* __tstate = wxPyBeginAllowThreads();
5796 result = wxGetDisplaySizeMM();
5797
5798 wxPyEndAllowThreads(__tstate);
5799 if (PyErr_Occurred()) SWIG_fail;
5800 }
5801 {
5802 wxSize * resultptr;
5803 resultptr = new wxSize(static_cast<wxSize & >(result));
5804 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5805 }
5806 return resultobj;
5807 fail:
5808 return NULL;
5809 }
5810
5811
5812 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5813 PyObject *resultobj = NULL;
5814 int *arg1 = (int *) 0 ;
5815 int *arg2 = (int *) 0 ;
5816 int *arg3 = (int *) 0 ;
5817 int *arg4 = (int *) 0 ;
5818 int temp1 ;
5819 int res1 = 0 ;
5820 int temp2 ;
5821 int res2 = 0 ;
5822 int temp3 ;
5823 int res3 = 0 ;
5824 int temp4 ;
5825 int res4 = 0 ;
5826 char *kwnames[] = {
5827 NULL
5828 };
5829
5830 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5831 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5832 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5833 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5835 {
5836 if (!wxPyCheckForApp()) SWIG_fail;
5837 PyThreadState* __tstate = wxPyBeginAllowThreads();
5838 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5839
5840 wxPyEndAllowThreads(__tstate);
5841 if (PyErr_Occurred()) SWIG_fail;
5842 }
5843 Py_INCREF(Py_None); resultobj = Py_None;
5844 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5845 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5846 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5847 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5848 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5849 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5850 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5851 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5852 return resultobj;
5853 fail:
5854 return NULL;
5855 }
5856
5857
5858 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5859 PyObject *resultobj = NULL;
5860 wxRect result;
5861 char *kwnames[] = {
5862 NULL
5863 };
5864
5865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5866 {
5867 if (!wxPyCheckForApp()) SWIG_fail;
5868 PyThreadState* __tstate = wxPyBeginAllowThreads();
5869 result = wxGetClientDisplayRect();
5870
5871 wxPyEndAllowThreads(__tstate);
5872 if (PyErr_Occurred()) SWIG_fail;
5873 }
5874 {
5875 wxRect * resultptr;
5876 resultptr = new wxRect(static_cast<wxRect & >(result));
5877 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5878 }
5879 return resultobj;
5880 fail:
5881 return NULL;
5882 }
5883
5884
5885 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5886 PyObject *resultobj = NULL;
5887 wxCursor *arg1 = 0 ;
5888 PyObject * obj0 = 0 ;
5889 char *kwnames[] = {
5890 (char *) "cursor", NULL
5891 };
5892
5893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5894 {
5895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5896 if (SWIG_arg_fail(1)) SWIG_fail;
5897 if (arg1 == NULL) {
5898 SWIG_null_ref("wxCursor");
5899 }
5900 if (SWIG_arg_fail(1)) SWIG_fail;
5901 }
5902 {
5903 if (!wxPyCheckForApp()) SWIG_fail;
5904 PyThreadState* __tstate = wxPyBeginAllowThreads();
5905 wxSetCursor(*arg1);
5906
5907 wxPyEndAllowThreads(__tstate);
5908 if (PyErr_Occurred()) SWIG_fail;
5909 }
5910 Py_INCREF(Py_None); resultobj = Py_None;
5911 return resultobj;
5912 fail:
5913 return NULL;
5914 }
5915
5916
5917 static PyObject *_wrap_GetXDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5918 PyObject *resultobj = NULL;
5919 void *result;
5920 char *kwnames[] = {
5921 NULL
5922 };
5923
5924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetXDisplay",kwnames)) goto fail;
5925 {
5926 if (!wxPyCheckForApp()) SWIG_fail;
5927 PyThreadState* __tstate = wxPyBeginAllowThreads();
5928 result = (void *)wxGetXDisplay();
5929
5930 wxPyEndAllowThreads(__tstate);
5931 if (PyErr_Occurred()) SWIG_fail;
5932 }
5933 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
5934 return resultobj;
5935 fail:
5936 return NULL;
5937 }
5938
5939
5940 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5941 PyObject *resultobj = NULL;
5942 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5943 PyObject * obj0 = 0 ;
5944 char *kwnames[] = {
5945 (char *) "cursor", NULL
5946 };
5947
5948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5949 if (obj0) {
5950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5951 if (SWIG_arg_fail(1)) SWIG_fail;
5952 }
5953 {
5954 if (!wxPyCheckForApp()) SWIG_fail;
5955 PyThreadState* __tstate = wxPyBeginAllowThreads();
5956 wxBeginBusyCursor(arg1);
5957
5958 wxPyEndAllowThreads(__tstate);
5959 if (PyErr_Occurred()) SWIG_fail;
5960 }
5961 Py_INCREF(Py_None); resultobj = Py_None;
5962 return resultobj;
5963 fail:
5964 return NULL;
5965 }
5966
5967
5968 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
5969 PyObject *resultobj = NULL;
5970 wxPoint result;
5971 char *kwnames[] = {
5972 NULL
5973 };
5974
5975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
5976 {
5977 if (!wxPyCheckForApp()) SWIG_fail;
5978 PyThreadState* __tstate = wxPyBeginAllowThreads();
5979 result = wxGetMousePosition();
5980
5981 wxPyEndAllowThreads(__tstate);
5982 if (PyErr_Occurred()) SWIG_fail;
5983 }
5984 {
5985 wxPoint * resultptr;
5986 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5987 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5988 }
5989 return resultobj;
5990 fail:
5991 return NULL;
5992 }
5993
5994
5995 static PyObject *_wrap_FindWindowAtPointer(PyObject *, PyObject *args, PyObject *kwargs) {
5996 PyObject *resultobj = NULL;
5997 wxWindow *result;
5998 char *kwnames[] = {
5999 NULL
6000 };
6001
6002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FindWindowAtPointer",kwnames)) goto fail;
6003 {
6004 if (!wxPyCheckForApp()) SWIG_fail;
6005 PyThreadState* __tstate = wxPyBeginAllowThreads();
6006 result = (wxWindow *)FindWindowAtPointer();
6007
6008 wxPyEndAllowThreads(__tstate);
6009 if (PyErr_Occurred()) SWIG_fail;
6010 }
6011 {
6012 resultobj = wxPyMake_wxObject(result, 0);
6013 }
6014 return resultobj;
6015 fail:
6016 return NULL;
6017 }
6018
6019
6020 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6021 PyObject *resultobj = NULL;
6022 wxWindow *result;
6023 char *kwnames[] = {
6024 NULL
6025 };
6026
6027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
6028 {
6029 if (!wxPyCheckForApp()) SWIG_fail;
6030 PyThreadState* __tstate = wxPyBeginAllowThreads();
6031 result = (wxWindow *)wxGetActiveWindow();
6032
6033 wxPyEndAllowThreads(__tstate);
6034 if (PyErr_Occurred()) SWIG_fail;
6035 }
6036 {
6037 resultobj = wxPyMake_wxObject(result, 0);
6038 }
6039 return resultobj;
6040 fail:
6041 return NULL;
6042 }
6043
6044
6045 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6046 PyObject *resultobj = NULL;
6047 wxPoint *arg1 = 0 ;
6048 wxWindow *result;
6049 wxPoint temp1 ;
6050 PyObject * obj0 = 0 ;
6051 char *kwnames[] = {
6052 (char *) "pt", NULL
6053 };
6054
6055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
6056 {
6057 arg1 = &temp1;
6058 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6059 }
6060 {
6061 if (!wxPyCheckForApp()) SWIG_fail;
6062 PyThreadState* __tstate = wxPyBeginAllowThreads();
6063 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6064
6065 wxPyEndAllowThreads(__tstate);
6066 if (PyErr_Occurred()) SWIG_fail;
6067 }
6068 {
6069 resultobj = wxPyMake_wxObject(result, 0);
6070 }
6071 return resultobj;
6072 fail:
6073 return NULL;
6074 }
6075
6076
6077 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6078 PyObject *resultobj = NULL;
6079 wxPoint *arg1 = 0 ;
6080 wxWindow *result;
6081 wxPoint temp1 ;
6082 PyObject * obj0 = 0 ;
6083 char *kwnames[] = {
6084 (char *) "pt", NULL
6085 };
6086
6087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
6088 {
6089 arg1 = &temp1;
6090 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6091 }
6092 {
6093 if (!wxPyCheckForApp()) SWIG_fail;
6094 PyThreadState* __tstate = wxPyBeginAllowThreads();
6095 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6096
6097 wxPyEndAllowThreads(__tstate);
6098 if (PyErr_Occurred()) SWIG_fail;
6099 }
6100 {
6101 resultobj = wxPyMake_wxObject(result, 0);
6102 }
6103 return resultobj;
6104 fail:
6105 return NULL;
6106 }
6107
6108
6109 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
6110 PyObject *resultobj = NULL;
6111 wxWindow *arg1 = (wxWindow *) 0 ;
6112 wxWindow *result;
6113 PyObject * obj0 = 0 ;
6114 char *kwnames[] = {
6115 (char *) "win", NULL
6116 };
6117
6118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
6119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6120 if (SWIG_arg_fail(1)) SWIG_fail;
6121 {
6122 if (!wxPyCheckForApp()) SWIG_fail;
6123 PyThreadState* __tstate = wxPyBeginAllowThreads();
6124 result = (wxWindow *)wxGetTopLevelParent(arg1);
6125
6126 wxPyEndAllowThreads(__tstate);
6127 if (PyErr_Occurred()) SWIG_fail;
6128 }
6129 {
6130 resultobj = wxPyMake_wxObject(result, 0);
6131 }
6132 return resultobj;
6133 fail:
6134 return NULL;
6135 }
6136
6137
6138 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6139 PyObject *resultobj = NULL;
6140 wxString *arg1 = 0 ;
6141 bool result;
6142 bool temp1 = false ;
6143 PyObject * obj0 = 0 ;
6144 char *kwnames[] = {
6145 (char *) "url", NULL
6146 };
6147
6148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6149 {
6150 arg1 = wxString_in_helper(obj0);
6151 if (arg1 == NULL) SWIG_fail;
6152 temp1 = true;
6153 }
6154 {
6155 PyThreadState* __tstate = wxPyBeginAllowThreads();
6156 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6157
6158 wxPyEndAllowThreads(__tstate);
6159 if (PyErr_Occurred()) SWIG_fail;
6160 }
6161 {
6162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6163 }
6164 {
6165 if (temp1)
6166 delete arg1;
6167 }
6168 return resultobj;
6169 fail:
6170 {
6171 if (temp1)
6172 delete arg1;
6173 }
6174 return NULL;
6175 }
6176
6177
6178 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6179 PyObject *resultobj = NULL;
6180 wxKeyCode arg1 ;
6181 bool result;
6182 PyObject * obj0 = 0 ;
6183 char *kwnames[] = {
6184 (char *) "key", NULL
6185 };
6186
6187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6188 {
6189 arg1 = static_cast<wxKeyCode >(SWIG_As_int(obj0));
6190 if (SWIG_arg_fail(1)) SWIG_fail;
6191 }
6192 {
6193 if (!wxPyCheckForApp()) SWIG_fail;
6194 PyThreadState* __tstate = wxPyBeginAllowThreads();
6195 result = (bool)wxGetKeyState(arg1);
6196
6197 wxPyEndAllowThreads(__tstate);
6198 if (PyErr_Occurred()) SWIG_fail;
6199 }
6200 {
6201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6202 }
6203 return resultobj;
6204 fail:
6205 return NULL;
6206 }
6207
6208
6209 static PyObject *_wrap_new_MouseState(PyObject *, PyObject *args, PyObject *kwargs) {
6210 PyObject *resultobj = NULL;
6211 wxMouseState *result;
6212 char *kwnames[] = {
6213 NULL
6214 };
6215
6216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MouseState",kwnames)) goto fail;
6217 {
6218 PyThreadState* __tstate = wxPyBeginAllowThreads();
6219 result = (wxMouseState *)new wxMouseState();
6220
6221 wxPyEndAllowThreads(__tstate);
6222 if (PyErr_Occurred()) SWIG_fail;
6223 }
6224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseState, 1);
6225 return resultobj;
6226 fail:
6227 return NULL;
6228 }
6229
6230
6231 static PyObject *_wrap_delete_MouseState(PyObject *, PyObject *args, PyObject *kwargs) {
6232 PyObject *resultobj = NULL;
6233 wxMouseState *arg1 = (wxMouseState *) 0 ;
6234 PyObject * obj0 = 0 ;
6235 char *kwnames[] = {
6236 (char *) "self", NULL
6237 };
6238
6239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MouseState",kwnames,&obj0)) goto fail;
6240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6241 if (SWIG_arg_fail(1)) SWIG_fail;
6242 {
6243 PyThreadState* __tstate = wxPyBeginAllowThreads();
6244 delete arg1;
6245
6246 wxPyEndAllowThreads(__tstate);
6247 if (PyErr_Occurred()) SWIG_fail;
6248 }
6249 Py_INCREF(Py_None); resultobj = Py_None;
6250 return resultobj;
6251 fail:
6252 return NULL;
6253 }
6254
6255
6256 static PyObject *_wrap_MouseState_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
6257 PyObject *resultobj = NULL;
6258 wxMouseState *arg1 = (wxMouseState *) 0 ;
6259 int result;
6260 PyObject * obj0 = 0 ;
6261 char *kwnames[] = {
6262 (char *) "self", NULL
6263 };
6264
6265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_GetX",kwnames,&obj0)) goto fail;
6266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6267 if (SWIG_arg_fail(1)) SWIG_fail;
6268 {
6269 PyThreadState* __tstate = wxPyBeginAllowThreads();
6270 result = (int)(arg1)->GetX();
6271
6272 wxPyEndAllowThreads(__tstate);
6273 if (PyErr_Occurred()) SWIG_fail;
6274 }
6275 {
6276 resultobj = SWIG_From_int(static_cast<int >(result));
6277 }
6278 return resultobj;
6279 fail:
6280 return NULL;
6281 }
6282
6283
6284 static PyObject *_wrap_MouseState_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
6285 PyObject *resultobj = NULL;
6286 wxMouseState *arg1 = (wxMouseState *) 0 ;
6287 int result;
6288 PyObject * obj0 = 0 ;
6289 char *kwnames[] = {
6290 (char *) "self", NULL
6291 };
6292
6293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_GetY",kwnames,&obj0)) goto fail;
6294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6295 if (SWIG_arg_fail(1)) SWIG_fail;
6296 {
6297 PyThreadState* __tstate = wxPyBeginAllowThreads();
6298 result = (int)(arg1)->GetY();
6299
6300 wxPyEndAllowThreads(__tstate);
6301 if (PyErr_Occurred()) SWIG_fail;
6302 }
6303 {
6304 resultobj = SWIG_From_int(static_cast<int >(result));
6305 }
6306 return resultobj;
6307 fail:
6308 return NULL;
6309 }
6310
6311
6312 static PyObject *_wrap_MouseState_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
6313 PyObject *resultobj = NULL;
6314 wxMouseState *arg1 = (wxMouseState *) 0 ;
6315 bool result;
6316 PyObject * obj0 = 0 ;
6317 char *kwnames[] = {
6318 (char *) "self", NULL
6319 };
6320
6321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_LeftDown",kwnames,&obj0)) goto fail;
6322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6323 if (SWIG_arg_fail(1)) SWIG_fail;
6324 {
6325 PyThreadState* __tstate = wxPyBeginAllowThreads();
6326 result = (bool)(arg1)->LeftDown();
6327
6328 wxPyEndAllowThreads(__tstate);
6329 if (PyErr_Occurred()) SWIG_fail;
6330 }
6331 {
6332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6333 }
6334 return resultobj;
6335 fail:
6336 return NULL;
6337 }
6338
6339
6340 static PyObject *_wrap_MouseState_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
6341 PyObject *resultobj = NULL;
6342 wxMouseState *arg1 = (wxMouseState *) 0 ;
6343 bool result;
6344 PyObject * obj0 = 0 ;
6345 char *kwnames[] = {
6346 (char *) "self", NULL
6347 };
6348
6349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_MiddleDown",kwnames,&obj0)) goto fail;
6350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6351 if (SWIG_arg_fail(1)) SWIG_fail;
6352 {
6353 PyThreadState* __tstate = wxPyBeginAllowThreads();
6354 result = (bool)(arg1)->MiddleDown();
6355
6356 wxPyEndAllowThreads(__tstate);
6357 if (PyErr_Occurred()) SWIG_fail;
6358 }
6359 {
6360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6361 }
6362 return resultobj;
6363 fail:
6364 return NULL;
6365 }
6366
6367
6368 static PyObject *_wrap_MouseState_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
6369 PyObject *resultobj = NULL;
6370 wxMouseState *arg1 = (wxMouseState *) 0 ;
6371 bool result;
6372 PyObject * obj0 = 0 ;
6373 char *kwnames[] = {
6374 (char *) "self", NULL
6375 };
6376
6377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_RightDown",kwnames,&obj0)) goto fail;
6378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6379 if (SWIG_arg_fail(1)) SWIG_fail;
6380 {
6381 PyThreadState* __tstate = wxPyBeginAllowThreads();
6382 result = (bool)(arg1)->RightDown();
6383
6384 wxPyEndAllowThreads(__tstate);
6385 if (PyErr_Occurred()) SWIG_fail;
6386 }
6387 {
6388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6389 }
6390 return resultobj;
6391 fail:
6392 return NULL;
6393 }
6394
6395
6396 static PyObject *_wrap_MouseState_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
6397 PyObject *resultobj = NULL;
6398 wxMouseState *arg1 = (wxMouseState *) 0 ;
6399 bool result;
6400 PyObject * obj0 = 0 ;
6401 char *kwnames[] = {
6402 (char *) "self", NULL
6403 };
6404
6405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_ControlDown",kwnames,&obj0)) goto fail;
6406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6407 if (SWIG_arg_fail(1)) SWIG_fail;
6408 {
6409 PyThreadState* __tstate = wxPyBeginAllowThreads();
6410 result = (bool)(arg1)->ControlDown();
6411
6412 wxPyEndAllowThreads(__tstate);
6413 if (PyErr_Occurred()) SWIG_fail;
6414 }
6415 {
6416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6417 }
6418 return resultobj;
6419 fail:
6420 return NULL;
6421 }
6422
6423
6424 static PyObject *_wrap_MouseState_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
6425 PyObject *resultobj = NULL;
6426 wxMouseState *arg1 = (wxMouseState *) 0 ;
6427 bool result;
6428 PyObject * obj0 = 0 ;
6429 char *kwnames[] = {
6430 (char *) "self", NULL
6431 };
6432
6433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_ShiftDown",kwnames,&obj0)) goto fail;
6434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6435 if (SWIG_arg_fail(1)) SWIG_fail;
6436 {
6437 PyThreadState* __tstate = wxPyBeginAllowThreads();
6438 result = (bool)(arg1)->ShiftDown();
6439
6440 wxPyEndAllowThreads(__tstate);
6441 if (PyErr_Occurred()) SWIG_fail;
6442 }
6443 {
6444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6445 }
6446 return resultobj;
6447 fail:
6448 return NULL;
6449 }
6450
6451
6452 static PyObject *_wrap_MouseState_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
6453 PyObject *resultobj = NULL;
6454 wxMouseState *arg1 = (wxMouseState *) 0 ;
6455 bool result;
6456 PyObject * obj0 = 0 ;
6457 char *kwnames[] = {
6458 (char *) "self", NULL
6459 };
6460
6461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_AltDown",kwnames,&obj0)) goto fail;
6462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6463 if (SWIG_arg_fail(1)) SWIG_fail;
6464 {
6465 PyThreadState* __tstate = wxPyBeginAllowThreads();
6466 result = (bool)(arg1)->AltDown();
6467
6468 wxPyEndAllowThreads(__tstate);
6469 if (PyErr_Occurred()) SWIG_fail;
6470 }
6471 {
6472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6473 }
6474 return resultobj;
6475 fail:
6476 return NULL;
6477 }
6478
6479
6480 static PyObject *_wrap_MouseState_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
6481 PyObject *resultobj = NULL;
6482 wxMouseState *arg1 = (wxMouseState *) 0 ;
6483 bool result;
6484 PyObject * obj0 = 0 ;
6485 char *kwnames[] = {
6486 (char *) "self", NULL
6487 };
6488
6489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_MetaDown",kwnames,&obj0)) goto fail;
6490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6491 if (SWIG_arg_fail(1)) SWIG_fail;
6492 {
6493 PyThreadState* __tstate = wxPyBeginAllowThreads();
6494 result = (bool)(arg1)->MetaDown();
6495
6496 wxPyEndAllowThreads(__tstate);
6497 if (PyErr_Occurred()) SWIG_fail;
6498 }
6499 {
6500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6501 }
6502 return resultobj;
6503 fail:
6504 return NULL;
6505 }
6506
6507
6508 static PyObject *_wrap_MouseState_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
6509 PyObject *resultobj = NULL;
6510 wxMouseState *arg1 = (wxMouseState *) 0 ;
6511 bool result;
6512 PyObject * obj0 = 0 ;
6513 char *kwnames[] = {
6514 (char *) "self", NULL
6515 };
6516
6517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_CmdDown",kwnames,&obj0)) goto fail;
6518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6519 if (SWIG_arg_fail(1)) SWIG_fail;
6520 {
6521 PyThreadState* __tstate = wxPyBeginAllowThreads();
6522 result = (bool)(arg1)->CmdDown();
6523
6524 wxPyEndAllowThreads(__tstate);
6525 if (PyErr_Occurred()) SWIG_fail;
6526 }
6527 {
6528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6529 }
6530 return resultobj;
6531 fail:
6532 return NULL;
6533 }
6534
6535
6536 static PyObject *_wrap_MouseState_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
6537 PyObject *resultobj = NULL;
6538 wxMouseState *arg1 = (wxMouseState *) 0 ;
6539 int arg2 ;
6540 PyObject * obj0 = 0 ;
6541 PyObject * obj1 = 0 ;
6542 char *kwnames[] = {
6543 (char *) "self",(char *) "x", NULL
6544 };
6545
6546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) goto fail;
6547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6548 if (SWIG_arg_fail(1)) SWIG_fail;
6549 {
6550 arg2 = static_cast<int >(SWIG_As_int(obj1));
6551 if (SWIG_arg_fail(2)) SWIG_fail;
6552 }
6553 {
6554 PyThreadState* __tstate = wxPyBeginAllowThreads();
6555 (arg1)->SetX(arg2);
6556
6557 wxPyEndAllowThreads(__tstate);
6558 if (PyErr_Occurred()) SWIG_fail;
6559 }
6560 Py_INCREF(Py_None); resultobj = Py_None;
6561 return resultobj;
6562 fail:
6563 return NULL;
6564 }
6565
6566
6567 static PyObject *_wrap_MouseState_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
6568 PyObject *resultobj = NULL;
6569 wxMouseState *arg1 = (wxMouseState *) 0 ;
6570 int arg2 ;
6571 PyObject * obj0 = 0 ;
6572 PyObject * obj1 = 0 ;
6573 char *kwnames[] = {
6574 (char *) "self",(char *) "y", NULL
6575 };
6576
6577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) goto fail;
6578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6579 if (SWIG_arg_fail(1)) SWIG_fail;
6580 {
6581 arg2 = static_cast<int >(SWIG_As_int(obj1));
6582 if (SWIG_arg_fail(2)) SWIG_fail;
6583 }
6584 {
6585 PyThreadState* __tstate = wxPyBeginAllowThreads();
6586 (arg1)->SetY(arg2);
6587
6588 wxPyEndAllowThreads(__tstate);
6589 if (PyErr_Occurred()) SWIG_fail;
6590 }
6591 Py_INCREF(Py_None); resultobj = Py_None;
6592 return resultobj;
6593 fail:
6594 return NULL;
6595 }
6596
6597
6598 static PyObject *_wrap_MouseState_SetLeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
6599 PyObject *resultobj = NULL;
6600 wxMouseState *arg1 = (wxMouseState *) 0 ;
6601 bool arg2 ;
6602 PyObject * obj0 = 0 ;
6603 PyObject * obj1 = 0 ;
6604 char *kwnames[] = {
6605 (char *) "self",(char *) "down", NULL
6606 };
6607
6608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) goto fail;
6609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6610 if (SWIG_arg_fail(1)) SWIG_fail;
6611 {
6612 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6613 if (SWIG_arg_fail(2)) SWIG_fail;
6614 }
6615 {
6616 PyThreadState* __tstate = wxPyBeginAllowThreads();
6617 (arg1)->SetLeftDown(arg2);
6618
6619 wxPyEndAllowThreads(__tstate);
6620 if (PyErr_Occurred()) SWIG_fail;
6621 }
6622 Py_INCREF(Py_None); resultobj = Py_None;
6623 return resultobj;
6624 fail:
6625 return NULL;
6626 }
6627
6628
6629 static PyObject *_wrap_MouseState_SetMiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
6630 PyObject *resultobj = NULL;
6631 wxMouseState *arg1 = (wxMouseState *) 0 ;
6632 bool arg2 ;
6633 PyObject * obj0 = 0 ;
6634 PyObject * obj1 = 0 ;
6635 char *kwnames[] = {
6636 (char *) "self",(char *) "down", NULL
6637 };
6638
6639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) goto fail;
6640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6641 if (SWIG_arg_fail(1)) SWIG_fail;
6642 {
6643 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6644 if (SWIG_arg_fail(2)) SWIG_fail;
6645 }
6646 {
6647 PyThreadState* __tstate = wxPyBeginAllowThreads();
6648 (arg1)->SetMiddleDown(arg2);
6649
6650 wxPyEndAllowThreads(__tstate);
6651 if (PyErr_Occurred()) SWIG_fail;
6652 }
6653 Py_INCREF(Py_None); resultobj = Py_None;
6654 return resultobj;
6655 fail:
6656 return NULL;
6657 }
6658
6659
6660 static PyObject *_wrap_MouseState_SetRightDown(PyObject *, PyObject *args, PyObject *kwargs) {
6661 PyObject *resultobj = NULL;
6662 wxMouseState *arg1 = (wxMouseState *) 0 ;
6663 bool arg2 ;
6664 PyObject * obj0 = 0 ;
6665 PyObject * obj1 = 0 ;
6666 char *kwnames[] = {
6667 (char *) "self",(char *) "down", NULL
6668 };
6669
6670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) goto fail;
6671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6672 if (SWIG_arg_fail(1)) SWIG_fail;
6673 {
6674 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6675 if (SWIG_arg_fail(2)) SWIG_fail;
6676 }
6677 {
6678 PyThreadState* __tstate = wxPyBeginAllowThreads();
6679 (arg1)->SetRightDown(arg2);
6680
6681 wxPyEndAllowThreads(__tstate);
6682 if (PyErr_Occurred()) SWIG_fail;
6683 }
6684 Py_INCREF(Py_None); resultobj = Py_None;
6685 return resultobj;
6686 fail:
6687 return NULL;
6688 }
6689
6690
6691 static PyObject *_wrap_MouseState_SetControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
6692 PyObject *resultobj = NULL;
6693 wxMouseState *arg1 = (wxMouseState *) 0 ;
6694 bool arg2 ;
6695 PyObject * obj0 = 0 ;
6696 PyObject * obj1 = 0 ;
6697 char *kwnames[] = {
6698 (char *) "self",(char *) "down", NULL
6699 };
6700
6701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) goto fail;
6702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6703 if (SWIG_arg_fail(1)) SWIG_fail;
6704 {
6705 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6706 if (SWIG_arg_fail(2)) SWIG_fail;
6707 }
6708 {
6709 PyThreadState* __tstate = wxPyBeginAllowThreads();
6710 (arg1)->SetControlDown(arg2);
6711
6712 wxPyEndAllowThreads(__tstate);
6713 if (PyErr_Occurred()) SWIG_fail;
6714 }
6715 Py_INCREF(Py_None); resultobj = Py_None;
6716 return resultobj;
6717 fail:
6718 return NULL;
6719 }
6720
6721
6722 static PyObject *_wrap_MouseState_SetShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
6723 PyObject *resultobj = NULL;
6724 wxMouseState *arg1 = (wxMouseState *) 0 ;
6725 bool arg2 ;
6726 PyObject * obj0 = 0 ;
6727 PyObject * obj1 = 0 ;
6728 char *kwnames[] = {
6729 (char *) "self",(char *) "down", NULL
6730 };
6731
6732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) goto fail;
6733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6734 if (SWIG_arg_fail(1)) SWIG_fail;
6735 {
6736 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6737 if (SWIG_arg_fail(2)) SWIG_fail;
6738 }
6739 {
6740 PyThreadState* __tstate = wxPyBeginAllowThreads();
6741 (arg1)->SetShiftDown(arg2);
6742
6743 wxPyEndAllowThreads(__tstate);
6744 if (PyErr_Occurred()) SWIG_fail;
6745 }
6746 Py_INCREF(Py_None); resultobj = Py_None;
6747 return resultobj;
6748 fail:
6749 return NULL;
6750 }
6751
6752
6753 static PyObject *_wrap_MouseState_SetAltDown(PyObject *, PyObject *args, PyObject *kwargs) {
6754 PyObject *resultobj = NULL;
6755 wxMouseState *arg1 = (wxMouseState *) 0 ;
6756 bool arg2 ;
6757 PyObject * obj0 = 0 ;
6758 PyObject * obj1 = 0 ;
6759 char *kwnames[] = {
6760 (char *) "self",(char *) "down", NULL
6761 };
6762
6763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) goto fail;
6764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6765 if (SWIG_arg_fail(1)) SWIG_fail;
6766 {
6767 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6768 if (SWIG_arg_fail(2)) SWIG_fail;
6769 }
6770 {
6771 PyThreadState* __tstate = wxPyBeginAllowThreads();
6772 (arg1)->SetAltDown(arg2);
6773
6774 wxPyEndAllowThreads(__tstate);
6775 if (PyErr_Occurred()) SWIG_fail;
6776 }
6777 Py_INCREF(Py_None); resultobj = Py_None;
6778 return resultobj;
6779 fail:
6780 return NULL;
6781 }
6782
6783
6784 static PyObject *_wrap_MouseState_SetMetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
6785 PyObject *resultobj = NULL;
6786 wxMouseState *arg1 = (wxMouseState *) 0 ;
6787 bool arg2 ;
6788 PyObject * obj0 = 0 ;
6789 PyObject * obj1 = 0 ;
6790 char *kwnames[] = {
6791 (char *) "self",(char *) "down", NULL
6792 };
6793
6794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) goto fail;
6795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6796 if (SWIG_arg_fail(1)) SWIG_fail;
6797 {
6798 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6799 if (SWIG_arg_fail(2)) SWIG_fail;
6800 }
6801 {
6802 PyThreadState* __tstate = wxPyBeginAllowThreads();
6803 (arg1)->SetMetaDown(arg2);
6804
6805 wxPyEndAllowThreads(__tstate);
6806 if (PyErr_Occurred()) SWIG_fail;
6807 }
6808 Py_INCREF(Py_None); resultobj = Py_None;
6809 return resultobj;
6810 fail:
6811 return NULL;
6812 }
6813
6814
6815 static PyObject * MouseState_swigregister(PyObject *, PyObject *args) {
6816 PyObject *obj;
6817 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6818 SWIG_TypeClientData(SWIGTYPE_p_wxMouseState, obj);
6819 Py_INCREF(obj);
6820 return Py_BuildValue((char *)"");
6821 }
6822 static PyObject *_wrap_GetMouseState(PyObject *, PyObject *args, PyObject *kwargs) {
6823 PyObject *resultobj = NULL;
6824 wxMouseState result;
6825 char *kwnames[] = {
6826 NULL
6827 };
6828
6829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMouseState",kwnames)) goto fail;
6830 {
6831 PyThreadState* __tstate = wxPyBeginAllowThreads();
6832 result = wxGetMouseState();
6833
6834 wxPyEndAllowThreads(__tstate);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 {
6838 wxMouseState * resultptr;
6839 resultptr = new wxMouseState(static_cast<wxMouseState & >(result));
6840 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMouseState, 1);
6841 }
6842 return resultobj;
6843 fail:
6844 return NULL;
6845 }
6846
6847
6848 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6849 PyObject *resultobj = NULL;
6850 char *kwnames[] = {
6851 NULL
6852 };
6853
6854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6855 {
6856 if (!wxPyCheckForApp()) SWIG_fail;
6857 PyThreadState* __tstate = wxPyBeginAllowThreads();
6858 wxWakeUpMainThread();
6859
6860 wxPyEndAllowThreads(__tstate);
6861 if (PyErr_Occurred()) SWIG_fail;
6862 }
6863 Py_INCREF(Py_None); resultobj = Py_None;
6864 return resultobj;
6865 fail:
6866 return NULL;
6867 }
6868
6869
6870 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6871 PyObject *resultobj = NULL;
6872 char *kwnames[] = {
6873 NULL
6874 };
6875
6876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6877 {
6878 if (!wxPyCheckForApp()) SWIG_fail;
6879 PyThreadState* __tstate = wxPyBeginAllowThreads();
6880 wxMutexGuiEnter();
6881
6882 wxPyEndAllowThreads(__tstate);
6883 if (PyErr_Occurred()) SWIG_fail;
6884 }
6885 Py_INCREF(Py_None); resultobj = Py_None;
6886 return resultobj;
6887 fail:
6888 return NULL;
6889 }
6890
6891
6892 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6893 PyObject *resultobj = NULL;
6894 char *kwnames[] = {
6895 NULL
6896 };
6897
6898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6899 {
6900 if (!wxPyCheckForApp()) SWIG_fail;
6901 PyThreadState* __tstate = wxPyBeginAllowThreads();
6902 wxMutexGuiLeave();
6903
6904 wxPyEndAllowThreads(__tstate);
6905 if (PyErr_Occurred()) SWIG_fail;
6906 }
6907 Py_INCREF(Py_None); resultobj = Py_None;
6908 return resultobj;
6909 fail:
6910 return NULL;
6911 }
6912
6913
6914 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6915 PyObject *resultobj = NULL;
6916 wxMutexGuiLocker *result;
6917 char *kwnames[] = {
6918 NULL
6919 };
6920
6921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6922 {
6923 if (!wxPyCheckForApp()) SWIG_fail;
6924 PyThreadState* __tstate = wxPyBeginAllowThreads();
6925 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6926
6927 wxPyEndAllowThreads(__tstate);
6928 if (PyErr_Occurred()) SWIG_fail;
6929 }
6930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6931 return resultobj;
6932 fail:
6933 return NULL;
6934 }
6935
6936
6937 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6938 PyObject *resultobj = NULL;
6939 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6940 PyObject * obj0 = 0 ;
6941 char *kwnames[] = {
6942 (char *) "self", NULL
6943 };
6944
6945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6947 if (SWIG_arg_fail(1)) SWIG_fail;
6948 {
6949 PyThreadState* __tstate = wxPyBeginAllowThreads();
6950 delete arg1;
6951
6952 wxPyEndAllowThreads(__tstate);
6953 if (PyErr_Occurred()) SWIG_fail;
6954 }
6955 Py_INCREF(Py_None); resultobj = Py_None;
6956 return resultobj;
6957 fail:
6958 return NULL;
6959 }
6960
6961
6962 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6963 PyObject *obj;
6964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6965 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6966 Py_INCREF(obj);
6967 return Py_BuildValue((char *)"");
6968 }
6969 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6970 PyObject *resultobj = NULL;
6971 bool result;
6972 char *kwnames[] = {
6973 NULL
6974 };
6975
6976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6977 {
6978 PyThreadState* __tstate = wxPyBeginAllowThreads();
6979 result = (bool)wxThread_IsMain();
6980
6981 wxPyEndAllowThreads(__tstate);
6982 if (PyErr_Occurred()) SWIG_fail;
6983 }
6984 {
6985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6986 }
6987 return resultobj;
6988 fail:
6989 return NULL;
6990 }
6991
6992
6993 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6994 PyObject *resultobj = NULL;
6995 wxString *arg1 = 0 ;
6996 wxToolTip *result;
6997 bool temp1 = false ;
6998 PyObject * obj0 = 0 ;
6999 char *kwnames[] = {
7000 (char *) "tip", NULL
7001 };
7002
7003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
7004 {
7005 arg1 = wxString_in_helper(obj0);
7006 if (arg1 == NULL) SWIG_fail;
7007 temp1 = true;
7008 }
7009 {
7010 if (!wxPyCheckForApp()) SWIG_fail;
7011 PyThreadState* __tstate = wxPyBeginAllowThreads();
7012 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7013
7014 wxPyEndAllowThreads(__tstate);
7015 if (PyErr_Occurred()) SWIG_fail;
7016 }
7017 {
7018 resultobj = wxPyMake_wxObject(result, 1);
7019 }
7020 {
7021 if (temp1)
7022 delete arg1;
7023 }
7024 return resultobj;
7025 fail:
7026 {
7027 if (temp1)
7028 delete arg1;
7029 }
7030 return NULL;
7031 }
7032
7033
7034 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7035 PyObject *resultobj = NULL;
7036 wxToolTip *arg1 = (wxToolTip *) 0 ;
7037 wxString *arg2 = 0 ;
7038 bool temp2 = false ;
7039 PyObject * obj0 = 0 ;
7040 PyObject * obj1 = 0 ;
7041 char *kwnames[] = {
7042 (char *) "self",(char *) "tip", NULL
7043 };
7044
7045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
7046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
7047 if (SWIG_arg_fail(1)) SWIG_fail;
7048 {
7049 arg2 = wxString_in_helper(obj1);
7050 if (arg2 == NULL) SWIG_fail;
7051 temp2 = true;
7052 }
7053 {
7054 PyThreadState* __tstate = wxPyBeginAllowThreads();
7055 (arg1)->SetTip((wxString const &)*arg2);
7056
7057 wxPyEndAllowThreads(__tstate);
7058 if (PyErr_Occurred()) SWIG_fail;
7059 }
7060 Py_INCREF(Py_None); resultobj = Py_None;
7061 {
7062 if (temp2)
7063 delete arg2;
7064 }
7065 return resultobj;
7066 fail:
7067 {
7068 if (temp2)
7069 delete arg2;
7070 }
7071 return NULL;
7072 }
7073
7074
7075 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7076 PyObject *resultobj = NULL;
7077 wxToolTip *arg1 = (wxToolTip *) 0 ;
7078 wxString result;
7079 PyObject * obj0 = 0 ;
7080 char *kwnames[] = {
7081 (char *) "self", NULL
7082 };
7083
7084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
7085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
7086 if (SWIG_arg_fail(1)) SWIG_fail;
7087 {
7088 PyThreadState* __tstate = wxPyBeginAllowThreads();
7089 result = (arg1)->GetTip();
7090
7091 wxPyEndAllowThreads(__tstate);
7092 if (PyErr_Occurred()) SWIG_fail;
7093 }
7094 {
7095 #if wxUSE_UNICODE
7096 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7097 #else
7098 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7099 #endif
7100 }
7101 return resultobj;
7102 fail:
7103 return NULL;
7104 }
7105
7106
7107 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7108 PyObject *resultobj = NULL;
7109 wxToolTip *arg1 = (wxToolTip *) 0 ;
7110 wxWindow *result;
7111 PyObject * obj0 = 0 ;
7112 char *kwnames[] = {
7113 (char *) "self", NULL
7114 };
7115
7116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
7117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
7118 if (SWIG_arg_fail(1)) SWIG_fail;
7119 {
7120 PyThreadState* __tstate = wxPyBeginAllowThreads();
7121 result = (wxWindow *)(arg1)->GetWindow();
7122
7123 wxPyEndAllowThreads(__tstate);
7124 if (PyErr_Occurred()) SWIG_fail;
7125 }
7126 {
7127 resultobj = wxPyMake_wxObject(result, 0);
7128 }
7129 return resultobj;
7130 fail:
7131 return NULL;
7132 }
7133
7134
7135 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
7136 PyObject *resultobj = NULL;
7137 bool arg1 ;
7138 PyObject * obj0 = 0 ;
7139 char *kwnames[] = {
7140 (char *) "flag", NULL
7141 };
7142
7143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
7144 {
7145 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
7146 if (SWIG_arg_fail(1)) SWIG_fail;
7147 }
7148 {
7149 PyThreadState* __tstate = wxPyBeginAllowThreads();
7150 wxToolTip::Enable(arg1);
7151
7152 wxPyEndAllowThreads(__tstate);
7153 if (PyErr_Occurred()) SWIG_fail;
7154 }
7155 Py_INCREF(Py_None); resultobj = Py_None;
7156 return resultobj;
7157 fail:
7158 return NULL;
7159 }
7160
7161
7162 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
7163 PyObject *resultobj = NULL;
7164 long arg1 ;
7165 PyObject * obj0 = 0 ;
7166 char *kwnames[] = {
7167 (char *) "milliseconds", NULL
7168 };
7169
7170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
7171 {
7172 arg1 = static_cast<long >(SWIG_As_long(obj0));
7173 if (SWIG_arg_fail(1)) SWIG_fail;
7174 }
7175 {
7176 PyThreadState* __tstate = wxPyBeginAllowThreads();
7177 wxToolTip::SetDelay(arg1);
7178
7179 wxPyEndAllowThreads(__tstate);
7180 if (PyErr_Occurred()) SWIG_fail;
7181 }
7182 Py_INCREF(Py_None); resultobj = Py_None;
7183 return resultobj;
7184 fail:
7185 return NULL;
7186 }
7187
7188
7189 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
7190 PyObject *obj;
7191 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7192 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
7193 Py_INCREF(obj);
7194 return Py_BuildValue((char *)"");
7195 }
7196 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
7197 PyObject *resultobj = NULL;
7198 wxWindow *arg1 = (wxWindow *) 0 ;
7199 wxSize *arg2 = 0 ;
7200 wxCaret *result;
7201 wxSize temp2 ;
7202 PyObject * obj0 = 0 ;
7203 PyObject * obj1 = 0 ;
7204 char *kwnames[] = {
7205 (char *) "window",(char *) "size", NULL
7206 };
7207
7208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
7209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7210 if (SWIG_arg_fail(1)) SWIG_fail;
7211 {
7212 arg2 = &temp2;
7213 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
7214 }
7215 {
7216 if (!wxPyCheckForApp()) SWIG_fail;
7217 PyThreadState* __tstate = wxPyBeginAllowThreads();
7218 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
7219
7220 wxPyEndAllowThreads(__tstate);
7221 if (PyErr_Occurred()) SWIG_fail;
7222 }
7223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
7224 return resultobj;
7225 fail:
7226 return NULL;
7227 }
7228
7229
7230 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
7231 PyObject *resultobj = NULL;
7232 wxCaret *arg1 = (wxCaret *) 0 ;
7233 PyObject * obj0 = 0 ;
7234 char *kwnames[] = {
7235 (char *) "self", NULL
7236 };
7237
7238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
7239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7240 if (SWIG_arg_fail(1)) SWIG_fail;
7241 {
7242 PyThreadState* __tstate = wxPyBeginAllowThreads();
7243 wxCaret_Destroy(arg1);
7244
7245 wxPyEndAllowThreads(__tstate);
7246 if (PyErr_Occurred()) SWIG_fail;
7247 }
7248 Py_INCREF(Py_None); resultobj = Py_None;
7249 return resultobj;
7250 fail:
7251 return NULL;
7252 }
7253
7254
7255 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
7256 PyObject *resultobj = NULL;
7257 wxCaret *arg1 = (wxCaret *) 0 ;
7258 bool result;
7259 PyObject * obj0 = 0 ;
7260 char *kwnames[] = {
7261 (char *) "self", NULL
7262 };
7263
7264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
7265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7266 if (SWIG_arg_fail(1)) SWIG_fail;
7267 {
7268 PyThreadState* __tstate = wxPyBeginAllowThreads();
7269 result = (bool)(arg1)->IsOk();
7270
7271 wxPyEndAllowThreads(__tstate);
7272 if (PyErr_Occurred()) SWIG_fail;
7273 }
7274 {
7275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7276 }
7277 return resultobj;
7278 fail:
7279 return NULL;
7280 }
7281
7282
7283 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
7284 PyObject *resultobj = NULL;
7285 wxCaret *arg1 = (wxCaret *) 0 ;
7286 bool result;
7287 PyObject * obj0 = 0 ;
7288 char *kwnames[] = {
7289 (char *) "self", NULL
7290 };
7291
7292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
7293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7294 if (SWIG_arg_fail(1)) SWIG_fail;
7295 {
7296 PyThreadState* __tstate = wxPyBeginAllowThreads();
7297 result = (bool)(arg1)->IsVisible();
7298
7299 wxPyEndAllowThreads(__tstate);
7300 if (PyErr_Occurred()) SWIG_fail;
7301 }
7302 {
7303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7304 }
7305 return resultobj;
7306 fail:
7307 return NULL;
7308 }
7309
7310
7311 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
7312 PyObject *resultobj = NULL;
7313 wxCaret *arg1 = (wxCaret *) 0 ;
7314 wxPoint result;
7315 PyObject * obj0 = 0 ;
7316 char *kwnames[] = {
7317 (char *) "self", NULL
7318 };
7319
7320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
7321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7322 if (SWIG_arg_fail(1)) SWIG_fail;
7323 {
7324 PyThreadState* __tstate = wxPyBeginAllowThreads();
7325 result = (arg1)->GetPosition();
7326
7327 wxPyEndAllowThreads(__tstate);
7328 if (PyErr_Occurred()) SWIG_fail;
7329 }
7330 {
7331 wxPoint * resultptr;
7332 resultptr = new wxPoint(static_cast<wxPoint & >(result));
7333 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
7334 }
7335 return resultobj;
7336 fail:
7337 return NULL;
7338 }
7339
7340
7341 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
7342 PyObject *resultobj = NULL;
7343 wxCaret *arg1 = (wxCaret *) 0 ;
7344 int *arg2 = (int *) 0 ;
7345 int *arg3 = (int *) 0 ;
7346 int temp2 ;
7347 int res2 = 0 ;
7348 int temp3 ;
7349 int res3 = 0 ;
7350 PyObject * obj0 = 0 ;
7351 char *kwnames[] = {
7352 (char *) "self", NULL
7353 };
7354
7355 arg2 = &temp2; res2 = SWIG_NEWOBJ;
7356 arg3 = &temp3; res3 = SWIG_NEWOBJ;
7357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
7358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7359 if (SWIG_arg_fail(1)) SWIG_fail;
7360 {
7361 PyThreadState* __tstate = wxPyBeginAllowThreads();
7362 (arg1)->GetPosition(arg2,arg3);
7363
7364 wxPyEndAllowThreads(__tstate);
7365 if (PyErr_Occurred()) SWIG_fail;
7366 }
7367 Py_INCREF(Py_None); resultobj = Py_None;
7368 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
7369 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
7370 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
7371 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
7372 return resultobj;
7373 fail:
7374 return NULL;
7375 }
7376
7377
7378 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
7379 PyObject *resultobj = NULL;
7380 wxCaret *arg1 = (wxCaret *) 0 ;
7381 wxSize result;
7382 PyObject * obj0 = 0 ;
7383 char *kwnames[] = {
7384 (char *) "self", NULL
7385 };
7386
7387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
7388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7389 if (SWIG_arg_fail(1)) SWIG_fail;
7390 {
7391 PyThreadState* __tstate = wxPyBeginAllowThreads();
7392 result = (arg1)->GetSize();
7393
7394 wxPyEndAllowThreads(__tstate);
7395 if (PyErr_Occurred()) SWIG_fail;
7396 }
7397 {
7398 wxSize * resultptr;
7399 resultptr = new wxSize(static_cast<wxSize & >(result));
7400 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
7401 }
7402 return resultobj;
7403 fail:
7404 return NULL;
7405 }
7406
7407
7408 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
7409 PyObject *resultobj = NULL;
7410 wxCaret *arg1 = (wxCaret *) 0 ;
7411 int *arg2 = (int *) 0 ;
7412 int *arg3 = (int *) 0 ;
7413 int temp2 ;
7414 int res2 = 0 ;
7415 int temp3 ;
7416 int res3 = 0 ;
7417 PyObject * obj0 = 0 ;
7418 char *kwnames[] = {
7419 (char *) "self", NULL
7420 };
7421
7422 arg2 = &temp2; res2 = SWIG_NEWOBJ;
7423 arg3 = &temp3; res3 = SWIG_NEWOBJ;
7424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
7425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7426 if (SWIG_arg_fail(1)) SWIG_fail;
7427 {
7428 PyThreadState* __tstate = wxPyBeginAllowThreads();
7429 (arg1)->GetSize(arg2,arg3);
7430
7431 wxPyEndAllowThreads(__tstate);
7432 if (PyErr_Occurred()) SWIG_fail;
7433 }
7434 Py_INCREF(Py_None); resultobj = Py_None;
7435 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
7436 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
7437 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
7438 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
7439 return resultobj;
7440 fail:
7441 return NULL;
7442 }
7443
7444
7445 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7446 PyObject *resultobj = NULL;
7447 wxCaret *arg1 = (wxCaret *) 0 ;
7448 wxWindow *result;
7449 PyObject * obj0 = 0 ;
7450 char *kwnames[] = {
7451 (char *) "self", NULL
7452 };
7453
7454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
7455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7456 if (SWIG_arg_fail(1)) SWIG_fail;
7457 {
7458 PyThreadState* __tstate = wxPyBeginAllowThreads();
7459 result = (wxWindow *)(arg1)->GetWindow();
7460
7461 wxPyEndAllowThreads(__tstate);
7462 if (PyErr_Occurred()) SWIG_fail;
7463 }
7464 {
7465 resultobj = wxPyMake_wxObject(result, 0);
7466 }
7467 return resultobj;
7468 fail:
7469 return NULL;
7470 }
7471
7472
7473 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
7474 PyObject *resultobj = NULL;
7475 wxCaret *arg1 = (wxCaret *) 0 ;
7476 int arg2 ;
7477 int arg3 ;
7478 PyObject * obj0 = 0 ;
7479 PyObject * obj1 = 0 ;
7480 PyObject * obj2 = 0 ;
7481 char *kwnames[] = {
7482 (char *) "self",(char *) "x",(char *) "y", NULL
7483 };
7484
7485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
7486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7487 if (SWIG_arg_fail(1)) SWIG_fail;
7488 {
7489 arg2 = static_cast<int >(SWIG_As_int(obj1));
7490 if (SWIG_arg_fail(2)) SWIG_fail;
7491 }
7492 {
7493 arg3 = static_cast<int >(SWIG_As_int(obj2));
7494 if (SWIG_arg_fail(3)) SWIG_fail;
7495 }
7496 {
7497 PyThreadState* __tstate = wxPyBeginAllowThreads();
7498 (arg1)->Move(arg2,arg3);
7499
7500 wxPyEndAllowThreads(__tstate);
7501 if (PyErr_Occurred()) SWIG_fail;
7502 }
7503 Py_INCREF(Py_None); resultobj = Py_None;
7504 return resultobj;
7505 fail:
7506 return NULL;
7507 }
7508
7509
7510 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
7511 PyObject *resultobj = NULL;
7512 wxCaret *arg1 = (wxCaret *) 0 ;
7513 wxPoint *arg2 = 0 ;
7514 wxPoint temp2 ;
7515 PyObject * obj0 = 0 ;
7516 PyObject * obj1 = 0 ;
7517 char *kwnames[] = {
7518 (char *) "self",(char *) "pt", NULL
7519 };
7520
7521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
7522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7523 if (SWIG_arg_fail(1)) SWIG_fail;
7524 {
7525 arg2 = &temp2;
7526 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7527 }
7528 {
7529 PyThreadState* __tstate = wxPyBeginAllowThreads();
7530 (arg1)->Move((wxPoint const &)*arg2);
7531
7532 wxPyEndAllowThreads(__tstate);
7533 if (PyErr_Occurred()) SWIG_fail;
7534 }
7535 Py_INCREF(Py_None); resultobj = Py_None;
7536 return resultobj;
7537 fail:
7538 return NULL;
7539 }
7540
7541
7542 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
7543 PyObject *resultobj = NULL;
7544 wxCaret *arg1 = (wxCaret *) 0 ;
7545 int arg2 ;
7546 int arg3 ;
7547 PyObject * obj0 = 0 ;
7548 PyObject * obj1 = 0 ;
7549 PyObject * obj2 = 0 ;
7550 char *kwnames[] = {
7551 (char *) "self",(char *) "width",(char *) "height", NULL
7552 };
7553
7554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
7555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7556 if (SWIG_arg_fail(1)) SWIG_fail;
7557 {
7558 arg2 = static_cast<int >(SWIG_As_int(obj1));
7559 if (SWIG_arg_fail(2)) SWIG_fail;
7560 }
7561 {
7562 arg3 = static_cast<int >(SWIG_As_int(obj2));
7563 if (SWIG_arg_fail(3)) SWIG_fail;
7564 }
7565 {
7566 PyThreadState* __tstate = wxPyBeginAllowThreads();
7567 (arg1)->SetSize(arg2,arg3);
7568
7569 wxPyEndAllowThreads(__tstate);
7570 if (PyErr_Occurred()) SWIG_fail;
7571 }
7572 Py_INCREF(Py_None); resultobj = Py_None;
7573 return resultobj;
7574 fail:
7575 return NULL;
7576 }
7577
7578
7579 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
7580 PyObject *resultobj = NULL;
7581 wxCaret *arg1 = (wxCaret *) 0 ;
7582 wxSize *arg2 = 0 ;
7583 wxSize temp2 ;
7584 PyObject * obj0 = 0 ;
7585 PyObject * obj1 = 0 ;
7586 char *kwnames[] = {
7587 (char *) "self",(char *) "size", NULL
7588 };
7589
7590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
7591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7592 if (SWIG_arg_fail(1)) SWIG_fail;
7593 {
7594 arg2 = &temp2;
7595 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
7596 }
7597 {
7598 PyThreadState* __tstate = wxPyBeginAllowThreads();
7599 (arg1)->SetSize((wxSize const &)*arg2);
7600
7601 wxPyEndAllowThreads(__tstate);
7602 if (PyErr_Occurred()) SWIG_fail;
7603 }
7604 Py_INCREF(Py_None); resultobj = Py_None;
7605 return resultobj;
7606 fail:
7607 return NULL;
7608 }
7609
7610
7611 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
7612 PyObject *resultobj = NULL;
7613 wxCaret *arg1 = (wxCaret *) 0 ;
7614 int arg2 = (int) true ;
7615 PyObject * obj0 = 0 ;
7616 PyObject * obj1 = 0 ;
7617 char *kwnames[] = {
7618 (char *) "self",(char *) "show", NULL
7619 };
7620
7621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
7622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7623 if (SWIG_arg_fail(1)) SWIG_fail;
7624 if (obj1) {
7625 {
7626 arg2 = static_cast<int >(SWIG_As_int(obj1));
7627 if (SWIG_arg_fail(2)) SWIG_fail;
7628 }
7629 }
7630 {
7631 PyThreadState* __tstate = wxPyBeginAllowThreads();
7632 (arg1)->Show(arg2);
7633
7634 wxPyEndAllowThreads(__tstate);
7635 if (PyErr_Occurred()) SWIG_fail;
7636 }
7637 Py_INCREF(Py_None); resultobj = Py_None;
7638 return resultobj;
7639 fail:
7640 return NULL;
7641 }
7642
7643
7644 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
7645 PyObject *resultobj = NULL;
7646 wxCaret *arg1 = (wxCaret *) 0 ;
7647 PyObject * obj0 = 0 ;
7648 char *kwnames[] = {
7649 (char *) "self", NULL
7650 };
7651
7652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
7653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7654 if (SWIG_arg_fail(1)) SWIG_fail;
7655 {
7656 PyThreadState* __tstate = wxPyBeginAllowThreads();
7657 (arg1)->Hide();
7658
7659 wxPyEndAllowThreads(__tstate);
7660 if (PyErr_Occurred()) SWIG_fail;
7661 }
7662 Py_INCREF(Py_None); resultobj = Py_None;
7663 return resultobj;
7664 fail:
7665 return NULL;
7666 }
7667
7668
7669 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
7670 PyObject *resultobj = NULL;
7671 int result;
7672 char *kwnames[] = {
7673 NULL
7674 };
7675
7676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
7677 {
7678 PyThreadState* __tstate = wxPyBeginAllowThreads();
7679 result = (int)wxCaret::GetBlinkTime();
7680
7681 wxPyEndAllowThreads(__tstate);
7682 if (PyErr_Occurred()) SWIG_fail;
7683 }
7684 {
7685 resultobj = SWIG_From_int(static_cast<int >(result));
7686 }
7687 return resultobj;
7688 fail:
7689 return NULL;
7690 }
7691
7692
7693 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
7694 PyObject *resultobj = NULL;
7695 int arg1 ;
7696 PyObject * obj0 = 0 ;
7697 char *kwnames[] = {
7698 (char *) "milliseconds", NULL
7699 };
7700
7701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
7702 {
7703 arg1 = static_cast<int >(SWIG_As_int(obj0));
7704 if (SWIG_arg_fail(1)) SWIG_fail;
7705 }
7706 {
7707 PyThreadState* __tstate = wxPyBeginAllowThreads();
7708 wxCaret::SetBlinkTime(arg1);
7709
7710 wxPyEndAllowThreads(__tstate);
7711 if (PyErr_Occurred()) SWIG_fail;
7712 }
7713 Py_INCREF(Py_None); resultobj = Py_None;
7714 return resultobj;
7715 fail:
7716 return NULL;
7717 }
7718
7719
7720 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
7721 PyObject *obj;
7722 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7723 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
7724 Py_INCREF(obj);
7725 return Py_BuildValue((char *)"");
7726 }
7727 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7728 PyObject *resultobj = NULL;
7729 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7730 wxBusyCursor *result;
7731 PyObject * obj0 = 0 ;
7732 char *kwnames[] = {
7733 (char *) "cursor", NULL
7734 };
7735
7736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
7737 if (obj0) {
7738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
7739 if (SWIG_arg_fail(1)) SWIG_fail;
7740 }
7741 {
7742 if (!wxPyCheckForApp()) SWIG_fail;
7743 PyThreadState* __tstate = wxPyBeginAllowThreads();
7744 result = (wxBusyCursor *)new wxBusyCursor(arg1);
7745
7746 wxPyEndAllowThreads(__tstate);
7747 if (PyErr_Occurred()) SWIG_fail;
7748 }
7749 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
7750 return resultobj;
7751 fail:
7752 return NULL;
7753 }
7754
7755
7756 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7757 PyObject *resultobj = NULL;
7758 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
7759 PyObject * obj0 = 0 ;
7760 char *kwnames[] = {
7761 (char *) "self", NULL
7762 };
7763
7764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
7765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
7766 if (SWIG_arg_fail(1)) SWIG_fail;
7767 {
7768 PyThreadState* __tstate = wxPyBeginAllowThreads();
7769 delete arg1;
7770
7771 wxPyEndAllowThreads(__tstate);
7772 if (PyErr_Occurred()) SWIG_fail;
7773 }
7774 Py_INCREF(Py_None); resultobj = Py_None;
7775 return resultobj;
7776 fail:
7777 return NULL;
7778 }
7779
7780
7781 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7782 PyObject *obj;
7783 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7784 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7785 Py_INCREF(obj);
7786 return Py_BuildValue((char *)"");
7787 }
7788 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7789 PyObject *resultobj = NULL;
7790 wxWindow *arg1 = (wxWindow *) NULL ;
7791 wxWindowDisabler *result;
7792 PyObject * obj0 = 0 ;
7793 char *kwnames[] = {
7794 (char *) "winToSkip", NULL
7795 };
7796
7797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7798 if (obj0) {
7799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7800 if (SWIG_arg_fail(1)) SWIG_fail;
7801 }
7802 {
7803 if (!wxPyCheckForApp()) SWIG_fail;
7804 PyThreadState* __tstate = wxPyBeginAllowThreads();
7805 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7806
7807 wxPyEndAllowThreads(__tstate);
7808 if (PyErr_Occurred()) SWIG_fail;
7809 }
7810 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7811 return resultobj;
7812 fail:
7813 return NULL;
7814 }
7815
7816
7817 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7818 PyObject *resultobj = NULL;
7819 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7820 PyObject * obj0 = 0 ;
7821 char *kwnames[] = {
7822 (char *) "self", NULL
7823 };
7824
7825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7827 if (SWIG_arg_fail(1)) SWIG_fail;
7828 {
7829 PyThreadState* __tstate = wxPyBeginAllowThreads();
7830 delete arg1;
7831
7832 wxPyEndAllowThreads(__tstate);
7833 if (PyErr_Occurred()) SWIG_fail;
7834 }
7835 Py_INCREF(Py_None); resultobj = Py_None;
7836 return resultobj;
7837 fail:
7838 return NULL;
7839 }
7840
7841
7842 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7843 PyObject *obj;
7844 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7845 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7846 Py_INCREF(obj);
7847 return Py_BuildValue((char *)"");
7848 }
7849 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7850 PyObject *resultobj = NULL;
7851 wxString *arg1 = 0 ;
7852 wxBusyInfo *result;
7853 bool temp1 = false ;
7854 PyObject * obj0 = 0 ;
7855 char *kwnames[] = {
7856 (char *) "message", NULL
7857 };
7858
7859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7860 {
7861 arg1 = wxString_in_helper(obj0);
7862 if (arg1 == NULL) SWIG_fail;
7863 temp1 = true;
7864 }
7865 {
7866 if (!wxPyCheckForApp()) SWIG_fail;
7867 PyThreadState* __tstate = wxPyBeginAllowThreads();
7868 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7869
7870 wxPyEndAllowThreads(__tstate);
7871 if (PyErr_Occurred()) SWIG_fail;
7872 }
7873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7874 {
7875 if (temp1)
7876 delete arg1;
7877 }
7878 return resultobj;
7879 fail:
7880 {
7881 if (temp1)
7882 delete arg1;
7883 }
7884 return NULL;
7885 }
7886
7887
7888 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7889 PyObject *resultobj = NULL;
7890 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7891 PyObject * obj0 = 0 ;
7892 char *kwnames[] = {
7893 (char *) "self", NULL
7894 };
7895
7896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7898 if (SWIG_arg_fail(1)) SWIG_fail;
7899 {
7900 PyThreadState* __tstate = wxPyBeginAllowThreads();
7901 delete arg1;
7902
7903 wxPyEndAllowThreads(__tstate);
7904 if (PyErr_Occurred()) SWIG_fail;
7905 }
7906 Py_INCREF(Py_None); resultobj = Py_None;
7907 return resultobj;
7908 fail:
7909 return NULL;
7910 }
7911
7912
7913 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7914 PyObject *obj;
7915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7916 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7917 Py_INCREF(obj);
7918 return Py_BuildValue((char *)"");
7919 }
7920 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7921 PyObject *resultobj = NULL;
7922 wxStopWatch *result;
7923 char *kwnames[] = {
7924 NULL
7925 };
7926
7927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7928 {
7929 PyThreadState* __tstate = wxPyBeginAllowThreads();
7930 result = (wxStopWatch *)new wxStopWatch();
7931
7932 wxPyEndAllowThreads(__tstate);
7933 if (PyErr_Occurred()) SWIG_fail;
7934 }
7935 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7936 return resultobj;
7937 fail:
7938 return NULL;
7939 }
7940
7941
7942 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7943 PyObject *resultobj = NULL;
7944 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7945 long arg2 = (long) 0 ;
7946 PyObject * obj0 = 0 ;
7947 PyObject * obj1 = 0 ;
7948 char *kwnames[] = {
7949 (char *) "self",(char *) "t0", NULL
7950 };
7951
7952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7954 if (SWIG_arg_fail(1)) SWIG_fail;
7955 if (obj1) {
7956 {
7957 arg2 = static_cast<long >(SWIG_As_long(obj1));
7958 if (SWIG_arg_fail(2)) SWIG_fail;
7959 }
7960 }
7961 {
7962 PyThreadState* __tstate = wxPyBeginAllowThreads();
7963 (arg1)->Start(arg2);
7964
7965 wxPyEndAllowThreads(__tstate);
7966 if (PyErr_Occurred()) SWIG_fail;
7967 }
7968 Py_INCREF(Py_None); resultobj = Py_None;
7969 return resultobj;
7970 fail:
7971 return NULL;
7972 }
7973
7974
7975 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7976 PyObject *resultobj = NULL;
7977 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7978 PyObject * obj0 = 0 ;
7979 char *kwnames[] = {
7980 (char *) "self", NULL
7981 };
7982
7983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7985 if (SWIG_arg_fail(1)) SWIG_fail;
7986 {
7987 PyThreadState* __tstate = wxPyBeginAllowThreads();
7988 (arg1)->Pause();
7989
7990 wxPyEndAllowThreads(__tstate);
7991 if (PyErr_Occurred()) SWIG_fail;
7992 }
7993 Py_INCREF(Py_None); resultobj = Py_None;
7994 return resultobj;
7995 fail:
7996 return NULL;
7997 }
7998
7999
8000 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8001 PyObject *resultobj = NULL;
8002 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
8003 PyObject * obj0 = 0 ;
8004 char *kwnames[] = {
8005 (char *) "self", NULL
8006 };
8007
8008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
8009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
8010 if (SWIG_arg_fail(1)) SWIG_fail;
8011 {
8012 PyThreadState* __tstate = wxPyBeginAllowThreads();
8013 (arg1)->Resume();
8014
8015 wxPyEndAllowThreads(__tstate);
8016 if (PyErr_Occurred()) SWIG_fail;
8017 }
8018 Py_INCREF(Py_None); resultobj = Py_None;
8019 return resultobj;
8020 fail:
8021 return NULL;
8022 }
8023
8024
8025 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
8026 PyObject *resultobj = NULL;
8027 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
8028 long result;
8029 PyObject * obj0 = 0 ;
8030 char *kwnames[] = {
8031 (char *) "self", NULL
8032 };
8033
8034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
8035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
8036 if (SWIG_arg_fail(1)) SWIG_fail;
8037 {
8038 PyThreadState* __tstate = wxPyBeginAllowThreads();
8039 result = (long)((wxStopWatch const *)arg1)->Time();
8040
8041 wxPyEndAllowThreads(__tstate);
8042 if (PyErr_Occurred()) SWIG_fail;
8043 }
8044 {
8045 resultobj = SWIG_From_long(static_cast<long >(result));
8046 }
8047 return resultobj;
8048 fail:
8049 return NULL;
8050 }
8051
8052
8053 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
8054 PyObject *obj;
8055 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8056 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
8057 Py_INCREF(obj);
8058 return Py_BuildValue((char *)"");
8059 }
8060 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
8061 PyObject *resultobj = NULL;
8062 int arg1 = (int) 9 ;
8063 int arg2 = (int) wxID_FILE1 ;
8064 wxFileHistory *result;
8065 PyObject * obj0 = 0 ;
8066 PyObject * obj1 = 0 ;
8067 char *kwnames[] = {
8068 (char *) "maxFiles",(char *) "idBase", NULL
8069 };
8070
8071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
8072 if (obj0) {
8073 {
8074 arg1 = static_cast<int >(SWIG_As_int(obj0));
8075 if (SWIG_arg_fail(1)) SWIG_fail;
8076 }
8077 }
8078 if (obj1) {
8079 {
8080 arg2 = static_cast<int >(SWIG_As_int(obj1));
8081 if (SWIG_arg_fail(2)) SWIG_fail;
8082 }
8083 }
8084 {
8085 PyThreadState* __tstate = wxPyBeginAllowThreads();
8086 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
8087
8088 wxPyEndAllowThreads(__tstate);
8089 if (PyErr_Occurred()) SWIG_fail;
8090 }
8091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
8092 return resultobj;
8093 fail:
8094 return NULL;
8095 }
8096
8097
8098 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
8099 PyObject *resultobj = NULL;
8100 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8101 PyObject * obj0 = 0 ;
8102 char *kwnames[] = {
8103 (char *) "self", NULL
8104 };
8105
8106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
8107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8108 if (SWIG_arg_fail(1)) SWIG_fail;
8109 {
8110 PyThreadState* __tstate = wxPyBeginAllowThreads();
8111 delete arg1;
8112
8113 wxPyEndAllowThreads(__tstate);
8114 if (PyErr_Occurred()) SWIG_fail;
8115 }
8116 Py_INCREF(Py_None); resultobj = Py_None;
8117 return resultobj;
8118 fail:
8119 return NULL;
8120 }
8121
8122
8123 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
8124 PyObject *resultobj = NULL;
8125 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8126 wxString *arg2 = 0 ;
8127 bool temp2 = false ;
8128 PyObject * obj0 = 0 ;
8129 PyObject * obj1 = 0 ;
8130 char *kwnames[] = {
8131 (char *) "self",(char *) "file", NULL
8132 };
8133
8134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
8135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8136 if (SWIG_arg_fail(1)) SWIG_fail;
8137 {
8138 arg2 = wxString_in_helper(obj1);
8139 if (arg2 == NULL) SWIG_fail;
8140 temp2 = true;
8141 }
8142 {
8143 PyThreadState* __tstate = wxPyBeginAllowThreads();
8144 (arg1)->AddFileToHistory((wxString const &)*arg2);
8145
8146 wxPyEndAllowThreads(__tstate);
8147 if (PyErr_Occurred()) SWIG_fail;
8148 }
8149 Py_INCREF(Py_None); resultobj = Py_None;
8150 {
8151 if (temp2)
8152 delete arg2;
8153 }
8154 return resultobj;
8155 fail:
8156 {
8157 if (temp2)
8158 delete arg2;
8159 }
8160 return NULL;
8161 }
8162
8163
8164 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
8165 PyObject *resultobj = NULL;
8166 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8167 int arg2 ;
8168 PyObject * obj0 = 0 ;
8169 PyObject * obj1 = 0 ;
8170 char *kwnames[] = {
8171 (char *) "self",(char *) "i", NULL
8172 };
8173
8174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",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 = static_cast<int >(SWIG_As_int(obj1));
8179 if (SWIG_arg_fail(2)) SWIG_fail;
8180 }
8181 {
8182 PyThreadState* __tstate = wxPyBeginAllowThreads();
8183 (arg1)->RemoveFileFromHistory(arg2);
8184
8185 wxPyEndAllowThreads(__tstate);
8186 if (PyErr_Occurred()) SWIG_fail;
8187 }
8188 Py_INCREF(Py_None); resultobj = Py_None;
8189 return resultobj;
8190 fail:
8191 return NULL;
8192 }
8193
8194
8195 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
8196 PyObject *resultobj = NULL;
8197 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8198 int result;
8199 PyObject * obj0 = 0 ;
8200 char *kwnames[] = {
8201 (char *) "self", NULL
8202 };
8203
8204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
8205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8206 if (SWIG_arg_fail(1)) SWIG_fail;
8207 {
8208 PyThreadState* __tstate = wxPyBeginAllowThreads();
8209 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
8210
8211 wxPyEndAllowThreads(__tstate);
8212 if (PyErr_Occurred()) SWIG_fail;
8213 }
8214 {
8215 resultobj = SWIG_From_int(static_cast<int >(result));
8216 }
8217 return resultobj;
8218 fail:
8219 return NULL;
8220 }
8221
8222
8223 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
8224 PyObject *resultobj = NULL;
8225 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8226 wxMenu *arg2 = (wxMenu *) 0 ;
8227 PyObject * obj0 = 0 ;
8228 PyObject * obj1 = 0 ;
8229 char *kwnames[] = {
8230 (char *) "self",(char *) "menu", NULL
8231 };
8232
8233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
8234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8235 if (SWIG_arg_fail(1)) SWIG_fail;
8236 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
8237 if (SWIG_arg_fail(2)) SWIG_fail;
8238 {
8239 PyThreadState* __tstate = wxPyBeginAllowThreads();
8240 (arg1)->UseMenu(arg2);
8241
8242 wxPyEndAllowThreads(__tstate);
8243 if (PyErr_Occurred()) SWIG_fail;
8244 }
8245 Py_INCREF(Py_None); resultobj = Py_None;
8246 return resultobj;
8247 fail:
8248 return NULL;
8249 }
8250
8251
8252 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
8253 PyObject *resultobj = NULL;
8254 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8255 wxMenu *arg2 = (wxMenu *) 0 ;
8256 PyObject * obj0 = 0 ;
8257 PyObject * obj1 = 0 ;
8258 char *kwnames[] = {
8259 (char *) "self",(char *) "menu", NULL
8260 };
8261
8262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
8263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8264 if (SWIG_arg_fail(1)) SWIG_fail;
8265 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
8266 if (SWIG_arg_fail(2)) SWIG_fail;
8267 {
8268 PyThreadState* __tstate = wxPyBeginAllowThreads();
8269 (arg1)->RemoveMenu(arg2);
8270
8271 wxPyEndAllowThreads(__tstate);
8272 if (PyErr_Occurred()) SWIG_fail;
8273 }
8274 Py_INCREF(Py_None); resultobj = Py_None;
8275 return resultobj;
8276 fail:
8277 return NULL;
8278 }
8279
8280
8281 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
8282 PyObject *resultobj = NULL;
8283 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8284 wxConfigBase *arg2 = 0 ;
8285 PyObject * obj0 = 0 ;
8286 PyObject * obj1 = 0 ;
8287 char *kwnames[] = {
8288 (char *) "self",(char *) "config", NULL
8289 };
8290
8291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
8292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8293 if (SWIG_arg_fail(1)) SWIG_fail;
8294 {
8295 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8296 if (SWIG_arg_fail(2)) SWIG_fail;
8297 if (arg2 == NULL) {
8298 SWIG_null_ref("wxConfigBase");
8299 }
8300 if (SWIG_arg_fail(2)) SWIG_fail;
8301 }
8302 {
8303 PyThreadState* __tstate = wxPyBeginAllowThreads();
8304 (arg1)->Load(*arg2);
8305
8306 wxPyEndAllowThreads(__tstate);
8307 if (PyErr_Occurred()) SWIG_fail;
8308 }
8309 Py_INCREF(Py_None); resultobj = Py_None;
8310 return resultobj;
8311 fail:
8312 return NULL;
8313 }
8314
8315
8316 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
8317 PyObject *resultobj = NULL;
8318 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8319 wxConfigBase *arg2 = 0 ;
8320 PyObject * obj0 = 0 ;
8321 PyObject * obj1 = 0 ;
8322 char *kwnames[] = {
8323 (char *) "self",(char *) "config", NULL
8324 };
8325
8326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
8327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8328 if (SWIG_arg_fail(1)) SWIG_fail;
8329 {
8330 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8331 if (SWIG_arg_fail(2)) SWIG_fail;
8332 if (arg2 == NULL) {
8333 SWIG_null_ref("wxConfigBase");
8334 }
8335 if (SWIG_arg_fail(2)) SWIG_fail;
8336 }
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 (arg1)->Save(*arg2);
8340
8341 wxPyEndAllowThreads(__tstate);
8342 if (PyErr_Occurred()) SWIG_fail;
8343 }
8344 Py_INCREF(Py_None); resultobj = Py_None;
8345 return resultobj;
8346 fail:
8347 return NULL;
8348 }
8349
8350
8351 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
8352 PyObject *resultobj = NULL;
8353 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8354 PyObject * obj0 = 0 ;
8355 char *kwnames[] = {
8356 (char *) "self", NULL
8357 };
8358
8359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
8360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8361 if (SWIG_arg_fail(1)) SWIG_fail;
8362 {
8363 PyThreadState* __tstate = wxPyBeginAllowThreads();
8364 (arg1)->AddFilesToMenu();
8365
8366 wxPyEndAllowThreads(__tstate);
8367 if (PyErr_Occurred()) SWIG_fail;
8368 }
8369 Py_INCREF(Py_None); resultobj = Py_None;
8370 return resultobj;
8371 fail:
8372 return NULL;
8373 }
8374
8375
8376 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
8377 PyObject *resultobj = NULL;
8378 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8379 wxMenu *arg2 = (wxMenu *) 0 ;
8380 PyObject * obj0 = 0 ;
8381 PyObject * obj1 = 0 ;
8382 char *kwnames[] = {
8383 (char *) "self",(char *) "menu", NULL
8384 };
8385
8386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
8387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8388 if (SWIG_arg_fail(1)) SWIG_fail;
8389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
8390 if (SWIG_arg_fail(2)) SWIG_fail;
8391 {
8392 PyThreadState* __tstate = wxPyBeginAllowThreads();
8393 (arg1)->AddFilesToMenu(arg2);
8394
8395 wxPyEndAllowThreads(__tstate);
8396 if (PyErr_Occurred()) SWIG_fail;
8397 }
8398 Py_INCREF(Py_None); resultobj = Py_None;
8399 return resultobj;
8400 fail:
8401 return NULL;
8402 }
8403
8404
8405 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
8406 PyObject *resultobj = NULL;
8407 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8408 int arg2 ;
8409 wxString result;
8410 PyObject * obj0 = 0 ;
8411 PyObject * obj1 = 0 ;
8412 char *kwnames[] = {
8413 (char *) "self",(char *) "i", NULL
8414 };
8415
8416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
8417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8418 if (SWIG_arg_fail(1)) SWIG_fail;
8419 {
8420 arg2 = static_cast<int >(SWIG_As_int(obj1));
8421 if (SWIG_arg_fail(2)) SWIG_fail;
8422 }
8423 {
8424 PyThreadState* __tstate = wxPyBeginAllowThreads();
8425 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
8426
8427 wxPyEndAllowThreads(__tstate);
8428 if (PyErr_Occurred()) SWIG_fail;
8429 }
8430 {
8431 #if wxUSE_UNICODE
8432 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8433 #else
8434 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8435 #endif
8436 }
8437 return resultobj;
8438 fail:
8439 return NULL;
8440 }
8441
8442
8443 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
8444 PyObject *resultobj = NULL;
8445 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8446 int result;
8447 PyObject * obj0 = 0 ;
8448 char *kwnames[] = {
8449 (char *) "self", NULL
8450 };
8451
8452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
8453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8454 if (SWIG_arg_fail(1)) SWIG_fail;
8455 {
8456 PyThreadState* __tstate = wxPyBeginAllowThreads();
8457 result = (int)((wxFileHistory const *)arg1)->GetCount();
8458
8459 wxPyEndAllowThreads(__tstate);
8460 if (PyErr_Occurred()) SWIG_fail;
8461 }
8462 {
8463 resultobj = SWIG_From_int(static_cast<int >(result));
8464 }
8465 return resultobj;
8466 fail:
8467 return NULL;
8468 }
8469
8470
8471 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
8472 PyObject *obj;
8473 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8474 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
8475 Py_INCREF(obj);
8476 return Py_BuildValue((char *)"");
8477 }
8478 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
8479 PyObject *resultobj = NULL;
8480 wxString *arg1 = 0 ;
8481 wxString const &arg2_defvalue = wxPyEmptyString ;
8482 wxString *arg2 = (wxString *) &arg2_defvalue ;
8483 wxSingleInstanceChecker *result;
8484 bool temp1 = false ;
8485 bool temp2 = false ;
8486 PyObject * obj0 = 0 ;
8487 PyObject * obj1 = 0 ;
8488 char *kwnames[] = {
8489 (char *) "name",(char *) "path", NULL
8490 };
8491
8492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
8493 {
8494 arg1 = wxString_in_helper(obj0);
8495 if (arg1 == NULL) SWIG_fail;
8496 temp1 = true;
8497 }
8498 if (obj1) {
8499 {
8500 arg2 = wxString_in_helper(obj1);
8501 if (arg2 == NULL) SWIG_fail;
8502 temp2 = true;
8503 }
8504 }
8505 {
8506 PyThreadState* __tstate = wxPyBeginAllowThreads();
8507 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
8508
8509 wxPyEndAllowThreads(__tstate);
8510 if (PyErr_Occurred()) SWIG_fail;
8511 }
8512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
8513 {
8514 if (temp1)
8515 delete arg1;
8516 }
8517 {
8518 if (temp2)
8519 delete arg2;
8520 }
8521 return resultobj;
8522 fail:
8523 {
8524 if (temp1)
8525 delete arg1;
8526 }
8527 {
8528 if (temp2)
8529 delete arg2;
8530 }
8531 return NULL;
8532 }
8533
8534
8535 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
8536 PyObject *resultobj = NULL;
8537 wxSingleInstanceChecker *result;
8538 char *kwnames[] = {
8539 NULL
8540 };
8541
8542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
8543 {
8544 PyThreadState* __tstate = wxPyBeginAllowThreads();
8545 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
8546
8547 wxPyEndAllowThreads(__tstate);
8548 if (PyErr_Occurred()) SWIG_fail;
8549 }
8550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
8551 return resultobj;
8552 fail:
8553 return NULL;
8554 }
8555
8556
8557 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
8558 PyObject *resultobj = NULL;
8559 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
8560 PyObject * obj0 = 0 ;
8561 char *kwnames[] = {
8562 (char *) "self", NULL
8563 };
8564
8565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
8566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
8567 if (SWIG_arg_fail(1)) SWIG_fail;
8568 {
8569 PyThreadState* __tstate = wxPyBeginAllowThreads();
8570 delete arg1;
8571
8572 wxPyEndAllowThreads(__tstate);
8573 if (PyErr_Occurred()) SWIG_fail;
8574 }
8575 Py_INCREF(Py_None); resultobj = Py_None;
8576 return resultobj;
8577 fail:
8578 return NULL;
8579 }
8580
8581
8582 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
8583 PyObject *resultobj = NULL;
8584 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
8585 wxString *arg2 = 0 ;
8586 wxString const &arg3_defvalue = wxPyEmptyString ;
8587 wxString *arg3 = (wxString *) &arg3_defvalue ;
8588 bool result;
8589 bool temp2 = false ;
8590 bool temp3 = false ;
8591 PyObject * obj0 = 0 ;
8592 PyObject * obj1 = 0 ;
8593 PyObject * obj2 = 0 ;
8594 char *kwnames[] = {
8595 (char *) "self",(char *) "name",(char *) "path", NULL
8596 };
8597
8598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
8599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
8600 if (SWIG_arg_fail(1)) SWIG_fail;
8601 {
8602 arg2 = wxString_in_helper(obj1);
8603 if (arg2 == NULL) SWIG_fail;
8604 temp2 = true;
8605 }
8606 if (obj2) {
8607 {
8608 arg3 = wxString_in_helper(obj2);
8609 if (arg3 == NULL) SWIG_fail;
8610 temp3 = true;
8611 }
8612 }
8613 {
8614 PyThreadState* __tstate = wxPyBeginAllowThreads();
8615 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
8616
8617 wxPyEndAllowThreads(__tstate);
8618 if (PyErr_Occurred()) SWIG_fail;
8619 }
8620 {
8621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8622 }
8623 {
8624 if (temp2)
8625 delete arg2;
8626 }
8627 {
8628 if (temp3)
8629 delete arg3;
8630 }
8631 return resultobj;
8632 fail:
8633 {
8634 if (temp2)
8635 delete arg2;
8636 }
8637 {
8638 if (temp3)
8639 delete arg3;
8640 }
8641 return NULL;
8642 }
8643
8644
8645 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8646 PyObject *resultobj = NULL;
8647 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
8648 bool result;
8649 PyObject * obj0 = 0 ;
8650 char *kwnames[] = {
8651 (char *) "self", NULL
8652 };
8653
8654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
8655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
8656 if (SWIG_arg_fail(1)) SWIG_fail;
8657 {
8658 PyThreadState* __tstate = wxPyBeginAllowThreads();
8659 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
8660
8661 wxPyEndAllowThreads(__tstate);
8662 if (PyErr_Occurred()) SWIG_fail;
8663 }
8664 {
8665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8666 }
8667 return resultobj;
8668 fail:
8669 return NULL;
8670 }
8671
8672
8673 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
8674 PyObject *obj;
8675 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8676 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
8677 Py_INCREF(obj);
8678 return Py_BuildValue((char *)"");
8679 }
8680 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
8681 PyObject *resultobj = NULL;
8682 wxWindow *arg1 = (wxWindow *) 0 ;
8683 wxDC *arg2 = 0 ;
8684 bool result;
8685 PyObject * obj0 = 0 ;
8686 PyObject * obj1 = 0 ;
8687 char *kwnames[] = {
8688 (char *) "window",(char *) "dc", NULL
8689 };
8690
8691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
8692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8693 if (SWIG_arg_fail(1)) SWIG_fail;
8694 {
8695 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
8696 if (SWIG_arg_fail(2)) SWIG_fail;
8697 if (arg2 == NULL) {
8698 SWIG_null_ref("wxDC");
8699 }
8700 if (SWIG_arg_fail(2)) SWIG_fail;
8701 }
8702 {
8703 PyThreadState* __tstate = wxPyBeginAllowThreads();
8704 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
8705
8706 wxPyEndAllowThreads(__tstate);
8707 if (PyErr_Occurred()) SWIG_fail;
8708 }
8709 {
8710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8711 }
8712 return resultobj;
8713 fail:
8714 return NULL;
8715 }
8716
8717
8718 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8719 PyObject *resultobj = NULL;
8720 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8721 PyObject * obj0 = 0 ;
8722 char *kwnames[] = {
8723 (char *) "self", NULL
8724 };
8725
8726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
8727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8728 if (SWIG_arg_fail(1)) SWIG_fail;
8729 {
8730 PyThreadState* __tstate = wxPyBeginAllowThreads();
8731 delete arg1;
8732
8733 wxPyEndAllowThreads(__tstate);
8734 if (PyErr_Occurred()) SWIG_fail;
8735 }
8736 Py_INCREF(Py_None); resultobj = Py_None;
8737 return resultobj;
8738 fail:
8739 return NULL;
8740 }
8741
8742
8743 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
8744 PyObject *resultobj = NULL;
8745 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8746 wxString result;
8747 PyObject * obj0 = 0 ;
8748 char *kwnames[] = {
8749 (char *) "self", NULL
8750 };
8751
8752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
8753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8754 if (SWIG_arg_fail(1)) SWIG_fail;
8755 {
8756 PyThreadState* __tstate = wxPyBeginAllowThreads();
8757 result = (arg1)->GetTip();
8758
8759 wxPyEndAllowThreads(__tstate);
8760 if (PyErr_Occurred()) SWIG_fail;
8761 }
8762 {
8763 #if wxUSE_UNICODE
8764 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8765 #else
8766 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8767 #endif
8768 }
8769 return resultobj;
8770 fail:
8771 return NULL;
8772 }
8773
8774
8775 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8776 PyObject *resultobj = NULL;
8777 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8778 size_t result;
8779 PyObject * obj0 = 0 ;
8780 char *kwnames[] = {
8781 (char *) "self", NULL
8782 };
8783
8784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8786 if (SWIG_arg_fail(1)) SWIG_fail;
8787 {
8788 PyThreadState* __tstate = wxPyBeginAllowThreads();
8789 result = (size_t)(arg1)->GetCurrentTip();
8790
8791 wxPyEndAllowThreads(__tstate);
8792 if (PyErr_Occurred()) SWIG_fail;
8793 }
8794 {
8795 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
8796 }
8797 return resultobj;
8798 fail:
8799 return NULL;
8800 }
8801
8802
8803 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8804 PyObject *resultobj = NULL;
8805 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8806 wxString *arg2 = 0 ;
8807 wxString result;
8808 bool temp2 = false ;
8809 PyObject * obj0 = 0 ;
8810 PyObject * obj1 = 0 ;
8811 char *kwnames[] = {
8812 (char *) "self",(char *) "tip", NULL
8813 };
8814
8815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8817 if (SWIG_arg_fail(1)) SWIG_fail;
8818 {
8819 arg2 = wxString_in_helper(obj1);
8820 if (arg2 == NULL) SWIG_fail;
8821 temp2 = true;
8822 }
8823 {
8824 PyThreadState* __tstate = wxPyBeginAllowThreads();
8825 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8826
8827 wxPyEndAllowThreads(__tstate);
8828 if (PyErr_Occurred()) SWIG_fail;
8829 }
8830 {
8831 #if wxUSE_UNICODE
8832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8833 #else
8834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8835 #endif
8836 }
8837 {
8838 if (temp2)
8839 delete arg2;
8840 }
8841 return resultobj;
8842 fail:
8843 {
8844 if (temp2)
8845 delete arg2;
8846 }
8847 return NULL;
8848 }
8849
8850
8851 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8852 PyObject *obj;
8853 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8854 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8855 Py_INCREF(obj);
8856 return Py_BuildValue((char *)"");
8857 }
8858 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8859 PyObject *resultobj = NULL;
8860 size_t arg1 ;
8861 wxPyTipProvider *result;
8862 PyObject * obj0 = 0 ;
8863 char *kwnames[] = {
8864 (char *) "currentTip", NULL
8865 };
8866
8867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8868 {
8869 arg1 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj0));
8870 if (SWIG_arg_fail(1)) SWIG_fail;
8871 }
8872 {
8873 PyThreadState* __tstate = wxPyBeginAllowThreads();
8874 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8875
8876 wxPyEndAllowThreads(__tstate);
8877 if (PyErr_Occurred()) SWIG_fail;
8878 }
8879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8880 return resultobj;
8881 fail:
8882 return NULL;
8883 }
8884
8885
8886 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8887 PyObject *resultobj = NULL;
8888 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8889 PyObject *arg2 = (PyObject *) 0 ;
8890 PyObject *arg3 = (PyObject *) 0 ;
8891 PyObject * obj0 = 0 ;
8892 PyObject * obj1 = 0 ;
8893 PyObject * obj2 = 0 ;
8894 char *kwnames[] = {
8895 (char *) "self",(char *) "self",(char *) "_class", NULL
8896 };
8897
8898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8900 if (SWIG_arg_fail(1)) SWIG_fail;
8901 arg2 = obj1;
8902 arg3 = obj2;
8903 {
8904 PyThreadState* __tstate = wxPyBeginAllowThreads();
8905 (arg1)->_setCallbackInfo(arg2,arg3);
8906
8907 wxPyEndAllowThreads(__tstate);
8908 if (PyErr_Occurred()) SWIG_fail;
8909 }
8910 Py_INCREF(Py_None); resultobj = Py_None;
8911 return resultobj;
8912 fail:
8913 return NULL;
8914 }
8915
8916
8917 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8918 PyObject *obj;
8919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8920 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8921 Py_INCREF(obj);
8922 return Py_BuildValue((char *)"");
8923 }
8924 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8925 PyObject *resultobj = NULL;
8926 wxWindow *arg1 = (wxWindow *) 0 ;
8927 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8928 bool arg3 = (bool) true ;
8929 bool result;
8930 PyObject * obj0 = 0 ;
8931 PyObject * obj1 = 0 ;
8932 PyObject * obj2 = 0 ;
8933 char *kwnames[] = {
8934 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8935 };
8936
8937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8939 if (SWIG_arg_fail(1)) SWIG_fail;
8940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8941 if (SWIG_arg_fail(2)) SWIG_fail;
8942 if (obj2) {
8943 {
8944 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
8945 if (SWIG_arg_fail(3)) SWIG_fail;
8946 }
8947 }
8948 {
8949 if (!wxPyCheckForApp()) SWIG_fail;
8950 PyThreadState* __tstate = wxPyBeginAllowThreads();
8951 result = (bool)wxShowTip(arg1,arg2,arg3);
8952
8953 wxPyEndAllowThreads(__tstate);
8954 if (PyErr_Occurred()) SWIG_fail;
8955 }
8956 {
8957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8958 }
8959 return resultobj;
8960 fail:
8961 return NULL;
8962 }
8963
8964
8965 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8966 PyObject *resultobj = NULL;
8967 wxString *arg1 = 0 ;
8968 size_t arg2 ;
8969 wxTipProvider *result;
8970 bool temp1 = false ;
8971 PyObject * obj0 = 0 ;
8972 PyObject * obj1 = 0 ;
8973 char *kwnames[] = {
8974 (char *) "filename",(char *) "currentTip", NULL
8975 };
8976
8977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8978 {
8979 arg1 = wxString_in_helper(obj0);
8980 if (arg1 == NULL) SWIG_fail;
8981 temp1 = true;
8982 }
8983 {
8984 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
8985 if (SWIG_arg_fail(2)) SWIG_fail;
8986 }
8987 {
8988 if (!wxPyCheckForApp()) SWIG_fail;
8989 PyThreadState* __tstate = wxPyBeginAllowThreads();
8990 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8991
8992 wxPyEndAllowThreads(__tstate);
8993 if (PyErr_Occurred()) SWIG_fail;
8994 }
8995 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8996 {
8997 if (temp1)
8998 delete arg1;
8999 }
9000 return resultobj;
9001 fail:
9002 {
9003 if (temp1)
9004 delete arg1;
9005 }
9006 return NULL;
9007 }
9008
9009
9010 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
9011 PyObject *resultobj = NULL;
9012 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
9013 int arg2 = (int) -1 ;
9014 wxPyTimer *result;
9015 PyObject * obj0 = 0 ;
9016 PyObject * obj1 = 0 ;
9017 char *kwnames[] = {
9018 (char *) "owner",(char *) "id", NULL
9019 };
9020
9021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
9022 if (obj0) {
9023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
9024 if (SWIG_arg_fail(1)) SWIG_fail;
9025 }
9026 if (obj1) {
9027 {
9028 arg2 = static_cast<int >(SWIG_As_int(obj1));
9029 if (SWIG_arg_fail(2)) SWIG_fail;
9030 }
9031 }
9032 {
9033 if (!wxPyCheckForApp()) SWIG_fail;
9034 PyThreadState* __tstate = wxPyBeginAllowThreads();
9035 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
9036
9037 wxPyEndAllowThreads(__tstate);
9038 if (PyErr_Occurred()) SWIG_fail;
9039 }
9040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
9041 return resultobj;
9042 fail:
9043 return NULL;
9044 }
9045
9046
9047 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
9048 PyObject *resultobj = NULL;
9049 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9050 PyObject * obj0 = 0 ;
9051 char *kwnames[] = {
9052 (char *) "self", NULL
9053 };
9054
9055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
9056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9057 if (SWIG_arg_fail(1)) SWIG_fail;
9058 {
9059 PyThreadState* __tstate = wxPyBeginAllowThreads();
9060 delete arg1;
9061
9062 wxPyEndAllowThreads(__tstate);
9063 if (PyErr_Occurred()) SWIG_fail;
9064 }
9065 Py_INCREF(Py_None); resultobj = Py_None;
9066 return resultobj;
9067 fail:
9068 return NULL;
9069 }
9070
9071
9072 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9073 PyObject *resultobj = NULL;
9074 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9075 PyObject *arg2 = (PyObject *) 0 ;
9076 PyObject *arg3 = (PyObject *) 0 ;
9077 int arg4 = (int) 1 ;
9078 PyObject * obj0 = 0 ;
9079 PyObject * obj1 = 0 ;
9080 PyObject * obj2 = 0 ;
9081 PyObject * obj3 = 0 ;
9082 char *kwnames[] = {
9083 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
9084 };
9085
9086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9088 if (SWIG_arg_fail(1)) SWIG_fail;
9089 arg2 = obj1;
9090 arg3 = obj2;
9091 if (obj3) {
9092 {
9093 arg4 = static_cast<int >(SWIG_As_int(obj3));
9094 if (SWIG_arg_fail(4)) SWIG_fail;
9095 }
9096 }
9097 {
9098 PyThreadState* __tstate = wxPyBeginAllowThreads();
9099 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
9100
9101 wxPyEndAllowThreads(__tstate);
9102 if (PyErr_Occurred()) SWIG_fail;
9103 }
9104 Py_INCREF(Py_None); resultobj = Py_None;
9105 return resultobj;
9106 fail:
9107 return NULL;
9108 }
9109
9110
9111 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
9112 PyObject *resultobj = NULL;
9113 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9114 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
9115 int arg3 = (int) -1 ;
9116 PyObject * obj0 = 0 ;
9117 PyObject * obj1 = 0 ;
9118 PyObject * obj2 = 0 ;
9119 char *kwnames[] = {
9120 (char *) "self",(char *) "owner",(char *) "id", NULL
9121 };
9122
9123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
9124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9125 if (SWIG_arg_fail(1)) SWIG_fail;
9126 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
9127 if (SWIG_arg_fail(2)) SWIG_fail;
9128 if (obj2) {
9129 {
9130 arg3 = static_cast<int >(SWIG_As_int(obj2));
9131 if (SWIG_arg_fail(3)) SWIG_fail;
9132 }
9133 }
9134 {
9135 PyThreadState* __tstate = wxPyBeginAllowThreads();
9136 (arg1)->SetOwner(arg2,arg3);
9137
9138 wxPyEndAllowThreads(__tstate);
9139 if (PyErr_Occurred()) SWIG_fail;
9140 }
9141 Py_INCREF(Py_None); resultobj = Py_None;
9142 return resultobj;
9143 fail:
9144 return NULL;
9145 }
9146
9147
9148 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
9149 PyObject *resultobj = NULL;
9150 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9151 wxEvtHandler *result;
9152 PyObject * obj0 = 0 ;
9153 char *kwnames[] = {
9154 (char *) "self", NULL
9155 };
9156
9157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
9158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9159 if (SWIG_arg_fail(1)) SWIG_fail;
9160 {
9161 PyThreadState* __tstate = wxPyBeginAllowThreads();
9162 result = (wxEvtHandler *)(arg1)->GetOwner();
9163
9164 wxPyEndAllowThreads(__tstate);
9165 if (PyErr_Occurred()) SWIG_fail;
9166 }
9167 {
9168 resultobj = wxPyMake_wxObject(result, 0);
9169 }
9170 return resultobj;
9171 fail:
9172 return NULL;
9173 }
9174
9175
9176 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
9177 PyObject *resultobj = NULL;
9178 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9179 int arg2 = (int) -1 ;
9180 bool arg3 = (bool) false ;
9181 bool result;
9182 PyObject * obj0 = 0 ;
9183 PyObject * obj1 = 0 ;
9184 PyObject * obj2 = 0 ;
9185 char *kwnames[] = {
9186 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
9187 };
9188
9189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
9190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9191 if (SWIG_arg_fail(1)) SWIG_fail;
9192 if (obj1) {
9193 {
9194 arg2 = static_cast<int >(SWIG_As_int(obj1));
9195 if (SWIG_arg_fail(2)) SWIG_fail;
9196 }
9197 }
9198 if (obj2) {
9199 {
9200 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
9201 if (SWIG_arg_fail(3)) SWIG_fail;
9202 }
9203 }
9204 {
9205 PyThreadState* __tstate = wxPyBeginAllowThreads();
9206 result = (bool)(arg1)->Start(arg2,arg3);
9207
9208 wxPyEndAllowThreads(__tstate);
9209 if (PyErr_Occurred()) SWIG_fail;
9210 }
9211 {
9212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9213 }
9214 return resultobj;
9215 fail:
9216 return NULL;
9217 }
9218
9219
9220 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
9221 PyObject *resultobj = NULL;
9222 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9223 PyObject * obj0 = 0 ;
9224 char *kwnames[] = {
9225 (char *) "self", NULL
9226 };
9227
9228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
9229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9230 if (SWIG_arg_fail(1)) SWIG_fail;
9231 {
9232 PyThreadState* __tstate = wxPyBeginAllowThreads();
9233 (arg1)->Stop();
9234
9235 wxPyEndAllowThreads(__tstate);
9236 if (PyErr_Occurred()) SWIG_fail;
9237 }
9238 Py_INCREF(Py_None); resultobj = Py_None;
9239 return resultobj;
9240 fail:
9241 return NULL;
9242 }
9243
9244
9245 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
9246 PyObject *resultobj = NULL;
9247 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9248 bool result;
9249 PyObject * obj0 = 0 ;
9250 char *kwnames[] = {
9251 (char *) "self", NULL
9252 };
9253
9254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
9255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9256 if (SWIG_arg_fail(1)) SWIG_fail;
9257 {
9258 PyThreadState* __tstate = wxPyBeginAllowThreads();
9259 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
9260
9261 wxPyEndAllowThreads(__tstate);
9262 if (PyErr_Occurred()) SWIG_fail;
9263 }
9264 {
9265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9266 }
9267 return resultobj;
9268 fail:
9269 return NULL;
9270 }
9271
9272
9273 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
9274 PyObject *resultobj = NULL;
9275 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9276 int result;
9277 PyObject * obj0 = 0 ;
9278 char *kwnames[] = {
9279 (char *) "self", NULL
9280 };
9281
9282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
9283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9284 if (SWIG_arg_fail(1)) SWIG_fail;
9285 {
9286 PyThreadState* __tstate = wxPyBeginAllowThreads();
9287 result = (int)((wxPyTimer const *)arg1)->GetInterval();
9288
9289 wxPyEndAllowThreads(__tstate);
9290 if (PyErr_Occurred()) SWIG_fail;
9291 }
9292 {
9293 resultobj = SWIG_From_int(static_cast<int >(result));
9294 }
9295 return resultobj;
9296 fail:
9297 return NULL;
9298 }
9299
9300
9301 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
9302 PyObject *resultobj = NULL;
9303 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9304 bool result;
9305 PyObject * obj0 = 0 ;
9306 char *kwnames[] = {
9307 (char *) "self", NULL
9308 };
9309
9310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
9311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9312 if (SWIG_arg_fail(1)) SWIG_fail;
9313 {
9314 PyThreadState* __tstate = wxPyBeginAllowThreads();
9315 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
9316
9317 wxPyEndAllowThreads(__tstate);
9318 if (PyErr_Occurred()) SWIG_fail;
9319 }
9320 {
9321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9322 }
9323 return resultobj;
9324 fail:
9325 return NULL;
9326 }
9327
9328
9329 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
9330 PyObject *resultobj = NULL;
9331 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9332 int result;
9333 PyObject * obj0 = 0 ;
9334 char *kwnames[] = {
9335 (char *) "self", NULL
9336 };
9337
9338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
9339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9340 if (SWIG_arg_fail(1)) SWIG_fail;
9341 {
9342 PyThreadState* __tstate = wxPyBeginAllowThreads();
9343 result = (int)((wxPyTimer const *)arg1)->GetId();
9344
9345 wxPyEndAllowThreads(__tstate);
9346 if (PyErr_Occurred()) SWIG_fail;
9347 }
9348 {
9349 resultobj = SWIG_From_int(static_cast<int >(result));
9350 }
9351 return resultobj;
9352 fail:
9353 return NULL;
9354 }
9355
9356
9357 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
9358 PyObject *obj;
9359 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9360 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
9361 Py_INCREF(obj);
9362 return Py_BuildValue((char *)"");
9363 }
9364 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
9365 PyObject *resultobj = NULL;
9366 int arg1 = (int) 0 ;
9367 int arg2 = (int) 0 ;
9368 wxTimerEvent *result;
9369 PyObject * obj0 = 0 ;
9370 PyObject * obj1 = 0 ;
9371 char *kwnames[] = {
9372 (char *) "timerid",(char *) "interval", NULL
9373 };
9374
9375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
9376 if (obj0) {
9377 {
9378 arg1 = static_cast<int >(SWIG_As_int(obj0));
9379 if (SWIG_arg_fail(1)) SWIG_fail;
9380 }
9381 }
9382 if (obj1) {
9383 {
9384 arg2 = static_cast<int >(SWIG_As_int(obj1));
9385 if (SWIG_arg_fail(2)) SWIG_fail;
9386 }
9387 }
9388 {
9389 PyThreadState* __tstate = wxPyBeginAllowThreads();
9390 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
9391
9392 wxPyEndAllowThreads(__tstate);
9393 if (PyErr_Occurred()) SWIG_fail;
9394 }
9395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
9396 return resultobj;
9397 fail:
9398 return NULL;
9399 }
9400
9401
9402 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
9403 PyObject *resultobj = NULL;
9404 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
9405 int result;
9406 PyObject * obj0 = 0 ;
9407 char *kwnames[] = {
9408 (char *) "self", NULL
9409 };
9410
9411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
9412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
9413 if (SWIG_arg_fail(1)) SWIG_fail;
9414 {
9415 PyThreadState* __tstate = wxPyBeginAllowThreads();
9416 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
9417
9418 wxPyEndAllowThreads(__tstate);
9419 if (PyErr_Occurred()) SWIG_fail;
9420 }
9421 {
9422 resultobj = SWIG_From_int(static_cast<int >(result));
9423 }
9424 return resultobj;
9425 fail:
9426 return NULL;
9427 }
9428
9429
9430 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
9431 PyObject *obj;
9432 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9433 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
9434 Py_INCREF(obj);
9435 return Py_BuildValue((char *)"");
9436 }
9437 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
9438 PyObject *resultobj = NULL;
9439 wxTimer *arg1 = 0 ;
9440 wxTimerRunner *result;
9441 PyObject * obj0 = 0 ;
9442
9443 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
9444 {
9445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
9446 if (SWIG_arg_fail(1)) SWIG_fail;
9447 if (arg1 == NULL) {
9448 SWIG_null_ref("wxTimer");
9449 }
9450 if (SWIG_arg_fail(1)) SWIG_fail;
9451 }
9452 {
9453 if (!wxPyCheckForApp()) SWIG_fail;
9454 PyThreadState* __tstate = wxPyBeginAllowThreads();
9455 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
9456
9457 wxPyEndAllowThreads(__tstate);
9458 if (PyErr_Occurred()) SWIG_fail;
9459 }
9460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
9461 return resultobj;
9462 fail:
9463 return NULL;
9464 }
9465
9466
9467 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
9468 PyObject *resultobj = NULL;
9469 wxTimer *arg1 = 0 ;
9470 int arg2 ;
9471 bool arg3 ;
9472 wxTimerRunner *result;
9473 PyObject * obj0 = 0 ;
9474 PyObject * obj1 = 0 ;
9475 PyObject * obj2 = 0 ;
9476
9477 if(!PyArg_ParseTuple(args,(char *)"OOO:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
9478 {
9479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
9480 if (SWIG_arg_fail(1)) SWIG_fail;
9481 if (arg1 == NULL) {
9482 SWIG_null_ref("wxTimer");
9483 }
9484 if (SWIG_arg_fail(1)) SWIG_fail;
9485 }
9486 {
9487 arg2 = static_cast<int >(SWIG_As_int(obj1));
9488 if (SWIG_arg_fail(2)) SWIG_fail;
9489 }
9490 {
9491 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
9492 if (SWIG_arg_fail(3)) SWIG_fail;
9493 }
9494 {
9495 if (!wxPyCheckForApp()) SWIG_fail;
9496 PyThreadState* __tstate = wxPyBeginAllowThreads();
9497 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
9498
9499 wxPyEndAllowThreads(__tstate);
9500 if (PyErr_Occurred()) SWIG_fail;
9501 }
9502 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
9503 return resultobj;
9504 fail:
9505 return NULL;
9506 }
9507
9508
9509 static PyObject *_wrap_new_TimerRunner__SWIG_2(PyObject *, PyObject *args) {
9510 PyObject *resultobj = NULL;
9511 wxTimer *arg1 = 0 ;
9512 int arg2 ;
9513 wxTimerRunner *result;
9514 PyObject * obj0 = 0 ;
9515 PyObject * obj1 = 0 ;
9516
9517 if(!PyArg_ParseTuple(args,(char *)"OO:new_TimerRunner",&obj0,&obj1)) 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 {
9531 if (!wxPyCheckForApp()) SWIG_fail;
9532 PyThreadState* __tstate = wxPyBeginAllowThreads();
9533 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2);
9534
9535 wxPyEndAllowThreads(__tstate);
9536 if (PyErr_Occurred()) SWIG_fail;
9537 }
9538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
9539 return resultobj;
9540 fail:
9541 return NULL;
9542 }
9543
9544
9545 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
9546 int argc;
9547 PyObject *argv[4];
9548 int ii;
9549
9550 argc = PyObject_Length(args);
9551 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
9552 argv[ii] = PyTuple_GetItem(args,ii);
9553 }
9554 if (argc == 1) {
9555 int _v;
9556 {
9557 void *ptr = 0;
9558 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
9559 _v = 0;
9560 PyErr_Clear();
9561 } else {
9562 _v = (ptr != 0);
9563 }
9564 }
9565 if (_v) {
9566 return _wrap_new_TimerRunner__SWIG_0(self,args);
9567 }
9568 }
9569 if (argc == 2) {
9570 int _v;
9571 {
9572 void *ptr = 0;
9573 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
9574 _v = 0;
9575 PyErr_Clear();
9576 } else {
9577 _v = (ptr != 0);
9578 }
9579 }
9580 if (_v) {
9581 _v = SWIG_Check_int(argv[1]);
9582 if (_v) {
9583 return _wrap_new_TimerRunner__SWIG_2(self,args);
9584 }
9585 }
9586 }
9587 if (argc == 3) {
9588 int _v;
9589 {
9590 void *ptr = 0;
9591 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
9592 _v = 0;
9593 PyErr_Clear();
9594 } else {
9595 _v = (ptr != 0);
9596 }
9597 }
9598 if (_v) {
9599 _v = SWIG_Check_int(argv[1]);
9600 if (_v) {
9601 _v = SWIG_Check_bool(argv[2]);
9602 if (_v) {
9603 return _wrap_new_TimerRunner__SWIG_1(self,args);
9604 }
9605 }
9606 }
9607 }
9608
9609 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
9610 return NULL;
9611 }
9612
9613
9614 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
9615 PyObject *resultobj = NULL;
9616 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
9617 PyObject * obj0 = 0 ;
9618 char *kwnames[] = {
9619 (char *) "self", NULL
9620 };
9621
9622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
9623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
9624 if (SWIG_arg_fail(1)) SWIG_fail;
9625 {
9626 PyThreadState* __tstate = wxPyBeginAllowThreads();
9627 delete arg1;
9628
9629 wxPyEndAllowThreads(__tstate);
9630 if (PyErr_Occurred()) SWIG_fail;
9631 }
9632 Py_INCREF(Py_None); resultobj = Py_None;
9633 return resultobj;
9634 fail:
9635 return NULL;
9636 }
9637
9638
9639 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
9640 PyObject *resultobj = NULL;
9641 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
9642 int arg2 ;
9643 bool arg3 = (bool) false ;
9644 PyObject * obj0 = 0 ;
9645 PyObject * obj1 = 0 ;
9646 PyObject * obj2 = 0 ;
9647 char *kwnames[] = {
9648 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
9649 };
9650
9651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
9652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
9653 if (SWIG_arg_fail(1)) SWIG_fail;
9654 {
9655 arg2 = static_cast<int >(SWIG_As_int(obj1));
9656 if (SWIG_arg_fail(2)) SWIG_fail;
9657 }
9658 if (obj2) {
9659 {
9660 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
9661 if (SWIG_arg_fail(3)) SWIG_fail;
9662 }
9663 }
9664 {
9665 PyThreadState* __tstate = wxPyBeginAllowThreads();
9666 (arg1)->Start(arg2,arg3);
9667
9668 wxPyEndAllowThreads(__tstate);
9669 if (PyErr_Occurred()) SWIG_fail;
9670 }
9671 Py_INCREF(Py_None); resultobj = Py_None;
9672 return resultobj;
9673 fail:
9674 return NULL;
9675 }
9676
9677
9678 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
9679 PyObject *obj;
9680 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9681 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
9682 Py_INCREF(obj);
9683 return Py_BuildValue((char *)"");
9684 }
9685 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
9686 PyObject *resultobj = NULL;
9687 wxLog *result;
9688 char *kwnames[] = {
9689 NULL
9690 };
9691
9692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
9693 {
9694 PyThreadState* __tstate = wxPyBeginAllowThreads();
9695 result = (wxLog *)new wxLog();
9696
9697 wxPyEndAllowThreads(__tstate);
9698 if (PyErr_Occurred()) SWIG_fail;
9699 }
9700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
9701 return resultobj;
9702 fail:
9703 return NULL;
9704 }
9705
9706
9707 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
9708 PyObject *resultobj = NULL;
9709 bool result;
9710 char *kwnames[] = {
9711 NULL
9712 };
9713
9714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
9715 {
9716 PyThreadState* __tstate = wxPyBeginAllowThreads();
9717 result = (bool)wxLog::IsEnabled();
9718
9719 wxPyEndAllowThreads(__tstate);
9720 if (PyErr_Occurred()) SWIG_fail;
9721 }
9722 {
9723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9724 }
9725 return resultobj;
9726 fail:
9727 return NULL;
9728 }
9729
9730
9731 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
9732 PyObject *resultobj = NULL;
9733 bool arg1 = (bool) true ;
9734 bool result;
9735 PyObject * obj0 = 0 ;
9736 char *kwnames[] = {
9737 (char *) "doIt", NULL
9738 };
9739
9740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
9741 if (obj0) {
9742 {
9743 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
9744 if (SWIG_arg_fail(1)) SWIG_fail;
9745 }
9746 }
9747 {
9748 PyThreadState* __tstate = wxPyBeginAllowThreads();
9749 result = (bool)wxLog::EnableLogging(arg1);
9750
9751 wxPyEndAllowThreads(__tstate);
9752 if (PyErr_Occurred()) SWIG_fail;
9753 }
9754 {
9755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9756 }
9757 return resultobj;
9758 fail:
9759 return NULL;
9760 }
9761
9762
9763 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
9764 PyObject *resultobj = NULL;
9765 wxLogLevel arg1 ;
9766 wxChar *arg2 = (wxChar *) 0 ;
9767 time_t arg3 ;
9768 PyObject * obj0 = 0 ;
9769 PyObject * obj1 = 0 ;
9770 PyObject * obj2 = 0 ;
9771 char *kwnames[] = {
9772 (char *) "level",(char *) "szString",(char *) "t", NULL
9773 };
9774
9775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
9776 {
9777 arg1 = static_cast<wxLogLevel >(SWIG_As_unsigned_SS_long(obj0));
9778 if (SWIG_arg_fail(1)) SWIG_fail;
9779 }
9780 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9781 if (SWIG_arg_fail(2)) SWIG_fail;
9782 {
9783 arg3 = static_cast<time_t >(SWIG_As_unsigned_SS_int(obj2));
9784 if (SWIG_arg_fail(3)) SWIG_fail;
9785 }
9786 {
9787 PyThreadState* __tstate = wxPyBeginAllowThreads();
9788 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
9789
9790 wxPyEndAllowThreads(__tstate);
9791 if (PyErr_Occurred()) SWIG_fail;
9792 }
9793 Py_INCREF(Py_None); resultobj = Py_None;
9794 return resultobj;
9795 fail:
9796 return NULL;
9797 }
9798
9799
9800 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
9801 PyObject *resultobj = NULL;
9802 wxLog *arg1 = (wxLog *) 0 ;
9803 PyObject * obj0 = 0 ;
9804 char *kwnames[] = {
9805 (char *) "self", NULL
9806 };
9807
9808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
9809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9810 if (SWIG_arg_fail(1)) SWIG_fail;
9811 {
9812 PyThreadState* __tstate = wxPyBeginAllowThreads();
9813 (arg1)->Flush();
9814
9815 wxPyEndAllowThreads(__tstate);
9816 if (PyErr_Occurred()) SWIG_fail;
9817 }
9818 Py_INCREF(Py_None); resultobj = Py_None;
9819 return resultobj;
9820 fail:
9821 return NULL;
9822 }
9823
9824
9825 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9826 PyObject *resultobj = NULL;
9827 char *kwnames[] = {
9828 NULL
9829 };
9830
9831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9832 {
9833 PyThreadState* __tstate = wxPyBeginAllowThreads();
9834 wxLog::FlushActive();
9835
9836 wxPyEndAllowThreads(__tstate);
9837 if (PyErr_Occurred()) SWIG_fail;
9838 }
9839 Py_INCREF(Py_None); resultobj = Py_None;
9840 return resultobj;
9841 fail:
9842 return NULL;
9843 }
9844
9845
9846 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9847 PyObject *resultobj = NULL;
9848 wxLog *result;
9849 char *kwnames[] = {
9850 NULL
9851 };
9852
9853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9854 {
9855 PyThreadState* __tstate = wxPyBeginAllowThreads();
9856 result = (wxLog *)wxLog::GetActiveTarget();
9857
9858 wxPyEndAllowThreads(__tstate);
9859 if (PyErr_Occurred()) SWIG_fail;
9860 }
9861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9862 return resultobj;
9863 fail:
9864 return NULL;
9865 }
9866
9867
9868 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9869 PyObject *resultobj = NULL;
9870 wxLog *arg1 = (wxLog *) 0 ;
9871 wxLog *result;
9872 PyObject * obj0 = 0 ;
9873 char *kwnames[] = {
9874 (char *) "pLogger", NULL
9875 };
9876
9877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9879 if (SWIG_arg_fail(1)) SWIG_fail;
9880 {
9881 PyThreadState* __tstate = wxPyBeginAllowThreads();
9882 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9883
9884 wxPyEndAllowThreads(__tstate);
9885 if (PyErr_Occurred()) SWIG_fail;
9886 }
9887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9888 return resultobj;
9889 fail:
9890 return NULL;
9891 }
9892
9893
9894 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9895 PyObject *resultobj = NULL;
9896 char *kwnames[] = {
9897 NULL
9898 };
9899
9900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9901 {
9902 PyThreadState* __tstate = wxPyBeginAllowThreads();
9903 wxLog::Suspend();
9904
9905 wxPyEndAllowThreads(__tstate);
9906 if (PyErr_Occurred()) SWIG_fail;
9907 }
9908 Py_INCREF(Py_None); resultobj = Py_None;
9909 return resultobj;
9910 fail:
9911 return NULL;
9912 }
9913
9914
9915 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9916 PyObject *resultobj = NULL;
9917 char *kwnames[] = {
9918 NULL
9919 };
9920
9921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9922 {
9923 PyThreadState* __tstate = wxPyBeginAllowThreads();
9924 wxLog::Resume();
9925
9926 wxPyEndAllowThreads(__tstate);
9927 if (PyErr_Occurred()) SWIG_fail;
9928 }
9929 Py_INCREF(Py_None); resultobj = Py_None;
9930 return resultobj;
9931 fail:
9932 return NULL;
9933 }
9934
9935
9936 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9937 PyObject *resultobj = NULL;
9938 bool arg1 = (bool) true ;
9939 PyObject * obj0 = 0 ;
9940 char *kwnames[] = {
9941 (char *) "bVerbose", NULL
9942 };
9943
9944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9945 if (obj0) {
9946 {
9947 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
9948 if (SWIG_arg_fail(1)) SWIG_fail;
9949 }
9950 }
9951 {
9952 PyThreadState* __tstate = wxPyBeginAllowThreads();
9953 wxLog::SetVerbose(arg1);
9954
9955 wxPyEndAllowThreads(__tstate);
9956 if (PyErr_Occurred()) SWIG_fail;
9957 }
9958 Py_INCREF(Py_None); resultobj = Py_None;
9959 return resultobj;
9960 fail:
9961 return NULL;
9962 }
9963
9964
9965 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9966 PyObject *resultobj = NULL;
9967 wxLogLevel arg1 ;
9968 PyObject * obj0 = 0 ;
9969 char *kwnames[] = {
9970 (char *) "logLevel", NULL
9971 };
9972
9973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9974 {
9975 arg1 = static_cast<wxLogLevel >(SWIG_As_unsigned_SS_long(obj0));
9976 if (SWIG_arg_fail(1)) SWIG_fail;
9977 }
9978 {
9979 PyThreadState* __tstate = wxPyBeginAllowThreads();
9980 wxLog::SetLogLevel(arg1);
9981
9982 wxPyEndAllowThreads(__tstate);
9983 if (PyErr_Occurred()) SWIG_fail;
9984 }
9985 Py_INCREF(Py_None); resultobj = Py_None;
9986 return resultobj;
9987 fail:
9988 return NULL;
9989 }
9990
9991
9992 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9993 PyObject *resultobj = NULL;
9994 char *kwnames[] = {
9995 NULL
9996 };
9997
9998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9999 {
10000 PyThreadState* __tstate = wxPyBeginAllowThreads();
10001 wxLog::DontCreateOnDemand();
10002
10003 wxPyEndAllowThreads(__tstate);
10004 if (PyErr_Occurred()) SWIG_fail;
10005 }
10006 Py_INCREF(Py_None); resultobj = Py_None;
10007 return resultobj;
10008 fail:
10009 return NULL;
10010 }
10011
10012
10013 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10014 PyObject *resultobj = NULL;
10015 wxTraceMask arg1 ;
10016 PyObject * obj0 = 0 ;
10017 char *kwnames[] = {
10018 (char *) "ulMask", NULL
10019 };
10020
10021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
10022 {
10023 arg1 = static_cast<wxTraceMask >(SWIG_As_unsigned_SS_long(obj0));
10024 if (SWIG_arg_fail(1)) SWIG_fail;
10025 }
10026 {
10027 PyThreadState* __tstate = wxPyBeginAllowThreads();
10028 wxLog::SetTraceMask(arg1);
10029
10030 wxPyEndAllowThreads(__tstate);
10031 if (PyErr_Occurred()) SWIG_fail;
10032 }
10033 Py_INCREF(Py_None); resultobj = Py_None;
10034 return resultobj;
10035 fail:
10036 return NULL;
10037 }
10038
10039
10040 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10041 PyObject *resultobj = NULL;
10042 wxString *arg1 = 0 ;
10043 bool temp1 = false ;
10044 PyObject * obj0 = 0 ;
10045 char *kwnames[] = {
10046 (char *) "str", NULL
10047 };
10048
10049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
10050 {
10051 arg1 = wxString_in_helper(obj0);
10052 if (arg1 == NULL) SWIG_fail;
10053 temp1 = true;
10054 }
10055 {
10056 PyThreadState* __tstate = wxPyBeginAllowThreads();
10057 wxLog::AddTraceMask((wxString const &)*arg1);
10058
10059 wxPyEndAllowThreads(__tstate);
10060 if (PyErr_Occurred()) SWIG_fail;
10061 }
10062 Py_INCREF(Py_None); resultobj = Py_None;
10063 {
10064 if (temp1)
10065 delete arg1;
10066 }
10067 return resultobj;
10068 fail:
10069 {
10070 if (temp1)
10071 delete arg1;
10072 }
10073 return NULL;
10074 }
10075
10076
10077 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10078 PyObject *resultobj = NULL;
10079 wxString *arg1 = 0 ;
10080 bool temp1 = false ;
10081 PyObject * obj0 = 0 ;
10082 char *kwnames[] = {
10083 (char *) "str", NULL
10084 };
10085
10086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
10087 {
10088 arg1 = wxString_in_helper(obj0);
10089 if (arg1 == NULL) SWIG_fail;
10090 temp1 = true;
10091 }
10092 {
10093 PyThreadState* __tstate = wxPyBeginAllowThreads();
10094 wxLog::RemoveTraceMask((wxString const &)*arg1);
10095
10096 wxPyEndAllowThreads(__tstate);
10097 if (PyErr_Occurred()) SWIG_fail;
10098 }
10099 Py_INCREF(Py_None); resultobj = Py_None;
10100 {
10101 if (temp1)
10102 delete arg1;
10103 }
10104 return resultobj;
10105 fail:
10106 {
10107 if (temp1)
10108 delete arg1;
10109 }
10110 return NULL;
10111 }
10112
10113
10114 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
10115 PyObject *resultobj = NULL;
10116 char *kwnames[] = {
10117 NULL
10118 };
10119
10120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
10121 {
10122 PyThreadState* __tstate = wxPyBeginAllowThreads();
10123 wxLog::ClearTraceMasks();
10124
10125 wxPyEndAllowThreads(__tstate);
10126 if (PyErr_Occurred()) SWIG_fail;
10127 }
10128 Py_INCREF(Py_None); resultobj = Py_None;
10129 return resultobj;
10130 fail:
10131 return NULL;
10132 }
10133
10134
10135 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
10136 PyObject *resultobj = NULL;
10137 wxArrayString *result;
10138 char *kwnames[] = {
10139 NULL
10140 };
10141
10142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
10143 {
10144 PyThreadState* __tstate = wxPyBeginAllowThreads();
10145 {
10146 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
10147 result = (wxArrayString *) &_result_ref;
10148 }
10149
10150 wxPyEndAllowThreads(__tstate);
10151 if (PyErr_Occurred()) SWIG_fail;
10152 }
10153 {
10154 resultobj = wxArrayString2PyList_helper(*result);
10155 }
10156 return resultobj;
10157 fail:
10158 return NULL;
10159 }
10160
10161
10162 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
10163 PyObject *resultobj = NULL;
10164 wxChar *arg1 = (wxChar *) 0 ;
10165 PyObject * obj0 = 0 ;
10166 char *kwnames[] = {
10167 (char *) "ts", NULL
10168 };
10169
10170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
10171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
10172 if (SWIG_arg_fail(1)) SWIG_fail;
10173 {
10174 PyThreadState* __tstate = wxPyBeginAllowThreads();
10175 wxLog::SetTimestamp((wxChar const *)arg1);
10176
10177 wxPyEndAllowThreads(__tstate);
10178 if (PyErr_Occurred()) SWIG_fail;
10179 }
10180 Py_INCREF(Py_None); resultobj = Py_None;
10181 return resultobj;
10182 fail:
10183 return NULL;
10184 }
10185
10186
10187 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10188 PyObject *resultobj = NULL;
10189 bool result;
10190 char *kwnames[] = {
10191 NULL
10192 };
10193
10194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
10195 {
10196 PyThreadState* __tstate = wxPyBeginAllowThreads();
10197 result = (bool)wxLog::GetVerbose();
10198
10199 wxPyEndAllowThreads(__tstate);
10200 if (PyErr_Occurred()) SWIG_fail;
10201 }
10202 {
10203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10204 }
10205 return resultobj;
10206 fail:
10207 return NULL;
10208 }
10209
10210
10211 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10212 PyObject *resultobj = NULL;
10213 wxTraceMask result;
10214 char *kwnames[] = {
10215 NULL
10216 };
10217
10218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
10219 {
10220 PyThreadState* __tstate = wxPyBeginAllowThreads();
10221 result = (wxTraceMask)wxLog::GetTraceMask();
10222
10223 wxPyEndAllowThreads(__tstate);
10224 if (PyErr_Occurred()) SWIG_fail;
10225 }
10226 {
10227 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10228 }
10229 return resultobj;
10230 fail:
10231 return NULL;
10232 }
10233
10234
10235 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10236 PyObject *resultobj = NULL;
10237 wxChar *arg1 = (wxChar *) 0 ;
10238 bool result;
10239 PyObject * obj0 = 0 ;
10240 char *kwnames[] = {
10241 (char *) "mask", NULL
10242 };
10243
10244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
10245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
10246 if (SWIG_arg_fail(1)) SWIG_fail;
10247 {
10248 PyThreadState* __tstate = wxPyBeginAllowThreads();
10249 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
10250
10251 wxPyEndAllowThreads(__tstate);
10252 if (PyErr_Occurred()) SWIG_fail;
10253 }
10254 {
10255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10256 }
10257 return resultobj;
10258 fail:
10259 return NULL;
10260 }
10261
10262
10263 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
10264 PyObject *resultobj = NULL;
10265 wxLogLevel result;
10266 char *kwnames[] = {
10267 NULL
10268 };
10269
10270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
10271 {
10272 PyThreadState* __tstate = wxPyBeginAllowThreads();
10273 result = (wxLogLevel)wxLog::GetLogLevel();
10274
10275 wxPyEndAllowThreads(__tstate);
10276 if (PyErr_Occurred()) SWIG_fail;
10277 }
10278 {
10279 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10280 }
10281 return resultobj;
10282 fail:
10283 return NULL;
10284 }
10285
10286
10287 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
10288 PyObject *resultobj = NULL;
10289 wxChar *result;
10290 char *kwnames[] = {
10291 NULL
10292 };
10293
10294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
10295 {
10296 PyThreadState* __tstate = wxPyBeginAllowThreads();
10297 result = (wxChar *)wxLog::GetTimestamp();
10298
10299 wxPyEndAllowThreads(__tstate);
10300 if (PyErr_Occurred()) SWIG_fail;
10301 }
10302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
10303 return resultobj;
10304 fail:
10305 return NULL;
10306 }
10307
10308
10309 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
10310 PyObject *resultobj = NULL;
10311 wxString result;
10312 char *kwnames[] = {
10313 NULL
10314 };
10315
10316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
10317 {
10318 PyThreadState* __tstate = wxPyBeginAllowThreads();
10319 result = wxLog_TimeStamp();
10320
10321 wxPyEndAllowThreads(__tstate);
10322 if (PyErr_Occurred()) SWIG_fail;
10323 }
10324 {
10325 #if wxUSE_UNICODE
10326 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10327 #else
10328 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10329 #endif
10330 }
10331 return resultobj;
10332 fail:
10333 return NULL;
10334 }
10335
10336
10337 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10338 PyObject *resultobj = NULL;
10339 wxLog *arg1 = (wxLog *) 0 ;
10340 PyObject * obj0 = 0 ;
10341 char *kwnames[] = {
10342 (char *) "self", NULL
10343 };
10344
10345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
10346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
10347 if (SWIG_arg_fail(1)) SWIG_fail;
10348 {
10349 PyThreadState* __tstate = wxPyBeginAllowThreads();
10350 wxLog_Destroy(arg1);
10351
10352 wxPyEndAllowThreads(__tstate);
10353 if (PyErr_Occurred()) SWIG_fail;
10354 }
10355 Py_INCREF(Py_None); resultobj = Py_None;
10356 return resultobj;
10357 fail:
10358 return NULL;
10359 }
10360
10361
10362 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
10363 PyObject *obj;
10364 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10365 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
10366 Py_INCREF(obj);
10367 return Py_BuildValue((char *)"");
10368 }
10369 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
10370 PyObject *resultobj = NULL;
10371 wxLogStderr *result;
10372 char *kwnames[] = {
10373 NULL
10374 };
10375
10376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
10377 {
10378 PyThreadState* __tstate = wxPyBeginAllowThreads();
10379 result = (wxLogStderr *)new wxLogStderr();
10380
10381 wxPyEndAllowThreads(__tstate);
10382 if (PyErr_Occurred()) SWIG_fail;
10383 }
10384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
10385 return resultobj;
10386 fail:
10387 return NULL;
10388 }
10389
10390
10391 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
10392 PyObject *obj;
10393 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10394 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
10395 Py_INCREF(obj);
10396 return Py_BuildValue((char *)"");
10397 }
10398 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
10399 PyObject *resultobj = NULL;
10400 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10401 wxLogTextCtrl *result;
10402 PyObject * obj0 = 0 ;
10403 char *kwnames[] = {
10404 (char *) "pTextCtrl", NULL
10405 };
10406
10407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
10408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10409 if (SWIG_arg_fail(1)) SWIG_fail;
10410 {
10411 PyThreadState* __tstate = wxPyBeginAllowThreads();
10412 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
10413
10414 wxPyEndAllowThreads(__tstate);
10415 if (PyErr_Occurred()) SWIG_fail;
10416 }
10417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
10418 return resultobj;
10419 fail:
10420 return NULL;
10421 }
10422
10423
10424 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
10425 PyObject *obj;
10426 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10427 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
10428 Py_INCREF(obj);
10429 return Py_BuildValue((char *)"");
10430 }
10431 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
10432 PyObject *resultobj = NULL;
10433 wxLogGui *result;
10434 char *kwnames[] = {
10435 NULL
10436 };
10437
10438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
10439 {
10440 PyThreadState* __tstate = wxPyBeginAllowThreads();
10441 result = (wxLogGui *)new wxLogGui();
10442
10443 wxPyEndAllowThreads(__tstate);
10444 if (PyErr_Occurred()) SWIG_fail;
10445 }
10446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
10447 return resultobj;
10448 fail:
10449 return NULL;
10450 }
10451
10452
10453 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
10454 PyObject *obj;
10455 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10456 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
10457 Py_INCREF(obj);
10458 return Py_BuildValue((char *)"");
10459 }
10460 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10461 PyObject *resultobj = NULL;
10462 wxFrame *arg1 = (wxFrame *) 0 ;
10463 wxString *arg2 = 0 ;
10464 bool arg3 = (bool) true ;
10465 bool arg4 = (bool) true ;
10466 wxLogWindow *result;
10467 bool temp2 = false ;
10468 PyObject * obj0 = 0 ;
10469 PyObject * obj1 = 0 ;
10470 PyObject * obj2 = 0 ;
10471 PyObject * obj3 = 0 ;
10472 char *kwnames[] = {
10473 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
10474 };
10475
10476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10478 if (SWIG_arg_fail(1)) SWIG_fail;
10479 {
10480 arg2 = wxString_in_helper(obj1);
10481 if (arg2 == NULL) SWIG_fail;
10482 temp2 = true;
10483 }
10484 if (obj2) {
10485 {
10486 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
10487 if (SWIG_arg_fail(3)) SWIG_fail;
10488 }
10489 }
10490 if (obj3) {
10491 {
10492 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
10493 if (SWIG_arg_fail(4)) SWIG_fail;
10494 }
10495 }
10496 {
10497 PyThreadState* __tstate = wxPyBeginAllowThreads();
10498 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
10499
10500 wxPyEndAllowThreads(__tstate);
10501 if (PyErr_Occurred()) SWIG_fail;
10502 }
10503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
10504 {
10505 if (temp2)
10506 delete arg2;
10507 }
10508 return resultobj;
10509 fail:
10510 {
10511 if (temp2)
10512 delete arg2;
10513 }
10514 return NULL;
10515 }
10516
10517
10518 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
10519 PyObject *resultobj = NULL;
10520 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10521 bool arg2 = (bool) true ;
10522 PyObject * obj0 = 0 ;
10523 PyObject * obj1 = 0 ;
10524 char *kwnames[] = {
10525 (char *) "self",(char *) "bShow", NULL
10526 };
10527
10528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
10529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10530 if (SWIG_arg_fail(1)) SWIG_fail;
10531 if (obj1) {
10532 {
10533 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
10534 if (SWIG_arg_fail(2)) SWIG_fail;
10535 }
10536 }
10537 {
10538 PyThreadState* __tstate = wxPyBeginAllowThreads();
10539 (arg1)->Show(arg2);
10540
10541 wxPyEndAllowThreads(__tstate);
10542 if (PyErr_Occurred()) SWIG_fail;
10543 }
10544 Py_INCREF(Py_None); resultobj = Py_None;
10545 return resultobj;
10546 fail:
10547 return NULL;
10548 }
10549
10550
10551 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10552 PyObject *resultobj = NULL;
10553 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10554 wxFrame *result;
10555 PyObject * obj0 = 0 ;
10556 char *kwnames[] = {
10557 (char *) "self", NULL
10558 };
10559
10560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
10561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10562 if (SWIG_arg_fail(1)) SWIG_fail;
10563 {
10564 PyThreadState* __tstate = wxPyBeginAllowThreads();
10565 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
10566
10567 wxPyEndAllowThreads(__tstate);
10568 if (PyErr_Occurred()) SWIG_fail;
10569 }
10570 {
10571 resultobj = wxPyMake_wxObject(result, 0);
10572 }
10573 return resultobj;
10574 fail:
10575 return NULL;
10576 }
10577
10578
10579 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10580 PyObject *resultobj = NULL;
10581 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10582 wxLog *result;
10583 PyObject * obj0 = 0 ;
10584 char *kwnames[] = {
10585 (char *) "self", NULL
10586 };
10587
10588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
10589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10590 if (SWIG_arg_fail(1)) SWIG_fail;
10591 {
10592 PyThreadState* __tstate = wxPyBeginAllowThreads();
10593 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
10594
10595 wxPyEndAllowThreads(__tstate);
10596 if (PyErr_Occurred()) SWIG_fail;
10597 }
10598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10599 return resultobj;
10600 fail:
10601 return NULL;
10602 }
10603
10604
10605 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
10606 PyObject *resultobj = NULL;
10607 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10608 bool result;
10609 PyObject * obj0 = 0 ;
10610 char *kwnames[] = {
10611 (char *) "self", NULL
10612 };
10613
10614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
10615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10616 if (SWIG_arg_fail(1)) SWIG_fail;
10617 {
10618 PyThreadState* __tstate = wxPyBeginAllowThreads();
10619 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
10620
10621 wxPyEndAllowThreads(__tstate);
10622 if (PyErr_Occurred()) SWIG_fail;
10623 }
10624 {
10625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10626 }
10627 return resultobj;
10628 fail:
10629 return NULL;
10630 }
10631
10632
10633 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
10634 PyObject *resultobj = NULL;
10635 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10636 bool arg2 ;
10637 PyObject * obj0 = 0 ;
10638 PyObject * obj1 = 0 ;
10639 char *kwnames[] = {
10640 (char *) "self",(char *) "bDoPass", NULL
10641 };
10642
10643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
10644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10645 if (SWIG_arg_fail(1)) SWIG_fail;
10646 {
10647 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
10648 if (SWIG_arg_fail(2)) SWIG_fail;
10649 }
10650 {
10651 PyThreadState* __tstate = wxPyBeginAllowThreads();
10652 (arg1)->PassMessages(arg2);
10653
10654 wxPyEndAllowThreads(__tstate);
10655 if (PyErr_Occurred()) SWIG_fail;
10656 }
10657 Py_INCREF(Py_None); resultobj = Py_None;
10658 return resultobj;
10659 fail:
10660 return NULL;
10661 }
10662
10663
10664 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
10665 PyObject *obj;
10666 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10667 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
10668 Py_INCREF(obj);
10669 return Py_BuildValue((char *)"");
10670 }
10671 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
10672 PyObject *resultobj = NULL;
10673 wxLog *arg1 = (wxLog *) 0 ;
10674 wxLogChain *result;
10675 PyObject * obj0 = 0 ;
10676 char *kwnames[] = {
10677 (char *) "logger", NULL
10678 };
10679
10680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
10681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
10682 if (SWIG_arg_fail(1)) SWIG_fail;
10683 {
10684 PyThreadState* __tstate = wxPyBeginAllowThreads();
10685 result = (wxLogChain *)new wxLogChain(arg1);
10686
10687 wxPyEndAllowThreads(__tstate);
10688 if (PyErr_Occurred()) SWIG_fail;
10689 }
10690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
10691 return resultobj;
10692 fail:
10693 return NULL;
10694 }
10695
10696
10697 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
10698 PyObject *resultobj = NULL;
10699 wxLogChain *arg1 = (wxLogChain *) 0 ;
10700 wxLog *arg2 = (wxLog *) 0 ;
10701 PyObject * obj0 = 0 ;
10702 PyObject * obj1 = 0 ;
10703 char *kwnames[] = {
10704 (char *) "self",(char *) "logger", NULL
10705 };
10706
10707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
10708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10709 if (SWIG_arg_fail(1)) SWIG_fail;
10710 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
10711 if (SWIG_arg_fail(2)) SWIG_fail;
10712 {
10713 PyThreadState* __tstate = wxPyBeginAllowThreads();
10714 (arg1)->SetLog(arg2);
10715
10716 wxPyEndAllowThreads(__tstate);
10717 if (PyErr_Occurred()) SWIG_fail;
10718 }
10719 Py_INCREF(Py_None); resultobj = Py_None;
10720 return resultobj;
10721 fail:
10722 return NULL;
10723 }
10724
10725
10726 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
10727 PyObject *resultobj = NULL;
10728 wxLogChain *arg1 = (wxLogChain *) 0 ;
10729 bool arg2 ;
10730 PyObject * obj0 = 0 ;
10731 PyObject * obj1 = 0 ;
10732 char *kwnames[] = {
10733 (char *) "self",(char *) "bDoPass", NULL
10734 };
10735
10736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
10737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10738 if (SWIG_arg_fail(1)) SWIG_fail;
10739 {
10740 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
10741 if (SWIG_arg_fail(2)) SWIG_fail;
10742 }
10743 {
10744 PyThreadState* __tstate = wxPyBeginAllowThreads();
10745 (arg1)->PassMessages(arg2);
10746
10747 wxPyEndAllowThreads(__tstate);
10748 if (PyErr_Occurred()) SWIG_fail;
10749 }
10750 Py_INCREF(Py_None); resultobj = Py_None;
10751 return resultobj;
10752 fail:
10753 return NULL;
10754 }
10755
10756
10757 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
10758 PyObject *resultobj = NULL;
10759 wxLogChain *arg1 = (wxLogChain *) 0 ;
10760 bool result;
10761 PyObject * obj0 = 0 ;
10762 char *kwnames[] = {
10763 (char *) "self", NULL
10764 };
10765
10766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
10767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10768 if (SWIG_arg_fail(1)) SWIG_fail;
10769 {
10770 PyThreadState* __tstate = wxPyBeginAllowThreads();
10771 result = (bool)(arg1)->IsPassingMessages();
10772
10773 wxPyEndAllowThreads(__tstate);
10774 if (PyErr_Occurred()) SWIG_fail;
10775 }
10776 {
10777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10778 }
10779 return resultobj;
10780 fail:
10781 return NULL;
10782 }
10783
10784
10785 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10786 PyObject *resultobj = NULL;
10787 wxLogChain *arg1 = (wxLogChain *) 0 ;
10788 wxLog *result;
10789 PyObject * obj0 = 0 ;
10790 char *kwnames[] = {
10791 (char *) "self", NULL
10792 };
10793
10794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
10795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10796 if (SWIG_arg_fail(1)) SWIG_fail;
10797 {
10798 PyThreadState* __tstate = wxPyBeginAllowThreads();
10799 result = (wxLog *)(arg1)->GetOldLog();
10800
10801 wxPyEndAllowThreads(__tstate);
10802 if (PyErr_Occurred()) SWIG_fail;
10803 }
10804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10805 return resultobj;
10806 fail:
10807 return NULL;
10808 }
10809
10810
10811 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
10812 PyObject *obj;
10813 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10814 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
10815 Py_INCREF(obj);
10816 return Py_BuildValue((char *)"");
10817 }
10818 static PyObject *_wrap_new_LogBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
10819 PyObject *resultobj = NULL;
10820 wxLogBuffer *result;
10821 char *kwnames[] = {
10822 NULL
10823 };
10824
10825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogBuffer",kwnames)) goto fail;
10826 {
10827 PyThreadState* __tstate = wxPyBeginAllowThreads();
10828 result = (wxLogBuffer *)new wxLogBuffer();
10829
10830 wxPyEndAllowThreads(__tstate);
10831 if (PyErr_Occurred()) SWIG_fail;
10832 }
10833 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogBuffer, 1);
10834 return resultobj;
10835 fail:
10836 return NULL;
10837 }
10838
10839
10840 static PyObject *_wrap_LogBuffer_GetBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
10841 PyObject *resultobj = NULL;
10842 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
10843 wxString *result;
10844 PyObject * obj0 = 0 ;
10845 char *kwnames[] = {
10846 (char *) "self", NULL
10847 };
10848
10849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogBuffer_GetBuffer",kwnames,&obj0)) goto fail;
10850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_EXCEPTION | 0);
10851 if (SWIG_arg_fail(1)) SWIG_fail;
10852 {
10853 PyThreadState* __tstate = wxPyBeginAllowThreads();
10854 {
10855 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
10856 result = (wxString *) &_result_ref;
10857 }
10858
10859 wxPyEndAllowThreads(__tstate);
10860 if (PyErr_Occurred()) SWIG_fail;
10861 }
10862 {
10863 #if wxUSE_UNICODE
10864 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10865 #else
10866 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10867 #endif
10868 }
10869 return resultobj;
10870 fail:
10871 return NULL;
10872 }
10873
10874
10875 static PyObject *_wrap_LogBuffer_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
10876 PyObject *resultobj = NULL;
10877 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
10878 PyObject * obj0 = 0 ;
10879 char *kwnames[] = {
10880 (char *) "self", NULL
10881 };
10882
10883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogBuffer_Flush",kwnames,&obj0)) goto fail;
10884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_EXCEPTION | 0);
10885 if (SWIG_arg_fail(1)) SWIG_fail;
10886 {
10887 PyThreadState* __tstate = wxPyBeginAllowThreads();
10888 (arg1)->Flush();
10889
10890 wxPyEndAllowThreads(__tstate);
10891 if (PyErr_Occurred()) SWIG_fail;
10892 }
10893 Py_INCREF(Py_None); resultobj = Py_None;
10894 return resultobj;
10895 fail:
10896 return NULL;
10897 }
10898
10899
10900 static PyObject * LogBuffer_swigregister(PyObject *, PyObject *args) {
10901 PyObject *obj;
10902 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10903 SWIG_TypeClientData(SWIGTYPE_p_wxLogBuffer, obj);
10904 Py_INCREF(obj);
10905 return Py_BuildValue((char *)"");
10906 }
10907 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10908 PyObject *resultobj = NULL;
10909 unsigned long result;
10910 char *kwnames[] = {
10911 NULL
10912 };
10913
10914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10915 {
10916 PyThreadState* __tstate = wxPyBeginAllowThreads();
10917 result = (unsigned long)wxSysErrorCode();
10918
10919 wxPyEndAllowThreads(__tstate);
10920 if (PyErr_Occurred()) SWIG_fail;
10921 }
10922 {
10923 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10924 }
10925 return resultobj;
10926 fail:
10927 return NULL;
10928 }
10929
10930
10931 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10932 PyObject *resultobj = NULL;
10933 unsigned long arg1 = (unsigned long) 0 ;
10934 wxString result;
10935 PyObject * obj0 = 0 ;
10936 char *kwnames[] = {
10937 (char *) "nErrCode", NULL
10938 };
10939
10940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10941 if (obj0) {
10942 {
10943 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
10944 if (SWIG_arg_fail(1)) SWIG_fail;
10945 }
10946 }
10947 {
10948 PyThreadState* __tstate = wxPyBeginAllowThreads();
10949 result = wxSysErrorMsg(arg1);
10950
10951 wxPyEndAllowThreads(__tstate);
10952 if (PyErr_Occurred()) SWIG_fail;
10953 }
10954 {
10955 #if wxUSE_UNICODE
10956 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10957 #else
10958 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10959 #endif
10960 }
10961 return resultobj;
10962 fail:
10963 return NULL;
10964 }
10965
10966
10967 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10968 PyObject *resultobj = NULL;
10969 wxString *arg1 = 0 ;
10970 bool temp1 = false ;
10971 PyObject * obj0 = 0 ;
10972 char *kwnames[] = {
10973 (char *) "msg", NULL
10974 };
10975
10976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10977 {
10978 arg1 = wxString_in_helper(obj0);
10979 if (arg1 == NULL) SWIG_fail;
10980 temp1 = true;
10981 }
10982 {
10983 PyThreadState* __tstate = wxPyBeginAllowThreads();
10984 wxPyLogFatalError((wxString const &)*arg1);
10985
10986 wxPyEndAllowThreads(__tstate);
10987 if (PyErr_Occurred()) SWIG_fail;
10988 }
10989 Py_INCREF(Py_None); resultobj = Py_None;
10990 {
10991 if (temp1)
10992 delete arg1;
10993 }
10994 return resultobj;
10995 fail:
10996 {
10997 if (temp1)
10998 delete arg1;
10999 }
11000 return NULL;
11001 }
11002
11003
11004 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
11005 PyObject *resultobj = NULL;
11006 wxString *arg1 = 0 ;
11007 bool temp1 = false ;
11008 PyObject * obj0 = 0 ;
11009 char *kwnames[] = {
11010 (char *) "msg", NULL
11011 };
11012
11013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
11014 {
11015 arg1 = wxString_in_helper(obj0);
11016 if (arg1 == NULL) SWIG_fail;
11017 temp1 = true;
11018 }
11019 {
11020 PyThreadState* __tstate = wxPyBeginAllowThreads();
11021 wxPyLogError((wxString const &)*arg1);
11022
11023 wxPyEndAllowThreads(__tstate);
11024 if (PyErr_Occurred()) SWIG_fail;
11025 }
11026 Py_INCREF(Py_None); resultobj = Py_None;
11027 {
11028 if (temp1)
11029 delete arg1;
11030 }
11031 return resultobj;
11032 fail:
11033 {
11034 if (temp1)
11035 delete arg1;
11036 }
11037 return NULL;
11038 }
11039
11040
11041 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
11042 PyObject *resultobj = NULL;
11043 wxString *arg1 = 0 ;
11044 bool temp1 = false ;
11045 PyObject * obj0 = 0 ;
11046 char *kwnames[] = {
11047 (char *) "msg", NULL
11048 };
11049
11050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
11051 {
11052 arg1 = wxString_in_helper(obj0);
11053 if (arg1 == NULL) SWIG_fail;
11054 temp1 = true;
11055 }
11056 {
11057 PyThreadState* __tstate = wxPyBeginAllowThreads();
11058 wxPyLogWarning((wxString const &)*arg1);
11059
11060 wxPyEndAllowThreads(__tstate);
11061 if (PyErr_Occurred()) SWIG_fail;
11062 }
11063 Py_INCREF(Py_None); resultobj = Py_None;
11064 {
11065 if (temp1)
11066 delete arg1;
11067 }
11068 return resultobj;
11069 fail:
11070 {
11071 if (temp1)
11072 delete arg1;
11073 }
11074 return NULL;
11075 }
11076
11077
11078 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
11079 PyObject *resultobj = NULL;
11080 wxString *arg1 = 0 ;
11081 bool temp1 = false ;
11082 PyObject * obj0 = 0 ;
11083 char *kwnames[] = {
11084 (char *) "msg", NULL
11085 };
11086
11087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
11088 {
11089 arg1 = wxString_in_helper(obj0);
11090 if (arg1 == NULL) SWIG_fail;
11091 temp1 = true;
11092 }
11093 {
11094 PyThreadState* __tstate = wxPyBeginAllowThreads();
11095 wxPyLogMessage((wxString const &)*arg1);
11096
11097 wxPyEndAllowThreads(__tstate);
11098 if (PyErr_Occurred()) SWIG_fail;
11099 }
11100 Py_INCREF(Py_None); resultobj = Py_None;
11101 {
11102 if (temp1)
11103 delete arg1;
11104 }
11105 return resultobj;
11106 fail:
11107 {
11108 if (temp1)
11109 delete arg1;
11110 }
11111 return NULL;
11112 }
11113
11114
11115 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11116 PyObject *resultobj = NULL;
11117 wxString *arg1 = 0 ;
11118 bool temp1 = false ;
11119 PyObject * obj0 = 0 ;
11120 char *kwnames[] = {
11121 (char *) "msg", NULL
11122 };
11123
11124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
11125 {
11126 arg1 = wxString_in_helper(obj0);
11127 if (arg1 == NULL) SWIG_fail;
11128 temp1 = true;
11129 }
11130 {
11131 PyThreadState* __tstate = wxPyBeginAllowThreads();
11132 wxPyLogInfo((wxString const &)*arg1);
11133
11134 wxPyEndAllowThreads(__tstate);
11135 if (PyErr_Occurred()) SWIG_fail;
11136 }
11137 Py_INCREF(Py_None); resultobj = Py_None;
11138 {
11139 if (temp1)
11140 delete arg1;
11141 }
11142 return resultobj;
11143 fail:
11144 {
11145 if (temp1)
11146 delete arg1;
11147 }
11148 return NULL;
11149 }
11150
11151
11152 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
11153 PyObject *resultobj = NULL;
11154 wxString *arg1 = 0 ;
11155 bool temp1 = false ;
11156 PyObject * obj0 = 0 ;
11157 char *kwnames[] = {
11158 (char *) "msg", NULL
11159 };
11160
11161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
11162 {
11163 arg1 = wxString_in_helper(obj0);
11164 if (arg1 == NULL) SWIG_fail;
11165 temp1 = true;
11166 }
11167 {
11168 PyThreadState* __tstate = wxPyBeginAllowThreads();
11169 wxPyLogDebug((wxString const &)*arg1);
11170
11171 wxPyEndAllowThreads(__tstate);
11172 if (PyErr_Occurred()) SWIG_fail;
11173 }
11174 Py_INCREF(Py_None); resultobj = Py_None;
11175 {
11176 if (temp1)
11177 delete arg1;
11178 }
11179 return resultobj;
11180 fail:
11181 {
11182 if (temp1)
11183 delete arg1;
11184 }
11185 return NULL;
11186 }
11187
11188
11189 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
11190 PyObject *resultobj = NULL;
11191 wxString *arg1 = 0 ;
11192 bool temp1 = false ;
11193 PyObject * obj0 = 0 ;
11194 char *kwnames[] = {
11195 (char *) "msg", NULL
11196 };
11197
11198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
11199 {
11200 arg1 = wxString_in_helper(obj0);
11201 if (arg1 == NULL) SWIG_fail;
11202 temp1 = true;
11203 }
11204 {
11205 PyThreadState* __tstate = wxPyBeginAllowThreads();
11206 wxPyLogVerbose((wxString const &)*arg1);
11207
11208 wxPyEndAllowThreads(__tstate);
11209 if (PyErr_Occurred()) SWIG_fail;
11210 }
11211 Py_INCREF(Py_None); resultobj = Py_None;
11212 {
11213 if (temp1)
11214 delete arg1;
11215 }
11216 return resultobj;
11217 fail:
11218 {
11219 if (temp1)
11220 delete arg1;
11221 }
11222 return NULL;
11223 }
11224
11225
11226 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
11227 PyObject *resultobj = NULL;
11228 wxString *arg1 = 0 ;
11229 bool temp1 = false ;
11230 PyObject * obj0 = 0 ;
11231 char *kwnames[] = {
11232 (char *) "msg", NULL
11233 };
11234
11235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
11236 {
11237 arg1 = wxString_in_helper(obj0);
11238 if (arg1 == NULL) SWIG_fail;
11239 temp1 = true;
11240 }
11241 {
11242 PyThreadState* __tstate = wxPyBeginAllowThreads();
11243 wxPyLogStatus((wxString const &)*arg1);
11244
11245 wxPyEndAllowThreads(__tstate);
11246 if (PyErr_Occurred()) SWIG_fail;
11247 }
11248 Py_INCREF(Py_None); resultobj = Py_None;
11249 {
11250 if (temp1)
11251 delete arg1;
11252 }
11253 return resultobj;
11254 fail:
11255 {
11256 if (temp1)
11257 delete arg1;
11258 }
11259 return NULL;
11260 }
11261
11262
11263 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
11264 PyObject *resultobj = NULL;
11265 wxFrame *arg1 = (wxFrame *) 0 ;
11266 wxString *arg2 = 0 ;
11267 bool temp2 = false ;
11268 PyObject * obj0 = 0 ;
11269 PyObject * obj1 = 0 ;
11270 char *kwnames[] = {
11271 (char *) "pFrame",(char *) "msg", NULL
11272 };
11273
11274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
11275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
11276 if (SWIG_arg_fail(1)) SWIG_fail;
11277 {
11278 arg2 = wxString_in_helper(obj1);
11279 if (arg2 == NULL) SWIG_fail;
11280 temp2 = true;
11281 }
11282 {
11283 PyThreadState* __tstate = wxPyBeginAllowThreads();
11284 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
11285
11286 wxPyEndAllowThreads(__tstate);
11287 if (PyErr_Occurred()) SWIG_fail;
11288 }
11289 Py_INCREF(Py_None); resultobj = Py_None;
11290 {
11291 if (temp2)
11292 delete arg2;
11293 }
11294 return resultobj;
11295 fail:
11296 {
11297 if (temp2)
11298 delete arg2;
11299 }
11300 return NULL;
11301 }
11302
11303
11304 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
11305 PyObject *resultobj = NULL;
11306 wxString *arg1 = 0 ;
11307 bool temp1 = false ;
11308 PyObject * obj0 = 0 ;
11309 char *kwnames[] = {
11310 (char *) "msg", NULL
11311 };
11312
11313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
11314 {
11315 arg1 = wxString_in_helper(obj0);
11316 if (arg1 == NULL) SWIG_fail;
11317 temp1 = true;
11318 }
11319 {
11320 PyThreadState* __tstate = wxPyBeginAllowThreads();
11321 wxPyLogSysError((wxString const &)*arg1);
11322
11323 wxPyEndAllowThreads(__tstate);
11324 if (PyErr_Occurred()) SWIG_fail;
11325 }
11326 Py_INCREF(Py_None); resultobj = Py_None;
11327 {
11328 if (temp1)
11329 delete arg1;
11330 }
11331 return resultobj;
11332 fail:
11333 {
11334 if (temp1)
11335 delete arg1;
11336 }
11337 return NULL;
11338 }
11339
11340
11341 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
11342 PyObject *resultobj = NULL;
11343 unsigned long arg1 ;
11344 wxString *arg2 = 0 ;
11345 bool temp2 = false ;
11346 PyObject * obj0 = 0 ;
11347 PyObject * obj1 = 0 ;
11348 char *kwnames[] = {
11349 (char *) "level",(char *) "msg", NULL
11350 };
11351
11352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
11353 {
11354 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
11355 if (SWIG_arg_fail(1)) SWIG_fail;
11356 }
11357 {
11358 arg2 = wxString_in_helper(obj1);
11359 if (arg2 == NULL) SWIG_fail;
11360 temp2 = true;
11361 }
11362 {
11363 PyThreadState* __tstate = wxPyBeginAllowThreads();
11364 wxPyLogGeneric(arg1,(wxString const &)*arg2);
11365
11366 wxPyEndAllowThreads(__tstate);
11367 if (PyErr_Occurred()) SWIG_fail;
11368 }
11369 Py_INCREF(Py_None); resultobj = Py_None;
11370 {
11371 if (temp2)
11372 delete arg2;
11373 }
11374 return resultobj;
11375 fail:
11376 {
11377 if (temp2)
11378 delete arg2;
11379 }
11380 return NULL;
11381 }
11382
11383
11384 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
11385 PyObject *resultobj = NULL;
11386 unsigned long arg1 ;
11387 wxString *arg2 = 0 ;
11388 bool temp2 = false ;
11389 PyObject * obj0 = 0 ;
11390 PyObject * obj1 = 0 ;
11391
11392 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
11393 {
11394 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
11395 if (SWIG_arg_fail(1)) SWIG_fail;
11396 }
11397 {
11398 arg2 = wxString_in_helper(obj1);
11399 if (arg2 == NULL) SWIG_fail;
11400 temp2 = true;
11401 }
11402 {
11403 PyThreadState* __tstate = wxPyBeginAllowThreads();
11404 wxPyLogTrace(arg1,(wxString const &)*arg2);
11405
11406 wxPyEndAllowThreads(__tstate);
11407 if (PyErr_Occurred()) SWIG_fail;
11408 }
11409 Py_INCREF(Py_None); resultobj = Py_None;
11410 {
11411 if (temp2)
11412 delete arg2;
11413 }
11414 return resultobj;
11415 fail:
11416 {
11417 if (temp2)
11418 delete arg2;
11419 }
11420 return NULL;
11421 }
11422
11423
11424 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
11425 PyObject *resultobj = NULL;
11426 wxString *arg1 = 0 ;
11427 wxString *arg2 = 0 ;
11428 bool temp1 = false ;
11429 bool temp2 = false ;
11430 PyObject * obj0 = 0 ;
11431 PyObject * obj1 = 0 ;
11432
11433 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
11434 {
11435 arg1 = wxString_in_helper(obj0);
11436 if (arg1 == NULL) SWIG_fail;
11437 temp1 = true;
11438 }
11439 {
11440 arg2 = wxString_in_helper(obj1);
11441 if (arg2 == NULL) SWIG_fail;
11442 temp2 = true;
11443 }
11444 {
11445 PyThreadState* __tstate = wxPyBeginAllowThreads();
11446 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
11447
11448 wxPyEndAllowThreads(__tstate);
11449 if (PyErr_Occurred()) SWIG_fail;
11450 }
11451 Py_INCREF(Py_None); resultobj = Py_None;
11452 {
11453 if (temp1)
11454 delete arg1;
11455 }
11456 {
11457 if (temp2)
11458 delete arg2;
11459 }
11460 return resultobj;
11461 fail:
11462 {
11463 if (temp1)
11464 delete arg1;
11465 }
11466 {
11467 if (temp2)
11468 delete arg2;
11469 }
11470 return NULL;
11471 }
11472
11473
11474 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
11475 int argc;
11476 PyObject *argv[3];
11477 int ii;
11478
11479 argc = PyObject_Length(args);
11480 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
11481 argv[ii] = PyTuple_GetItem(args,ii);
11482 }
11483 if (argc == 2) {
11484 int _v;
11485 {
11486 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11487 }
11488 if (_v) {
11489 {
11490 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11491 }
11492 if (_v) {
11493 return _wrap_LogTrace__SWIG_1(self,args);
11494 }
11495 }
11496 }
11497 if (argc == 2) {
11498 int _v;
11499 _v = SWIG_Check_unsigned_SS_long(argv[0]);
11500 if (_v) {
11501 {
11502 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11503 }
11504 if (_v) {
11505 return _wrap_LogTrace__SWIG_0(self,args);
11506 }
11507 }
11508 }
11509
11510 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
11511 return NULL;
11512 }
11513
11514
11515 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
11516 PyObject *resultobj = NULL;
11517 wxString *arg1 = 0 ;
11518 wxString *arg2 = 0 ;
11519 bool temp1 = false ;
11520 bool temp2 = false ;
11521 PyObject * obj0 = 0 ;
11522 PyObject * obj1 = 0 ;
11523 char *kwnames[] = {
11524 (char *) "title",(char *) "text", NULL
11525 };
11526
11527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
11528 {
11529 arg1 = wxString_in_helper(obj0);
11530 if (arg1 == NULL) SWIG_fail;
11531 temp1 = true;
11532 }
11533 {
11534 arg2 = wxString_in_helper(obj1);
11535 if (arg2 == NULL) SWIG_fail;
11536 temp2 = true;
11537 }
11538 {
11539 PyThreadState* __tstate = wxPyBeginAllowThreads();
11540 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
11541
11542 wxPyEndAllowThreads(__tstate);
11543 if (PyErr_Occurred()) SWIG_fail;
11544 }
11545 Py_INCREF(Py_None); resultobj = Py_None;
11546 {
11547 if (temp1)
11548 delete arg1;
11549 }
11550 {
11551 if (temp2)
11552 delete arg2;
11553 }
11554 return resultobj;
11555 fail:
11556 {
11557 if (temp1)
11558 delete arg1;
11559 }
11560 {
11561 if (temp2)
11562 delete arg2;
11563 }
11564 return NULL;
11565 }
11566
11567
11568 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
11569 PyObject *resultobj = NULL;
11570 wxLogNull *result;
11571 char *kwnames[] = {
11572 NULL
11573 };
11574
11575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
11576 {
11577 PyThreadState* __tstate = wxPyBeginAllowThreads();
11578 result = (wxLogNull *)new wxLogNull();
11579
11580 wxPyEndAllowThreads(__tstate);
11581 if (PyErr_Occurred()) SWIG_fail;
11582 }
11583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
11584 return resultobj;
11585 fail:
11586 return NULL;
11587 }
11588
11589
11590 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
11591 PyObject *resultobj = NULL;
11592 wxLogNull *arg1 = (wxLogNull *) 0 ;
11593 PyObject * obj0 = 0 ;
11594 char *kwnames[] = {
11595 (char *) "self", NULL
11596 };
11597
11598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
11599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
11600 if (SWIG_arg_fail(1)) SWIG_fail;
11601 {
11602 PyThreadState* __tstate = wxPyBeginAllowThreads();
11603 delete arg1;
11604
11605 wxPyEndAllowThreads(__tstate);
11606 if (PyErr_Occurred()) SWIG_fail;
11607 }
11608 Py_INCREF(Py_None); resultobj = Py_None;
11609 return resultobj;
11610 fail:
11611 return NULL;
11612 }
11613
11614
11615 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
11616 PyObject *obj;
11617 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11618 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
11619 Py_INCREF(obj);
11620 return Py_BuildValue((char *)"");
11621 }
11622 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
11623 PyObject *resultobj = NULL;
11624 wxPyLog *result;
11625 char *kwnames[] = {
11626 NULL
11627 };
11628
11629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
11630 {
11631 PyThreadState* __tstate = wxPyBeginAllowThreads();
11632 result = (wxPyLog *)new wxPyLog();
11633
11634 wxPyEndAllowThreads(__tstate);
11635 if (PyErr_Occurred()) SWIG_fail;
11636 }
11637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
11638 return resultobj;
11639 fail:
11640 return NULL;
11641 }
11642
11643
11644 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11645 PyObject *resultobj = NULL;
11646 wxPyLog *arg1 = (wxPyLog *) 0 ;
11647 PyObject *arg2 = (PyObject *) 0 ;
11648 PyObject *arg3 = (PyObject *) 0 ;
11649 PyObject * obj0 = 0 ;
11650 PyObject * obj1 = 0 ;
11651 PyObject * obj2 = 0 ;
11652 char *kwnames[] = {
11653 (char *) "self",(char *) "self",(char *) "_class", NULL
11654 };
11655
11656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
11658 if (SWIG_arg_fail(1)) SWIG_fail;
11659 arg2 = obj1;
11660 arg3 = obj2;
11661 {
11662 PyThreadState* __tstate = wxPyBeginAllowThreads();
11663 (arg1)->_setCallbackInfo(arg2,arg3);
11664
11665 wxPyEndAllowThreads(__tstate);
11666 if (PyErr_Occurred()) SWIG_fail;
11667 }
11668 Py_INCREF(Py_None); resultobj = Py_None;
11669 return resultobj;
11670 fail:
11671 return NULL;
11672 }
11673
11674
11675 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
11676 PyObject *obj;
11677 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11678 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
11679 Py_INCREF(obj);
11680 return Py_BuildValue((char *)"");
11681 }
11682 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11683 PyObject *resultobj = NULL;
11684 int arg1 ;
11685 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11686 int arg3 = (int) wxKILL_NOCHILDREN ;
11687 wxKillError result;
11688 PyObject * obj0 = 0 ;
11689 PyObject * obj1 = 0 ;
11690 PyObject * obj2 = 0 ;
11691 char *kwnames[] = {
11692 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11693 };
11694
11695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11696 {
11697 arg1 = static_cast<int >(SWIG_As_int(obj0));
11698 if (SWIG_arg_fail(1)) SWIG_fail;
11699 }
11700 if (obj1) {
11701 {
11702 arg2 = static_cast<wxSignal >(SWIG_As_int(obj1));
11703 if (SWIG_arg_fail(2)) SWIG_fail;
11704 }
11705 }
11706 if (obj2) {
11707 {
11708 arg3 = static_cast<int >(SWIG_As_int(obj2));
11709 if (SWIG_arg_fail(3)) SWIG_fail;
11710 }
11711 }
11712 {
11713 PyThreadState* __tstate = wxPyBeginAllowThreads();
11714 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
11715
11716 wxPyEndAllowThreads(__tstate);
11717 if (PyErr_Occurred()) SWIG_fail;
11718 }
11719 resultobj = SWIG_From_int((result));
11720 return resultobj;
11721 fail:
11722 return NULL;
11723 }
11724
11725
11726 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
11727 PyObject *resultobj = NULL;
11728 int arg1 ;
11729 bool result;
11730 PyObject * obj0 = 0 ;
11731 char *kwnames[] = {
11732 (char *) "pid", NULL
11733 };
11734
11735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
11736 {
11737 arg1 = static_cast<int >(SWIG_As_int(obj0));
11738 if (SWIG_arg_fail(1)) SWIG_fail;
11739 }
11740 {
11741 PyThreadState* __tstate = wxPyBeginAllowThreads();
11742 result = (bool)wxPyProcess::Exists(arg1);
11743
11744 wxPyEndAllowThreads(__tstate);
11745 if (PyErr_Occurred()) SWIG_fail;
11746 }
11747 {
11748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11749 }
11750 return resultobj;
11751 fail:
11752 return NULL;
11753 }
11754
11755
11756 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
11757 PyObject *resultobj = NULL;
11758 wxString *arg1 = 0 ;
11759 int arg2 = (int) wxEXEC_ASYNC ;
11760 wxPyProcess *result;
11761 bool temp1 = false ;
11762 PyObject * obj0 = 0 ;
11763 PyObject * obj1 = 0 ;
11764 char *kwnames[] = {
11765 (char *) "cmd",(char *) "flags", NULL
11766 };
11767
11768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
11769 {
11770 arg1 = wxString_in_helper(obj0);
11771 if (arg1 == NULL) SWIG_fail;
11772 temp1 = true;
11773 }
11774 if (obj1) {
11775 {
11776 arg2 = static_cast<int >(SWIG_As_int(obj1));
11777 if (SWIG_arg_fail(2)) SWIG_fail;
11778 }
11779 }
11780 {
11781 PyThreadState* __tstate = wxPyBeginAllowThreads();
11782 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
11783
11784 wxPyEndAllowThreads(__tstate);
11785 if (PyErr_Occurred()) SWIG_fail;
11786 }
11787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
11788 {
11789 if (temp1)
11790 delete arg1;
11791 }
11792 return resultobj;
11793 fail:
11794 {
11795 if (temp1)
11796 delete arg1;
11797 }
11798 return NULL;
11799 }
11800
11801
11802 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
11803 PyObject *resultobj = NULL;
11804 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11805 int arg2 = (int) -1 ;
11806 wxPyProcess *result;
11807 PyObject * obj0 = 0 ;
11808 PyObject * obj1 = 0 ;
11809 char *kwnames[] = {
11810 (char *) "parent",(char *) "id", NULL
11811 };
11812
11813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
11814 if (obj0) {
11815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
11816 if (SWIG_arg_fail(1)) SWIG_fail;
11817 }
11818 if (obj1) {
11819 {
11820 arg2 = static_cast<int >(SWIG_As_int(obj1));
11821 if (SWIG_arg_fail(2)) SWIG_fail;
11822 }
11823 }
11824 {
11825 PyThreadState* __tstate = wxPyBeginAllowThreads();
11826 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
11827
11828 wxPyEndAllowThreads(__tstate);
11829 if (PyErr_Occurred()) SWIG_fail;
11830 }
11831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
11832 return resultobj;
11833 fail:
11834 return NULL;
11835 }
11836
11837
11838 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11839 PyObject *resultobj = NULL;
11840 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11841 PyObject *arg2 = (PyObject *) 0 ;
11842 PyObject *arg3 = (PyObject *) 0 ;
11843 PyObject * obj0 = 0 ;
11844 PyObject * obj1 = 0 ;
11845 PyObject * obj2 = 0 ;
11846 char *kwnames[] = {
11847 (char *) "self",(char *) "self",(char *) "_class", NULL
11848 };
11849
11850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11852 if (SWIG_arg_fail(1)) SWIG_fail;
11853 arg2 = obj1;
11854 arg3 = obj2;
11855 {
11856 PyThreadState* __tstate = wxPyBeginAllowThreads();
11857 (arg1)->_setCallbackInfo(arg2,arg3);
11858
11859 wxPyEndAllowThreads(__tstate);
11860 if (PyErr_Occurred()) SWIG_fail;
11861 }
11862 Py_INCREF(Py_None); resultobj = Py_None;
11863 return resultobj;
11864 fail:
11865 return NULL;
11866 }
11867
11868
11869 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
11870 PyObject *resultobj = NULL;
11871 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11872 int arg2 ;
11873 int arg3 ;
11874 PyObject * obj0 = 0 ;
11875 PyObject * obj1 = 0 ;
11876 PyObject * obj2 = 0 ;
11877 char *kwnames[] = {
11878 (char *) "self",(char *) "pid",(char *) "status", NULL
11879 };
11880
11881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
11882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11883 if (SWIG_arg_fail(1)) SWIG_fail;
11884 {
11885 arg2 = static_cast<int >(SWIG_As_int(obj1));
11886 if (SWIG_arg_fail(2)) SWIG_fail;
11887 }
11888 {
11889 arg3 = static_cast<int >(SWIG_As_int(obj2));
11890 if (SWIG_arg_fail(3)) SWIG_fail;
11891 }
11892 {
11893 PyThreadState* __tstate = wxPyBeginAllowThreads();
11894 (arg1)->base_OnTerminate(arg2,arg3);
11895
11896 wxPyEndAllowThreads(__tstate);
11897 if (PyErr_Occurred()) SWIG_fail;
11898 }
11899 Py_INCREF(Py_None); resultobj = Py_None;
11900 return resultobj;
11901 fail:
11902 return NULL;
11903 }
11904
11905
11906 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11907 PyObject *resultobj = NULL;
11908 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11909 PyObject * obj0 = 0 ;
11910 char *kwnames[] = {
11911 (char *) "self", NULL
11912 };
11913
11914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11916 if (SWIG_arg_fail(1)) SWIG_fail;
11917 {
11918 PyThreadState* __tstate = wxPyBeginAllowThreads();
11919 (arg1)->Redirect();
11920
11921 wxPyEndAllowThreads(__tstate);
11922 if (PyErr_Occurred()) SWIG_fail;
11923 }
11924 Py_INCREF(Py_None); resultobj = Py_None;
11925 return resultobj;
11926 fail:
11927 return NULL;
11928 }
11929
11930
11931 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11932 PyObject *resultobj = NULL;
11933 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11934 bool result;
11935 PyObject * obj0 = 0 ;
11936 char *kwnames[] = {
11937 (char *) "self", NULL
11938 };
11939
11940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11942 if (SWIG_arg_fail(1)) SWIG_fail;
11943 {
11944 PyThreadState* __tstate = wxPyBeginAllowThreads();
11945 result = (bool)(arg1)->IsRedirected();
11946
11947 wxPyEndAllowThreads(__tstate);
11948 if (PyErr_Occurred()) SWIG_fail;
11949 }
11950 {
11951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11952 }
11953 return resultobj;
11954 fail:
11955 return NULL;
11956 }
11957
11958
11959 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11960 PyObject *resultobj = NULL;
11961 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11962 PyObject * obj0 = 0 ;
11963 char *kwnames[] = {
11964 (char *) "self", NULL
11965 };
11966
11967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11969 if (SWIG_arg_fail(1)) SWIG_fail;
11970 {
11971 PyThreadState* __tstate = wxPyBeginAllowThreads();
11972 (arg1)->Detach();
11973
11974 wxPyEndAllowThreads(__tstate);
11975 if (PyErr_Occurred()) SWIG_fail;
11976 }
11977 Py_INCREF(Py_None); resultobj = Py_None;
11978 return resultobj;
11979 fail:
11980 return NULL;
11981 }
11982
11983
11984 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11985 PyObject *resultobj = NULL;
11986 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11987 wxInputStream *result;
11988 PyObject * obj0 = 0 ;
11989 char *kwnames[] = {
11990 (char *) "self", NULL
11991 };
11992
11993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11995 if (SWIG_arg_fail(1)) SWIG_fail;
11996 {
11997 PyThreadState* __tstate = wxPyBeginAllowThreads();
11998 result = (wxInputStream *)(arg1)->GetInputStream();
11999
12000 wxPyEndAllowThreads(__tstate);
12001 if (PyErr_Occurred()) SWIG_fail;
12002 }
12003 {
12004 wxPyInputStream * _ptr = NULL;
12005
12006 if (result) {
12007 _ptr = new wxPyInputStream(result);
12008 }
12009 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12010 }
12011 return resultobj;
12012 fail:
12013 return NULL;
12014 }
12015
12016
12017 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
12018 PyObject *resultobj = NULL;
12019 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12020 wxInputStream *result;
12021 PyObject * obj0 = 0 ;
12022 char *kwnames[] = {
12023 (char *) "self", NULL
12024 };
12025
12026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
12027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12028 if (SWIG_arg_fail(1)) SWIG_fail;
12029 {
12030 PyThreadState* __tstate = wxPyBeginAllowThreads();
12031 result = (wxInputStream *)(arg1)->GetErrorStream();
12032
12033 wxPyEndAllowThreads(__tstate);
12034 if (PyErr_Occurred()) SWIG_fail;
12035 }
12036 {
12037 wxPyInputStream * _ptr = NULL;
12038
12039 if (result) {
12040 _ptr = new wxPyInputStream(result);
12041 }
12042 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12043 }
12044 return resultobj;
12045 fail:
12046 return NULL;
12047 }
12048
12049
12050 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
12051 PyObject *resultobj = NULL;
12052 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12053 wxOutputStream *result;
12054 PyObject * obj0 = 0 ;
12055 char *kwnames[] = {
12056 (char *) "self", NULL
12057 };
12058
12059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
12060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12061 if (SWIG_arg_fail(1)) SWIG_fail;
12062 {
12063 PyThreadState* __tstate = wxPyBeginAllowThreads();
12064 result = (wxOutputStream *)(arg1)->GetOutputStream();
12065
12066 wxPyEndAllowThreads(__tstate);
12067 if (PyErr_Occurred()) SWIG_fail;
12068 }
12069 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
12070 return resultobj;
12071 fail:
12072 return NULL;
12073 }
12074
12075
12076 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
12077 PyObject *resultobj = NULL;
12078 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12079 PyObject * obj0 = 0 ;
12080 char *kwnames[] = {
12081 (char *) "self", NULL
12082 };
12083
12084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
12085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12086 if (SWIG_arg_fail(1)) SWIG_fail;
12087 {
12088 PyThreadState* __tstate = wxPyBeginAllowThreads();
12089 (arg1)->CloseOutput();
12090
12091 wxPyEndAllowThreads(__tstate);
12092 if (PyErr_Occurred()) SWIG_fail;
12093 }
12094 Py_INCREF(Py_None); resultobj = Py_None;
12095 return resultobj;
12096 fail:
12097 return NULL;
12098 }
12099
12100
12101 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
12102 PyObject *resultobj = NULL;
12103 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12104 bool result;
12105 PyObject * obj0 = 0 ;
12106 char *kwnames[] = {
12107 (char *) "self", NULL
12108 };
12109
12110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
12111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12112 if (SWIG_arg_fail(1)) SWIG_fail;
12113 {
12114 PyThreadState* __tstate = wxPyBeginAllowThreads();
12115 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
12116
12117 wxPyEndAllowThreads(__tstate);
12118 if (PyErr_Occurred()) SWIG_fail;
12119 }
12120 {
12121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12122 }
12123 return resultobj;
12124 fail:
12125 return NULL;
12126 }
12127
12128
12129 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
12130 PyObject *resultobj = NULL;
12131 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12132 bool result;
12133 PyObject * obj0 = 0 ;
12134 char *kwnames[] = {
12135 (char *) "self", NULL
12136 };
12137
12138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
12139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12140 if (SWIG_arg_fail(1)) SWIG_fail;
12141 {
12142 PyThreadState* __tstate = wxPyBeginAllowThreads();
12143 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
12144
12145 wxPyEndAllowThreads(__tstate);
12146 if (PyErr_Occurred()) SWIG_fail;
12147 }
12148 {
12149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12150 }
12151 return resultobj;
12152 fail:
12153 return NULL;
12154 }
12155
12156
12157 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
12158 PyObject *resultobj = NULL;
12159 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12160 bool result;
12161 PyObject * obj0 = 0 ;
12162 char *kwnames[] = {
12163 (char *) "self", NULL
12164 };
12165
12166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
12167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12168 if (SWIG_arg_fail(1)) SWIG_fail;
12169 {
12170 PyThreadState* __tstate = wxPyBeginAllowThreads();
12171 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
12172
12173 wxPyEndAllowThreads(__tstate);
12174 if (PyErr_Occurred()) SWIG_fail;
12175 }
12176 {
12177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12178 }
12179 return resultobj;
12180 fail:
12181 return NULL;
12182 }
12183
12184
12185 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
12186 PyObject *obj;
12187 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12188 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
12189 Py_INCREF(obj);
12190 return Py_BuildValue((char *)"");
12191 }
12192 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12193 PyObject *resultobj = NULL;
12194 int arg1 = (int) 0 ;
12195 int arg2 = (int) 0 ;
12196 int arg3 = (int) 0 ;
12197 wxProcessEvent *result;
12198 PyObject * obj0 = 0 ;
12199 PyObject * obj1 = 0 ;
12200 PyObject * obj2 = 0 ;
12201 char *kwnames[] = {
12202 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
12203 };
12204
12205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
12206 if (obj0) {
12207 {
12208 arg1 = static_cast<int >(SWIG_As_int(obj0));
12209 if (SWIG_arg_fail(1)) SWIG_fail;
12210 }
12211 }
12212 if (obj1) {
12213 {
12214 arg2 = static_cast<int >(SWIG_As_int(obj1));
12215 if (SWIG_arg_fail(2)) SWIG_fail;
12216 }
12217 }
12218 if (obj2) {
12219 {
12220 arg3 = static_cast<int >(SWIG_As_int(obj2));
12221 if (SWIG_arg_fail(3)) SWIG_fail;
12222 }
12223 }
12224 {
12225 PyThreadState* __tstate = wxPyBeginAllowThreads();
12226 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
12227
12228 wxPyEndAllowThreads(__tstate);
12229 if (PyErr_Occurred()) SWIG_fail;
12230 }
12231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
12232 return resultobj;
12233 fail:
12234 return NULL;
12235 }
12236
12237
12238 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
12239 PyObject *resultobj = NULL;
12240 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12241 int result;
12242 PyObject * obj0 = 0 ;
12243 char *kwnames[] = {
12244 (char *) "self", NULL
12245 };
12246
12247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
12248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12249 if (SWIG_arg_fail(1)) SWIG_fail;
12250 {
12251 PyThreadState* __tstate = wxPyBeginAllowThreads();
12252 result = (int)(arg1)->GetPid();
12253
12254 wxPyEndAllowThreads(__tstate);
12255 if (PyErr_Occurred()) SWIG_fail;
12256 }
12257 {
12258 resultobj = SWIG_From_int(static_cast<int >(result));
12259 }
12260 return resultobj;
12261 fail:
12262 return NULL;
12263 }
12264
12265
12266 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
12267 PyObject *resultobj = NULL;
12268 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12269 int result;
12270 PyObject * obj0 = 0 ;
12271 char *kwnames[] = {
12272 (char *) "self", NULL
12273 };
12274
12275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
12276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12277 if (SWIG_arg_fail(1)) SWIG_fail;
12278 {
12279 PyThreadState* __tstate = wxPyBeginAllowThreads();
12280 result = (int)(arg1)->GetExitCode();
12281
12282 wxPyEndAllowThreads(__tstate);
12283 if (PyErr_Occurred()) SWIG_fail;
12284 }
12285 {
12286 resultobj = SWIG_From_int(static_cast<int >(result));
12287 }
12288 return resultobj;
12289 fail:
12290 return NULL;
12291 }
12292
12293
12294 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
12295 PyObject *resultobj = NULL;
12296 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12297 int arg2 ;
12298 PyObject * obj0 = 0 ;
12299 PyObject * obj1 = 0 ;
12300 char *kwnames[] = {
12301 (char *) "self",(char *) "m_pid", NULL
12302 };
12303
12304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
12305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12306 if (SWIG_arg_fail(1)) SWIG_fail;
12307 {
12308 arg2 = static_cast<int >(SWIG_As_int(obj1));
12309 if (SWIG_arg_fail(2)) SWIG_fail;
12310 }
12311 if (arg1) (arg1)->m_pid = arg2;
12312
12313 Py_INCREF(Py_None); resultobj = Py_None;
12314 return resultobj;
12315 fail:
12316 return NULL;
12317 }
12318
12319
12320 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
12321 PyObject *resultobj = NULL;
12322 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12323 int result;
12324 PyObject * obj0 = 0 ;
12325 char *kwnames[] = {
12326 (char *) "self", NULL
12327 };
12328
12329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
12330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12331 if (SWIG_arg_fail(1)) SWIG_fail;
12332 result = (int) ((arg1)->m_pid);
12333
12334 {
12335 resultobj = SWIG_From_int(static_cast<int >(result));
12336 }
12337 return resultobj;
12338 fail:
12339 return NULL;
12340 }
12341
12342
12343 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
12344 PyObject *resultobj = NULL;
12345 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12346 int arg2 ;
12347 PyObject * obj0 = 0 ;
12348 PyObject * obj1 = 0 ;
12349 char *kwnames[] = {
12350 (char *) "self",(char *) "m_exitcode", NULL
12351 };
12352
12353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
12354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12355 if (SWIG_arg_fail(1)) SWIG_fail;
12356 {
12357 arg2 = static_cast<int >(SWIG_As_int(obj1));
12358 if (SWIG_arg_fail(2)) SWIG_fail;
12359 }
12360 if (arg1) (arg1)->m_exitcode = arg2;
12361
12362 Py_INCREF(Py_None); resultobj = Py_None;
12363 return resultobj;
12364 fail:
12365 return NULL;
12366 }
12367
12368
12369 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
12370 PyObject *resultobj = NULL;
12371 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12372 int result;
12373 PyObject * obj0 = 0 ;
12374 char *kwnames[] = {
12375 (char *) "self", NULL
12376 };
12377
12378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
12379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12380 if (SWIG_arg_fail(1)) SWIG_fail;
12381 result = (int) ((arg1)->m_exitcode);
12382
12383 {
12384 resultobj = SWIG_From_int(static_cast<int >(result));
12385 }
12386 return resultobj;
12387 fail:
12388 return NULL;
12389 }
12390
12391
12392 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
12393 PyObject *obj;
12394 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12395 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
12396 Py_INCREF(obj);
12397 return Py_BuildValue((char *)"");
12398 }
12399 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
12400 PyObject *resultobj = NULL;
12401 wxString *arg1 = 0 ;
12402 int arg2 = (int) wxEXEC_ASYNC ;
12403 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
12404 long result;
12405 bool temp1 = false ;
12406 PyObject * obj0 = 0 ;
12407 PyObject * obj1 = 0 ;
12408 PyObject * obj2 = 0 ;
12409 char *kwnames[] = {
12410 (char *) "command",(char *) "flags",(char *) "process", NULL
12411 };
12412
12413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
12414 {
12415 arg1 = wxString_in_helper(obj0);
12416 if (arg1 == NULL) SWIG_fail;
12417 temp1 = true;
12418 }
12419 if (obj1) {
12420 {
12421 arg2 = static_cast<int >(SWIG_As_int(obj1));
12422 if (SWIG_arg_fail(2)) SWIG_fail;
12423 }
12424 }
12425 if (obj2) {
12426 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12427 if (SWIG_arg_fail(3)) SWIG_fail;
12428 }
12429 {
12430 if (!wxPyCheckForApp()) SWIG_fail;
12431 PyThreadState* __tstate = wxPyBeginAllowThreads();
12432 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
12433
12434 wxPyEndAllowThreads(__tstate);
12435 if (PyErr_Occurred()) SWIG_fail;
12436 }
12437 {
12438 resultobj = SWIG_From_long(static_cast<long >(result));
12439 }
12440 {
12441 if (temp1)
12442 delete arg1;
12443 }
12444 return resultobj;
12445 fail:
12446 {
12447 if (temp1)
12448 delete arg1;
12449 }
12450 return NULL;
12451 }
12452
12453
12454 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
12455 PyObject *resultobj = NULL;
12456 long arg1 ;
12457 wxSignal arg2 = (wxSignal) wxSIGTERM ;
12458 wxKillError *arg3 = (wxKillError *) 0 ;
12459 int arg4 = (int) wxKILL_NOCHILDREN ;
12460 int result;
12461 wxKillError temp3 ;
12462 PyObject * obj0 = 0 ;
12463 PyObject * obj1 = 0 ;
12464 PyObject * obj2 = 0 ;
12465 char *kwnames[] = {
12466 (char *) "pid",(char *) "sig",(char *) "flags", NULL
12467 };
12468
12469 {
12470 arg3 = &temp3;
12471 }
12472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
12473 {
12474 arg1 = static_cast<long >(SWIG_As_long(obj0));
12475 if (SWIG_arg_fail(1)) SWIG_fail;
12476 }
12477 if (obj1) {
12478 {
12479 arg2 = static_cast<wxSignal >(SWIG_As_int(obj1));
12480 if (SWIG_arg_fail(2)) SWIG_fail;
12481 }
12482 }
12483 if (obj2) {
12484 {
12485 arg4 = static_cast<int >(SWIG_As_int(obj2));
12486 if (SWIG_arg_fail(4)) SWIG_fail;
12487 }
12488 }
12489 {
12490 PyThreadState* __tstate = wxPyBeginAllowThreads();
12491 result = (int)wxKill(arg1,arg2,arg3,arg4);
12492
12493 wxPyEndAllowThreads(__tstate);
12494 if (PyErr_Occurred()) SWIG_fail;
12495 }
12496 {
12497 resultobj = SWIG_From_int(static_cast<int >(result));
12498 }
12499 {
12500 PyObject* o;
12501 o = PyInt_FromLong((long) (*arg3));
12502 resultobj = t_output_helper(resultobj, o);
12503 }
12504 return resultobj;
12505 fail:
12506 return NULL;
12507 }
12508
12509
12510 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
12511 PyObject *resultobj = NULL;
12512 int arg1 = (int) wxJOYSTICK1 ;
12513 wxJoystick *result;
12514 PyObject * obj0 = 0 ;
12515 char *kwnames[] = {
12516 (char *) "joystick", NULL
12517 };
12518
12519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
12520 if (obj0) {
12521 {
12522 arg1 = static_cast<int >(SWIG_As_int(obj0));
12523 if (SWIG_arg_fail(1)) SWIG_fail;
12524 }
12525 }
12526 {
12527 if (!wxPyCheckForApp()) SWIG_fail;
12528 PyThreadState* __tstate = wxPyBeginAllowThreads();
12529 result = (wxJoystick *)new wxJoystick(arg1);
12530
12531 wxPyEndAllowThreads(__tstate);
12532 if (PyErr_Occurred()) SWIG_fail;
12533 }
12534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
12535 return resultobj;
12536 fail:
12537 return NULL;
12538 }
12539
12540
12541 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
12542 PyObject *resultobj = NULL;
12543 wxJoystick *arg1 = (wxJoystick *) 0 ;
12544 PyObject * obj0 = 0 ;
12545 char *kwnames[] = {
12546 (char *) "self", NULL
12547 };
12548
12549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
12550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12551 if (SWIG_arg_fail(1)) SWIG_fail;
12552 {
12553 PyThreadState* __tstate = wxPyBeginAllowThreads();
12554 delete arg1;
12555
12556 wxPyEndAllowThreads(__tstate);
12557 if (PyErr_Occurred()) SWIG_fail;
12558 }
12559 Py_INCREF(Py_None); resultobj = Py_None;
12560 return resultobj;
12561 fail:
12562 return NULL;
12563 }
12564
12565
12566 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12567 PyObject *resultobj = NULL;
12568 wxJoystick *arg1 = (wxJoystick *) 0 ;
12569 wxPoint result;
12570 PyObject * obj0 = 0 ;
12571 char *kwnames[] = {
12572 (char *) "self", NULL
12573 };
12574
12575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
12576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12577 if (SWIG_arg_fail(1)) SWIG_fail;
12578 {
12579 PyThreadState* __tstate = wxPyBeginAllowThreads();
12580 result = (arg1)->GetPosition();
12581
12582 wxPyEndAllowThreads(__tstate);
12583 if (PyErr_Occurred()) SWIG_fail;
12584 }
12585 {
12586 wxPoint * resultptr;
12587 resultptr = new wxPoint(static_cast<wxPoint & >(result));
12588 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12589 }
12590 return resultobj;
12591 fail:
12592 return NULL;
12593 }
12594
12595
12596 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12597 PyObject *resultobj = NULL;
12598 wxJoystick *arg1 = (wxJoystick *) 0 ;
12599 int result;
12600 PyObject * obj0 = 0 ;
12601 char *kwnames[] = {
12602 (char *) "self", NULL
12603 };
12604
12605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
12606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12607 if (SWIG_arg_fail(1)) SWIG_fail;
12608 {
12609 PyThreadState* __tstate = wxPyBeginAllowThreads();
12610 result = (int)(arg1)->GetZPosition();
12611
12612 wxPyEndAllowThreads(__tstate);
12613 if (PyErr_Occurred()) SWIG_fail;
12614 }
12615 {
12616 resultobj = SWIG_From_int(static_cast<int >(result));
12617 }
12618 return resultobj;
12619 fail:
12620 return NULL;
12621 }
12622
12623
12624 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12625 PyObject *resultobj = NULL;
12626 wxJoystick *arg1 = (wxJoystick *) 0 ;
12627 int result;
12628 PyObject * obj0 = 0 ;
12629 char *kwnames[] = {
12630 (char *) "self", NULL
12631 };
12632
12633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
12634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12635 if (SWIG_arg_fail(1)) SWIG_fail;
12636 {
12637 PyThreadState* __tstate = wxPyBeginAllowThreads();
12638 result = (int)(arg1)->GetButtonState();
12639
12640 wxPyEndAllowThreads(__tstate);
12641 if (PyErr_Occurred()) SWIG_fail;
12642 }
12643 {
12644 resultobj = SWIG_From_int(static_cast<int >(result));
12645 }
12646 return resultobj;
12647 fail:
12648 return NULL;
12649 }
12650
12651
12652 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12653 PyObject *resultobj = NULL;
12654 wxJoystick *arg1 = (wxJoystick *) 0 ;
12655 int result;
12656 PyObject * obj0 = 0 ;
12657 char *kwnames[] = {
12658 (char *) "self", NULL
12659 };
12660
12661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
12662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12663 if (SWIG_arg_fail(1)) SWIG_fail;
12664 {
12665 PyThreadState* __tstate = wxPyBeginAllowThreads();
12666 result = (int)(arg1)->GetPOVPosition();
12667
12668 wxPyEndAllowThreads(__tstate);
12669 if (PyErr_Occurred()) SWIG_fail;
12670 }
12671 {
12672 resultobj = SWIG_From_int(static_cast<int >(result));
12673 }
12674 return resultobj;
12675 fail:
12676 return NULL;
12677 }
12678
12679
12680 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12681 PyObject *resultobj = NULL;
12682 wxJoystick *arg1 = (wxJoystick *) 0 ;
12683 int result;
12684 PyObject * obj0 = 0 ;
12685 char *kwnames[] = {
12686 (char *) "self", NULL
12687 };
12688
12689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
12690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12691 if (SWIG_arg_fail(1)) SWIG_fail;
12692 {
12693 PyThreadState* __tstate = wxPyBeginAllowThreads();
12694 result = (int)(arg1)->GetPOVCTSPosition();
12695
12696 wxPyEndAllowThreads(__tstate);
12697 if (PyErr_Occurred()) SWIG_fail;
12698 }
12699 {
12700 resultobj = SWIG_From_int(static_cast<int >(result));
12701 }
12702 return resultobj;
12703 fail:
12704 return NULL;
12705 }
12706
12707
12708 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12709 PyObject *resultobj = NULL;
12710 wxJoystick *arg1 = (wxJoystick *) 0 ;
12711 int result;
12712 PyObject * obj0 = 0 ;
12713 char *kwnames[] = {
12714 (char *) "self", NULL
12715 };
12716
12717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
12718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12719 if (SWIG_arg_fail(1)) SWIG_fail;
12720 {
12721 PyThreadState* __tstate = wxPyBeginAllowThreads();
12722 result = (int)(arg1)->GetRudderPosition();
12723
12724 wxPyEndAllowThreads(__tstate);
12725 if (PyErr_Occurred()) SWIG_fail;
12726 }
12727 {
12728 resultobj = SWIG_From_int(static_cast<int >(result));
12729 }
12730 return resultobj;
12731 fail:
12732 return NULL;
12733 }
12734
12735
12736 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12737 PyObject *resultobj = NULL;
12738 wxJoystick *arg1 = (wxJoystick *) 0 ;
12739 int result;
12740 PyObject * obj0 = 0 ;
12741 char *kwnames[] = {
12742 (char *) "self", NULL
12743 };
12744
12745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
12746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12747 if (SWIG_arg_fail(1)) SWIG_fail;
12748 {
12749 PyThreadState* __tstate = wxPyBeginAllowThreads();
12750 result = (int)(arg1)->GetUPosition();
12751
12752 wxPyEndAllowThreads(__tstate);
12753 if (PyErr_Occurred()) SWIG_fail;
12754 }
12755 {
12756 resultobj = SWIG_From_int(static_cast<int >(result));
12757 }
12758 return resultobj;
12759 fail:
12760 return NULL;
12761 }
12762
12763
12764 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12765 PyObject *resultobj = NULL;
12766 wxJoystick *arg1 = (wxJoystick *) 0 ;
12767 int result;
12768 PyObject * obj0 = 0 ;
12769 char *kwnames[] = {
12770 (char *) "self", NULL
12771 };
12772
12773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
12774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12775 if (SWIG_arg_fail(1)) SWIG_fail;
12776 {
12777 PyThreadState* __tstate = wxPyBeginAllowThreads();
12778 result = (int)(arg1)->GetVPosition();
12779
12780 wxPyEndAllowThreads(__tstate);
12781 if (PyErr_Occurred()) SWIG_fail;
12782 }
12783 {
12784 resultobj = SWIG_From_int(static_cast<int >(result));
12785 }
12786 return resultobj;
12787 fail:
12788 return NULL;
12789 }
12790
12791
12792 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
12793 PyObject *resultobj = NULL;
12794 wxJoystick *arg1 = (wxJoystick *) 0 ;
12795 int result;
12796 PyObject * obj0 = 0 ;
12797 char *kwnames[] = {
12798 (char *) "self", NULL
12799 };
12800
12801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
12802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12803 if (SWIG_arg_fail(1)) SWIG_fail;
12804 {
12805 PyThreadState* __tstate = wxPyBeginAllowThreads();
12806 result = (int)(arg1)->GetMovementThreshold();
12807
12808 wxPyEndAllowThreads(__tstate);
12809 if (PyErr_Occurred()) SWIG_fail;
12810 }
12811 {
12812 resultobj = SWIG_From_int(static_cast<int >(result));
12813 }
12814 return resultobj;
12815 fail:
12816 return NULL;
12817 }
12818
12819
12820 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
12821 PyObject *resultobj = NULL;
12822 wxJoystick *arg1 = (wxJoystick *) 0 ;
12823 int arg2 ;
12824 PyObject * obj0 = 0 ;
12825 PyObject * obj1 = 0 ;
12826 char *kwnames[] = {
12827 (char *) "self",(char *) "threshold", NULL
12828 };
12829
12830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
12831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12832 if (SWIG_arg_fail(1)) SWIG_fail;
12833 {
12834 arg2 = static_cast<int >(SWIG_As_int(obj1));
12835 if (SWIG_arg_fail(2)) SWIG_fail;
12836 }
12837 {
12838 PyThreadState* __tstate = wxPyBeginAllowThreads();
12839 (arg1)->SetMovementThreshold(arg2);
12840
12841 wxPyEndAllowThreads(__tstate);
12842 if (PyErr_Occurred()) SWIG_fail;
12843 }
12844 Py_INCREF(Py_None); resultobj = Py_None;
12845 return resultobj;
12846 fail:
12847 return NULL;
12848 }
12849
12850
12851 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
12852 PyObject *resultobj = NULL;
12853 wxJoystick *arg1 = (wxJoystick *) 0 ;
12854 bool result;
12855 PyObject * obj0 = 0 ;
12856 char *kwnames[] = {
12857 (char *) "self", NULL
12858 };
12859
12860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
12861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12862 if (SWIG_arg_fail(1)) SWIG_fail;
12863 {
12864 PyThreadState* __tstate = wxPyBeginAllowThreads();
12865 result = (bool)(arg1)->IsOk();
12866
12867 wxPyEndAllowThreads(__tstate);
12868 if (PyErr_Occurred()) SWIG_fail;
12869 }
12870 {
12871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12872 }
12873 return resultobj;
12874 fail:
12875 return NULL;
12876 }
12877
12878
12879 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
12880 PyObject *resultobj = NULL;
12881 wxJoystick *arg1 = (wxJoystick *) 0 ;
12882 int result;
12883 PyObject * obj0 = 0 ;
12884 char *kwnames[] = {
12885 (char *) "self", NULL
12886 };
12887
12888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
12889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12890 if (SWIG_arg_fail(1)) SWIG_fail;
12891 {
12892 PyThreadState* __tstate = wxPyBeginAllowThreads();
12893 result = (int)(arg1)->GetNumberJoysticks();
12894
12895 wxPyEndAllowThreads(__tstate);
12896 if (PyErr_Occurred()) SWIG_fail;
12897 }
12898 {
12899 resultobj = SWIG_From_int(static_cast<int >(result));
12900 }
12901 return resultobj;
12902 fail:
12903 return NULL;
12904 }
12905
12906
12907 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12908 PyObject *resultobj = NULL;
12909 wxJoystick *arg1 = (wxJoystick *) 0 ;
12910 int result;
12911 PyObject * obj0 = 0 ;
12912 char *kwnames[] = {
12913 (char *) "self", NULL
12914 };
12915
12916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12918 if (SWIG_arg_fail(1)) SWIG_fail;
12919 {
12920 PyThreadState* __tstate = wxPyBeginAllowThreads();
12921 result = (int)(arg1)->GetManufacturerId();
12922
12923 wxPyEndAllowThreads(__tstate);
12924 if (PyErr_Occurred()) SWIG_fail;
12925 }
12926 {
12927 resultobj = SWIG_From_int(static_cast<int >(result));
12928 }
12929 return resultobj;
12930 fail:
12931 return NULL;
12932 }
12933
12934
12935 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12936 PyObject *resultobj = NULL;
12937 wxJoystick *arg1 = (wxJoystick *) 0 ;
12938 int result;
12939 PyObject * obj0 = 0 ;
12940 char *kwnames[] = {
12941 (char *) "self", NULL
12942 };
12943
12944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12946 if (SWIG_arg_fail(1)) SWIG_fail;
12947 {
12948 PyThreadState* __tstate = wxPyBeginAllowThreads();
12949 result = (int)(arg1)->GetProductId();
12950
12951 wxPyEndAllowThreads(__tstate);
12952 if (PyErr_Occurred()) SWIG_fail;
12953 }
12954 {
12955 resultobj = SWIG_From_int(static_cast<int >(result));
12956 }
12957 return resultobj;
12958 fail:
12959 return NULL;
12960 }
12961
12962
12963 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12964 PyObject *resultobj = NULL;
12965 wxJoystick *arg1 = (wxJoystick *) 0 ;
12966 wxString result;
12967 PyObject * obj0 = 0 ;
12968 char *kwnames[] = {
12969 (char *) "self", NULL
12970 };
12971
12972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12974 if (SWIG_arg_fail(1)) SWIG_fail;
12975 {
12976 PyThreadState* __tstate = wxPyBeginAllowThreads();
12977 result = (arg1)->GetProductName();
12978
12979 wxPyEndAllowThreads(__tstate);
12980 if (PyErr_Occurred()) SWIG_fail;
12981 }
12982 {
12983 #if wxUSE_UNICODE
12984 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12985 #else
12986 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12987 #endif
12988 }
12989 return resultobj;
12990 fail:
12991 return NULL;
12992 }
12993
12994
12995 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12996 PyObject *resultobj = NULL;
12997 wxJoystick *arg1 = (wxJoystick *) 0 ;
12998 int result;
12999 PyObject * obj0 = 0 ;
13000 char *kwnames[] = {
13001 (char *) "self", NULL
13002 };
13003
13004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
13005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13006 if (SWIG_arg_fail(1)) SWIG_fail;
13007 {
13008 PyThreadState* __tstate = wxPyBeginAllowThreads();
13009 result = (int)(arg1)->GetXMin();
13010
13011 wxPyEndAllowThreads(__tstate);
13012 if (PyErr_Occurred()) SWIG_fail;
13013 }
13014 {
13015 resultobj = SWIG_From_int(static_cast<int >(result));
13016 }
13017 return resultobj;
13018 fail:
13019 return NULL;
13020 }
13021
13022
13023 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
13024 PyObject *resultobj = NULL;
13025 wxJoystick *arg1 = (wxJoystick *) 0 ;
13026 int result;
13027 PyObject * obj0 = 0 ;
13028 char *kwnames[] = {
13029 (char *) "self", NULL
13030 };
13031
13032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
13033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13034 if (SWIG_arg_fail(1)) SWIG_fail;
13035 {
13036 PyThreadState* __tstate = wxPyBeginAllowThreads();
13037 result = (int)(arg1)->GetYMin();
13038
13039 wxPyEndAllowThreads(__tstate);
13040 if (PyErr_Occurred()) SWIG_fail;
13041 }
13042 {
13043 resultobj = SWIG_From_int(static_cast<int >(result));
13044 }
13045 return resultobj;
13046 fail:
13047 return NULL;
13048 }
13049
13050
13051 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
13052 PyObject *resultobj = NULL;
13053 wxJoystick *arg1 = (wxJoystick *) 0 ;
13054 int result;
13055 PyObject * obj0 = 0 ;
13056 char *kwnames[] = {
13057 (char *) "self", NULL
13058 };
13059
13060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
13061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13062 if (SWIG_arg_fail(1)) SWIG_fail;
13063 {
13064 PyThreadState* __tstate = wxPyBeginAllowThreads();
13065 result = (int)(arg1)->GetZMin();
13066
13067 wxPyEndAllowThreads(__tstate);
13068 if (PyErr_Occurred()) SWIG_fail;
13069 }
13070 {
13071 resultobj = SWIG_From_int(static_cast<int >(result));
13072 }
13073 return resultobj;
13074 fail:
13075 return NULL;
13076 }
13077
13078
13079 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
13080 PyObject *resultobj = NULL;
13081 wxJoystick *arg1 = (wxJoystick *) 0 ;
13082 int result;
13083 PyObject * obj0 = 0 ;
13084 char *kwnames[] = {
13085 (char *) "self", NULL
13086 };
13087
13088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
13089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13090 if (SWIG_arg_fail(1)) SWIG_fail;
13091 {
13092 PyThreadState* __tstate = wxPyBeginAllowThreads();
13093 result = (int)(arg1)->GetXMax();
13094
13095 wxPyEndAllowThreads(__tstate);
13096 if (PyErr_Occurred()) SWIG_fail;
13097 }
13098 {
13099 resultobj = SWIG_From_int(static_cast<int >(result));
13100 }
13101 return resultobj;
13102 fail:
13103 return NULL;
13104 }
13105
13106
13107 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
13108 PyObject *resultobj = NULL;
13109 wxJoystick *arg1 = (wxJoystick *) 0 ;
13110 int result;
13111 PyObject * obj0 = 0 ;
13112 char *kwnames[] = {
13113 (char *) "self", NULL
13114 };
13115
13116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
13117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13118 if (SWIG_arg_fail(1)) SWIG_fail;
13119 {
13120 PyThreadState* __tstate = wxPyBeginAllowThreads();
13121 result = (int)(arg1)->GetYMax();
13122
13123 wxPyEndAllowThreads(__tstate);
13124 if (PyErr_Occurred()) SWIG_fail;
13125 }
13126 {
13127 resultobj = SWIG_From_int(static_cast<int >(result));
13128 }
13129 return resultobj;
13130 fail:
13131 return NULL;
13132 }
13133
13134
13135 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
13136 PyObject *resultobj = NULL;
13137 wxJoystick *arg1 = (wxJoystick *) 0 ;
13138 int result;
13139 PyObject * obj0 = 0 ;
13140 char *kwnames[] = {
13141 (char *) "self", NULL
13142 };
13143
13144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
13145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13146 if (SWIG_arg_fail(1)) SWIG_fail;
13147 {
13148 PyThreadState* __tstate = wxPyBeginAllowThreads();
13149 result = (int)(arg1)->GetZMax();
13150
13151 wxPyEndAllowThreads(__tstate);
13152 if (PyErr_Occurred()) SWIG_fail;
13153 }
13154 {
13155 resultobj = SWIG_From_int(static_cast<int >(result));
13156 }
13157 return resultobj;
13158 fail:
13159 return NULL;
13160 }
13161
13162
13163 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
13164 PyObject *resultobj = NULL;
13165 wxJoystick *arg1 = (wxJoystick *) 0 ;
13166 int result;
13167 PyObject * obj0 = 0 ;
13168 char *kwnames[] = {
13169 (char *) "self", NULL
13170 };
13171
13172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
13173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13174 if (SWIG_arg_fail(1)) SWIG_fail;
13175 {
13176 PyThreadState* __tstate = wxPyBeginAllowThreads();
13177 result = (int)(arg1)->GetNumberButtons();
13178
13179 wxPyEndAllowThreads(__tstate);
13180 if (PyErr_Occurred()) SWIG_fail;
13181 }
13182 {
13183 resultobj = SWIG_From_int(static_cast<int >(result));
13184 }
13185 return resultobj;
13186 fail:
13187 return NULL;
13188 }
13189
13190
13191 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
13192 PyObject *resultobj = NULL;
13193 wxJoystick *arg1 = (wxJoystick *) 0 ;
13194 int result;
13195 PyObject * obj0 = 0 ;
13196 char *kwnames[] = {
13197 (char *) "self", NULL
13198 };
13199
13200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
13201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13202 if (SWIG_arg_fail(1)) SWIG_fail;
13203 {
13204 PyThreadState* __tstate = wxPyBeginAllowThreads();
13205 result = (int)(arg1)->GetNumberAxes();
13206
13207 wxPyEndAllowThreads(__tstate);
13208 if (PyErr_Occurred()) SWIG_fail;
13209 }
13210 {
13211 resultobj = SWIG_From_int(static_cast<int >(result));
13212 }
13213 return resultobj;
13214 fail:
13215 return NULL;
13216 }
13217
13218
13219 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
13220 PyObject *resultobj = NULL;
13221 wxJoystick *arg1 = (wxJoystick *) 0 ;
13222 int result;
13223 PyObject * obj0 = 0 ;
13224 char *kwnames[] = {
13225 (char *) "self", NULL
13226 };
13227
13228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
13229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13230 if (SWIG_arg_fail(1)) SWIG_fail;
13231 {
13232 PyThreadState* __tstate = wxPyBeginAllowThreads();
13233 result = (int)(arg1)->GetMaxButtons();
13234
13235 wxPyEndAllowThreads(__tstate);
13236 if (PyErr_Occurred()) SWIG_fail;
13237 }
13238 {
13239 resultobj = SWIG_From_int(static_cast<int >(result));
13240 }
13241 return resultobj;
13242 fail:
13243 return NULL;
13244 }
13245
13246
13247 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
13248 PyObject *resultobj = NULL;
13249 wxJoystick *arg1 = (wxJoystick *) 0 ;
13250 int result;
13251 PyObject * obj0 = 0 ;
13252 char *kwnames[] = {
13253 (char *) "self", NULL
13254 };
13255
13256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
13257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13258 if (SWIG_arg_fail(1)) SWIG_fail;
13259 {
13260 PyThreadState* __tstate = wxPyBeginAllowThreads();
13261 result = (int)(arg1)->GetMaxAxes();
13262
13263 wxPyEndAllowThreads(__tstate);
13264 if (PyErr_Occurred()) SWIG_fail;
13265 }
13266 {
13267 resultobj = SWIG_From_int(static_cast<int >(result));
13268 }
13269 return resultobj;
13270 fail:
13271 return NULL;
13272 }
13273
13274
13275 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
13276 PyObject *resultobj = NULL;
13277 wxJoystick *arg1 = (wxJoystick *) 0 ;
13278 int result;
13279 PyObject * obj0 = 0 ;
13280 char *kwnames[] = {
13281 (char *) "self", NULL
13282 };
13283
13284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
13285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13286 if (SWIG_arg_fail(1)) SWIG_fail;
13287 {
13288 PyThreadState* __tstate = wxPyBeginAllowThreads();
13289 result = (int)(arg1)->GetPollingMin();
13290
13291 wxPyEndAllowThreads(__tstate);
13292 if (PyErr_Occurred()) SWIG_fail;
13293 }
13294 {
13295 resultobj = SWIG_From_int(static_cast<int >(result));
13296 }
13297 return resultobj;
13298 fail:
13299 return NULL;
13300 }
13301
13302
13303 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
13304 PyObject *resultobj = NULL;
13305 wxJoystick *arg1 = (wxJoystick *) 0 ;
13306 int result;
13307 PyObject * obj0 = 0 ;
13308 char *kwnames[] = {
13309 (char *) "self", NULL
13310 };
13311
13312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
13313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13314 if (SWIG_arg_fail(1)) SWIG_fail;
13315 {
13316 PyThreadState* __tstate = wxPyBeginAllowThreads();
13317 result = (int)(arg1)->GetPollingMax();
13318
13319 wxPyEndAllowThreads(__tstate);
13320 if (PyErr_Occurred()) SWIG_fail;
13321 }
13322 {
13323 resultobj = SWIG_From_int(static_cast<int >(result));
13324 }
13325 return resultobj;
13326 fail:
13327 return NULL;
13328 }
13329
13330
13331 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
13332 PyObject *resultobj = NULL;
13333 wxJoystick *arg1 = (wxJoystick *) 0 ;
13334 int result;
13335 PyObject * obj0 = 0 ;
13336 char *kwnames[] = {
13337 (char *) "self", NULL
13338 };
13339
13340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
13341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13342 if (SWIG_arg_fail(1)) SWIG_fail;
13343 {
13344 PyThreadState* __tstate = wxPyBeginAllowThreads();
13345 result = (int)(arg1)->GetRudderMin();
13346
13347 wxPyEndAllowThreads(__tstate);
13348 if (PyErr_Occurred()) SWIG_fail;
13349 }
13350 {
13351 resultobj = SWIG_From_int(static_cast<int >(result));
13352 }
13353 return resultobj;
13354 fail:
13355 return NULL;
13356 }
13357
13358
13359 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
13360 PyObject *resultobj = NULL;
13361 wxJoystick *arg1 = (wxJoystick *) 0 ;
13362 int result;
13363 PyObject * obj0 = 0 ;
13364 char *kwnames[] = {
13365 (char *) "self", NULL
13366 };
13367
13368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
13369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13370 if (SWIG_arg_fail(1)) SWIG_fail;
13371 {
13372 PyThreadState* __tstate = wxPyBeginAllowThreads();
13373 result = (int)(arg1)->GetRudderMax();
13374
13375 wxPyEndAllowThreads(__tstate);
13376 if (PyErr_Occurred()) SWIG_fail;
13377 }
13378 {
13379 resultobj = SWIG_From_int(static_cast<int >(result));
13380 }
13381 return resultobj;
13382 fail:
13383 return NULL;
13384 }
13385
13386
13387 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
13388 PyObject *resultobj = NULL;
13389 wxJoystick *arg1 = (wxJoystick *) 0 ;
13390 int result;
13391 PyObject * obj0 = 0 ;
13392 char *kwnames[] = {
13393 (char *) "self", NULL
13394 };
13395
13396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
13397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13398 if (SWIG_arg_fail(1)) SWIG_fail;
13399 {
13400 PyThreadState* __tstate = wxPyBeginAllowThreads();
13401 result = (int)(arg1)->GetUMin();
13402
13403 wxPyEndAllowThreads(__tstate);
13404 if (PyErr_Occurred()) SWIG_fail;
13405 }
13406 {
13407 resultobj = SWIG_From_int(static_cast<int >(result));
13408 }
13409 return resultobj;
13410 fail:
13411 return NULL;
13412 }
13413
13414
13415 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
13416 PyObject *resultobj = NULL;
13417 wxJoystick *arg1 = (wxJoystick *) 0 ;
13418 int result;
13419 PyObject * obj0 = 0 ;
13420 char *kwnames[] = {
13421 (char *) "self", NULL
13422 };
13423
13424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
13425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13426 if (SWIG_arg_fail(1)) SWIG_fail;
13427 {
13428 PyThreadState* __tstate = wxPyBeginAllowThreads();
13429 result = (int)(arg1)->GetUMax();
13430
13431 wxPyEndAllowThreads(__tstate);
13432 if (PyErr_Occurred()) SWIG_fail;
13433 }
13434 {
13435 resultobj = SWIG_From_int(static_cast<int >(result));
13436 }
13437 return resultobj;
13438 fail:
13439 return NULL;
13440 }
13441
13442
13443 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
13444 PyObject *resultobj = NULL;
13445 wxJoystick *arg1 = (wxJoystick *) 0 ;
13446 int result;
13447 PyObject * obj0 = 0 ;
13448 char *kwnames[] = {
13449 (char *) "self", NULL
13450 };
13451
13452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
13453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13454 if (SWIG_arg_fail(1)) SWIG_fail;
13455 {
13456 PyThreadState* __tstate = wxPyBeginAllowThreads();
13457 result = (int)(arg1)->GetVMin();
13458
13459 wxPyEndAllowThreads(__tstate);
13460 if (PyErr_Occurred()) SWIG_fail;
13461 }
13462 {
13463 resultobj = SWIG_From_int(static_cast<int >(result));
13464 }
13465 return resultobj;
13466 fail:
13467 return NULL;
13468 }
13469
13470
13471 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
13472 PyObject *resultobj = NULL;
13473 wxJoystick *arg1 = (wxJoystick *) 0 ;
13474 int result;
13475 PyObject * obj0 = 0 ;
13476 char *kwnames[] = {
13477 (char *) "self", NULL
13478 };
13479
13480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
13481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13482 if (SWIG_arg_fail(1)) SWIG_fail;
13483 {
13484 PyThreadState* __tstate = wxPyBeginAllowThreads();
13485 result = (int)(arg1)->GetVMax();
13486
13487 wxPyEndAllowThreads(__tstate);
13488 if (PyErr_Occurred()) SWIG_fail;
13489 }
13490 {
13491 resultobj = SWIG_From_int(static_cast<int >(result));
13492 }
13493 return resultobj;
13494 fail:
13495 return NULL;
13496 }
13497
13498
13499 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
13500 PyObject *resultobj = NULL;
13501 wxJoystick *arg1 = (wxJoystick *) 0 ;
13502 bool result;
13503 PyObject * obj0 = 0 ;
13504 char *kwnames[] = {
13505 (char *) "self", NULL
13506 };
13507
13508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
13509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13510 if (SWIG_arg_fail(1)) SWIG_fail;
13511 {
13512 PyThreadState* __tstate = wxPyBeginAllowThreads();
13513 result = (bool)(arg1)->HasRudder();
13514
13515 wxPyEndAllowThreads(__tstate);
13516 if (PyErr_Occurred()) SWIG_fail;
13517 }
13518 {
13519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13520 }
13521 return resultobj;
13522 fail:
13523 return NULL;
13524 }
13525
13526
13527 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
13528 PyObject *resultobj = NULL;
13529 wxJoystick *arg1 = (wxJoystick *) 0 ;
13530 bool result;
13531 PyObject * obj0 = 0 ;
13532 char *kwnames[] = {
13533 (char *) "self", NULL
13534 };
13535
13536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
13537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13538 if (SWIG_arg_fail(1)) SWIG_fail;
13539 {
13540 PyThreadState* __tstate = wxPyBeginAllowThreads();
13541 result = (bool)(arg1)->HasZ();
13542
13543 wxPyEndAllowThreads(__tstate);
13544 if (PyErr_Occurred()) SWIG_fail;
13545 }
13546 {
13547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13548 }
13549 return resultobj;
13550 fail:
13551 return NULL;
13552 }
13553
13554
13555 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
13556 PyObject *resultobj = NULL;
13557 wxJoystick *arg1 = (wxJoystick *) 0 ;
13558 bool result;
13559 PyObject * obj0 = 0 ;
13560 char *kwnames[] = {
13561 (char *) "self", NULL
13562 };
13563
13564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
13565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13566 if (SWIG_arg_fail(1)) SWIG_fail;
13567 {
13568 PyThreadState* __tstate = wxPyBeginAllowThreads();
13569 result = (bool)(arg1)->HasU();
13570
13571 wxPyEndAllowThreads(__tstate);
13572 if (PyErr_Occurred()) SWIG_fail;
13573 }
13574 {
13575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13576 }
13577 return resultobj;
13578 fail:
13579 return NULL;
13580 }
13581
13582
13583 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
13584 PyObject *resultobj = NULL;
13585 wxJoystick *arg1 = (wxJoystick *) 0 ;
13586 bool result;
13587 PyObject * obj0 = 0 ;
13588 char *kwnames[] = {
13589 (char *) "self", NULL
13590 };
13591
13592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
13593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13594 if (SWIG_arg_fail(1)) SWIG_fail;
13595 {
13596 PyThreadState* __tstate = wxPyBeginAllowThreads();
13597 result = (bool)(arg1)->HasV();
13598
13599 wxPyEndAllowThreads(__tstate);
13600 if (PyErr_Occurred()) SWIG_fail;
13601 }
13602 {
13603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13604 }
13605 return resultobj;
13606 fail:
13607 return NULL;
13608 }
13609
13610
13611 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
13612 PyObject *resultobj = NULL;
13613 wxJoystick *arg1 = (wxJoystick *) 0 ;
13614 bool result;
13615 PyObject * obj0 = 0 ;
13616 char *kwnames[] = {
13617 (char *) "self", NULL
13618 };
13619
13620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
13621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13622 if (SWIG_arg_fail(1)) SWIG_fail;
13623 {
13624 PyThreadState* __tstate = wxPyBeginAllowThreads();
13625 result = (bool)(arg1)->HasPOV();
13626
13627 wxPyEndAllowThreads(__tstate);
13628 if (PyErr_Occurred()) SWIG_fail;
13629 }
13630 {
13631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13632 }
13633 return resultobj;
13634 fail:
13635 return NULL;
13636 }
13637
13638
13639 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
13640 PyObject *resultobj = NULL;
13641 wxJoystick *arg1 = (wxJoystick *) 0 ;
13642 bool result;
13643 PyObject * obj0 = 0 ;
13644 char *kwnames[] = {
13645 (char *) "self", NULL
13646 };
13647
13648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
13649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13650 if (SWIG_arg_fail(1)) SWIG_fail;
13651 {
13652 PyThreadState* __tstate = wxPyBeginAllowThreads();
13653 result = (bool)(arg1)->HasPOV4Dir();
13654
13655 wxPyEndAllowThreads(__tstate);
13656 if (PyErr_Occurred()) SWIG_fail;
13657 }
13658 {
13659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13660 }
13661 return resultobj;
13662 fail:
13663 return NULL;
13664 }
13665
13666
13667 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
13668 PyObject *resultobj = NULL;
13669 wxJoystick *arg1 = (wxJoystick *) 0 ;
13670 bool result;
13671 PyObject * obj0 = 0 ;
13672 char *kwnames[] = {
13673 (char *) "self", NULL
13674 };
13675
13676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
13677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13678 if (SWIG_arg_fail(1)) SWIG_fail;
13679 {
13680 PyThreadState* __tstate = wxPyBeginAllowThreads();
13681 result = (bool)(arg1)->HasPOVCTS();
13682
13683 wxPyEndAllowThreads(__tstate);
13684 if (PyErr_Occurred()) SWIG_fail;
13685 }
13686 {
13687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13688 }
13689 return resultobj;
13690 fail:
13691 return NULL;
13692 }
13693
13694
13695 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
13696 PyObject *resultobj = NULL;
13697 wxJoystick *arg1 = (wxJoystick *) 0 ;
13698 wxWindow *arg2 = (wxWindow *) 0 ;
13699 int arg3 = (int) 0 ;
13700 bool result;
13701 PyObject * obj0 = 0 ;
13702 PyObject * obj1 = 0 ;
13703 PyObject * obj2 = 0 ;
13704 char *kwnames[] = {
13705 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
13706 };
13707
13708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
13709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13710 if (SWIG_arg_fail(1)) SWIG_fail;
13711 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13712 if (SWIG_arg_fail(2)) SWIG_fail;
13713 if (obj2) {
13714 {
13715 arg3 = static_cast<int >(SWIG_As_int(obj2));
13716 if (SWIG_arg_fail(3)) SWIG_fail;
13717 }
13718 }
13719 {
13720 PyThreadState* __tstate = wxPyBeginAllowThreads();
13721 result = (bool)(arg1)->SetCapture(arg2,arg3);
13722
13723 wxPyEndAllowThreads(__tstate);
13724 if (PyErr_Occurred()) SWIG_fail;
13725 }
13726 {
13727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13728 }
13729 return resultobj;
13730 fail:
13731 return NULL;
13732 }
13733
13734
13735 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
13736 PyObject *resultobj = NULL;
13737 wxJoystick *arg1 = (wxJoystick *) 0 ;
13738 bool result;
13739 PyObject * obj0 = 0 ;
13740 char *kwnames[] = {
13741 (char *) "self", NULL
13742 };
13743
13744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
13745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13746 if (SWIG_arg_fail(1)) SWIG_fail;
13747 {
13748 PyThreadState* __tstate = wxPyBeginAllowThreads();
13749 result = (bool)(arg1)->ReleaseCapture();
13750
13751 wxPyEndAllowThreads(__tstate);
13752 if (PyErr_Occurred()) SWIG_fail;
13753 }
13754 {
13755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13756 }
13757 return resultobj;
13758 fail:
13759 return NULL;
13760 }
13761
13762
13763 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
13764 PyObject *obj;
13765 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13766 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
13767 Py_INCREF(obj);
13768 return Py_BuildValue((char *)"");
13769 }
13770 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
13771 PyObject *resultobj = NULL;
13772 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
13773 int arg2 = (int) 0 ;
13774 int arg3 = (int) wxJOYSTICK1 ;
13775 int arg4 = (int) 0 ;
13776 wxJoystickEvent *result;
13777 PyObject * obj0 = 0 ;
13778 PyObject * obj1 = 0 ;
13779 PyObject * obj2 = 0 ;
13780 PyObject * obj3 = 0 ;
13781 char *kwnames[] = {
13782 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
13783 };
13784
13785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13786 if (obj0) {
13787 {
13788 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
13789 if (SWIG_arg_fail(1)) SWIG_fail;
13790 }
13791 }
13792 if (obj1) {
13793 {
13794 arg2 = static_cast<int >(SWIG_As_int(obj1));
13795 if (SWIG_arg_fail(2)) SWIG_fail;
13796 }
13797 }
13798 if (obj2) {
13799 {
13800 arg3 = static_cast<int >(SWIG_As_int(obj2));
13801 if (SWIG_arg_fail(3)) SWIG_fail;
13802 }
13803 }
13804 if (obj3) {
13805 {
13806 arg4 = static_cast<int >(SWIG_As_int(obj3));
13807 if (SWIG_arg_fail(4)) SWIG_fail;
13808 }
13809 }
13810 {
13811 PyThreadState* __tstate = wxPyBeginAllowThreads();
13812 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
13813
13814 wxPyEndAllowThreads(__tstate);
13815 if (PyErr_Occurred()) SWIG_fail;
13816 }
13817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
13818 return resultobj;
13819 fail:
13820 return NULL;
13821 }
13822
13823
13824 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13825 PyObject *resultobj = NULL;
13826 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13827 wxPoint result;
13828 PyObject * obj0 = 0 ;
13829 char *kwnames[] = {
13830 (char *) "self", NULL
13831 };
13832
13833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
13834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13835 if (SWIG_arg_fail(1)) SWIG_fail;
13836 {
13837 PyThreadState* __tstate = wxPyBeginAllowThreads();
13838 result = ((wxJoystickEvent const *)arg1)->GetPosition();
13839
13840 wxPyEndAllowThreads(__tstate);
13841 if (PyErr_Occurred()) SWIG_fail;
13842 }
13843 {
13844 wxPoint * resultptr;
13845 resultptr = new wxPoint(static_cast<wxPoint & >(result));
13846 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
13847 }
13848 return resultobj;
13849 fail:
13850 return NULL;
13851 }
13852
13853
13854 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13855 PyObject *resultobj = NULL;
13856 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13857 int result;
13858 PyObject * obj0 = 0 ;
13859 char *kwnames[] = {
13860 (char *) "self", NULL
13861 };
13862
13863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
13864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13865 if (SWIG_arg_fail(1)) SWIG_fail;
13866 {
13867 PyThreadState* __tstate = wxPyBeginAllowThreads();
13868 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
13869
13870 wxPyEndAllowThreads(__tstate);
13871 if (PyErr_Occurred()) SWIG_fail;
13872 }
13873 {
13874 resultobj = SWIG_From_int(static_cast<int >(result));
13875 }
13876 return resultobj;
13877 fail:
13878 return NULL;
13879 }
13880
13881
13882 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13883 PyObject *resultobj = NULL;
13884 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13885 int result;
13886 PyObject * obj0 = 0 ;
13887 char *kwnames[] = {
13888 (char *) "self", NULL
13889 };
13890
13891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13893 if (SWIG_arg_fail(1)) SWIG_fail;
13894 {
13895 PyThreadState* __tstate = wxPyBeginAllowThreads();
13896 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13897
13898 wxPyEndAllowThreads(__tstate);
13899 if (PyErr_Occurred()) SWIG_fail;
13900 }
13901 {
13902 resultobj = SWIG_From_int(static_cast<int >(result));
13903 }
13904 return resultobj;
13905 fail:
13906 return NULL;
13907 }
13908
13909
13910 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13911 PyObject *resultobj = NULL;
13912 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13913 int result;
13914 PyObject * obj0 = 0 ;
13915 char *kwnames[] = {
13916 (char *) "self", NULL
13917 };
13918
13919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13921 if (SWIG_arg_fail(1)) SWIG_fail;
13922 {
13923 PyThreadState* __tstate = wxPyBeginAllowThreads();
13924 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13925
13926 wxPyEndAllowThreads(__tstate);
13927 if (PyErr_Occurred()) SWIG_fail;
13928 }
13929 {
13930 resultobj = SWIG_From_int(static_cast<int >(result));
13931 }
13932 return resultobj;
13933 fail:
13934 return NULL;
13935 }
13936
13937
13938 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13939 PyObject *resultobj = NULL;
13940 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13941 int result;
13942 PyObject * obj0 = 0 ;
13943 char *kwnames[] = {
13944 (char *) "self", NULL
13945 };
13946
13947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13949 if (SWIG_arg_fail(1)) SWIG_fail;
13950 {
13951 PyThreadState* __tstate = wxPyBeginAllowThreads();
13952 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13953
13954 wxPyEndAllowThreads(__tstate);
13955 if (PyErr_Occurred()) SWIG_fail;
13956 }
13957 {
13958 resultobj = SWIG_From_int(static_cast<int >(result));
13959 }
13960 return resultobj;
13961 fail:
13962 return NULL;
13963 }
13964
13965
13966 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13967 PyObject *resultobj = NULL;
13968 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13969 int arg2 ;
13970 PyObject * obj0 = 0 ;
13971 PyObject * obj1 = 0 ;
13972 char *kwnames[] = {
13973 (char *) "self",(char *) "stick", NULL
13974 };
13975
13976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13978 if (SWIG_arg_fail(1)) SWIG_fail;
13979 {
13980 arg2 = static_cast<int >(SWIG_As_int(obj1));
13981 if (SWIG_arg_fail(2)) SWIG_fail;
13982 }
13983 {
13984 PyThreadState* __tstate = wxPyBeginAllowThreads();
13985 (arg1)->SetJoystick(arg2);
13986
13987 wxPyEndAllowThreads(__tstate);
13988 if (PyErr_Occurred()) SWIG_fail;
13989 }
13990 Py_INCREF(Py_None); resultobj = Py_None;
13991 return resultobj;
13992 fail:
13993 return NULL;
13994 }
13995
13996
13997 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13998 PyObject *resultobj = NULL;
13999 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14000 int arg2 ;
14001 PyObject * obj0 = 0 ;
14002 PyObject * obj1 = 0 ;
14003 char *kwnames[] = {
14004 (char *) "self",(char *) "state", NULL
14005 };
14006
14007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
14008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14009 if (SWIG_arg_fail(1)) SWIG_fail;
14010 {
14011 arg2 = static_cast<int >(SWIG_As_int(obj1));
14012 if (SWIG_arg_fail(2)) SWIG_fail;
14013 }
14014 {
14015 PyThreadState* __tstate = wxPyBeginAllowThreads();
14016 (arg1)->SetButtonState(arg2);
14017
14018 wxPyEndAllowThreads(__tstate);
14019 if (PyErr_Occurred()) SWIG_fail;
14020 }
14021 Py_INCREF(Py_None); resultobj = Py_None;
14022 return resultobj;
14023 fail:
14024 return NULL;
14025 }
14026
14027
14028 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
14029 PyObject *resultobj = NULL;
14030 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14031 int arg2 ;
14032 PyObject * obj0 = 0 ;
14033 PyObject * obj1 = 0 ;
14034 char *kwnames[] = {
14035 (char *) "self",(char *) "change", NULL
14036 };
14037
14038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
14039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14040 if (SWIG_arg_fail(1)) SWIG_fail;
14041 {
14042 arg2 = static_cast<int >(SWIG_As_int(obj1));
14043 if (SWIG_arg_fail(2)) SWIG_fail;
14044 }
14045 {
14046 PyThreadState* __tstate = wxPyBeginAllowThreads();
14047 (arg1)->SetButtonChange(arg2);
14048
14049 wxPyEndAllowThreads(__tstate);
14050 if (PyErr_Occurred()) SWIG_fail;
14051 }
14052 Py_INCREF(Py_None); resultobj = Py_None;
14053 return resultobj;
14054 fail:
14055 return NULL;
14056 }
14057
14058
14059 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
14060 PyObject *resultobj = NULL;
14061 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14062 wxPoint *arg2 = 0 ;
14063 wxPoint temp2 ;
14064 PyObject * obj0 = 0 ;
14065 PyObject * obj1 = 0 ;
14066 char *kwnames[] = {
14067 (char *) "self",(char *) "pos", NULL
14068 };
14069
14070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
14071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14072 if (SWIG_arg_fail(1)) SWIG_fail;
14073 {
14074 arg2 = &temp2;
14075 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14076 }
14077 {
14078 PyThreadState* __tstate = wxPyBeginAllowThreads();
14079 (arg1)->SetPosition((wxPoint const &)*arg2);
14080
14081 wxPyEndAllowThreads(__tstate);
14082 if (PyErr_Occurred()) SWIG_fail;
14083 }
14084 Py_INCREF(Py_None); resultobj = Py_None;
14085 return resultobj;
14086 fail:
14087 return NULL;
14088 }
14089
14090
14091 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
14092 PyObject *resultobj = NULL;
14093 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14094 int arg2 ;
14095 PyObject * obj0 = 0 ;
14096 PyObject * obj1 = 0 ;
14097 char *kwnames[] = {
14098 (char *) "self",(char *) "zPos", NULL
14099 };
14100
14101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
14102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14103 if (SWIG_arg_fail(1)) SWIG_fail;
14104 {
14105 arg2 = static_cast<int >(SWIG_As_int(obj1));
14106 if (SWIG_arg_fail(2)) SWIG_fail;
14107 }
14108 {
14109 PyThreadState* __tstate = wxPyBeginAllowThreads();
14110 (arg1)->SetZPosition(arg2);
14111
14112 wxPyEndAllowThreads(__tstate);
14113 if (PyErr_Occurred()) SWIG_fail;
14114 }
14115 Py_INCREF(Py_None); resultobj = Py_None;
14116 return resultobj;
14117 fail:
14118 return NULL;
14119 }
14120
14121
14122 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
14123 PyObject *resultobj = NULL;
14124 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14125 bool result;
14126 PyObject * obj0 = 0 ;
14127 char *kwnames[] = {
14128 (char *) "self", NULL
14129 };
14130
14131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
14132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14133 if (SWIG_arg_fail(1)) SWIG_fail;
14134 {
14135 PyThreadState* __tstate = wxPyBeginAllowThreads();
14136 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
14137
14138 wxPyEndAllowThreads(__tstate);
14139 if (PyErr_Occurred()) SWIG_fail;
14140 }
14141 {
14142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14143 }
14144 return resultobj;
14145 fail:
14146 return NULL;
14147 }
14148
14149
14150 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj = NULL;
14152 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14153 bool result;
14154 PyObject * obj0 = 0 ;
14155 char *kwnames[] = {
14156 (char *) "self", NULL
14157 };
14158
14159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
14160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14161 if (SWIG_arg_fail(1)) SWIG_fail;
14162 {
14163 PyThreadState* __tstate = wxPyBeginAllowThreads();
14164 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
14165
14166 wxPyEndAllowThreads(__tstate);
14167 if (PyErr_Occurred()) SWIG_fail;
14168 }
14169 {
14170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14171 }
14172 return resultobj;
14173 fail:
14174 return NULL;
14175 }
14176
14177
14178 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
14179 PyObject *resultobj = NULL;
14180 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14181 bool result;
14182 PyObject * obj0 = 0 ;
14183 char *kwnames[] = {
14184 (char *) "self", NULL
14185 };
14186
14187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
14188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14189 if (SWIG_arg_fail(1)) SWIG_fail;
14190 {
14191 PyThreadState* __tstate = wxPyBeginAllowThreads();
14192 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
14193
14194 wxPyEndAllowThreads(__tstate);
14195 if (PyErr_Occurred()) SWIG_fail;
14196 }
14197 {
14198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14199 }
14200 return resultobj;
14201 fail:
14202 return NULL;
14203 }
14204
14205
14206 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
14207 PyObject *resultobj = NULL;
14208 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14209 int arg2 = (int) wxJOY_BUTTON_ANY ;
14210 bool result;
14211 PyObject * obj0 = 0 ;
14212 PyObject * obj1 = 0 ;
14213 char *kwnames[] = {
14214 (char *) "self",(char *) "but", NULL
14215 };
14216
14217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
14218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14219 if (SWIG_arg_fail(1)) SWIG_fail;
14220 if (obj1) {
14221 {
14222 arg2 = static_cast<int >(SWIG_As_int(obj1));
14223 if (SWIG_arg_fail(2)) SWIG_fail;
14224 }
14225 }
14226 {
14227 PyThreadState* __tstate = wxPyBeginAllowThreads();
14228 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
14229
14230 wxPyEndAllowThreads(__tstate);
14231 if (PyErr_Occurred()) SWIG_fail;
14232 }
14233 {
14234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14235 }
14236 return resultobj;
14237 fail:
14238 return NULL;
14239 }
14240
14241
14242 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
14243 PyObject *resultobj = NULL;
14244 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14245 int arg2 = (int) wxJOY_BUTTON_ANY ;
14246 bool result;
14247 PyObject * obj0 = 0 ;
14248 PyObject * obj1 = 0 ;
14249 char *kwnames[] = {
14250 (char *) "self",(char *) "but", NULL
14251 };
14252
14253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
14254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14255 if (SWIG_arg_fail(1)) SWIG_fail;
14256 if (obj1) {
14257 {
14258 arg2 = static_cast<int >(SWIG_As_int(obj1));
14259 if (SWIG_arg_fail(2)) SWIG_fail;
14260 }
14261 }
14262 {
14263 PyThreadState* __tstate = wxPyBeginAllowThreads();
14264 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
14265
14266 wxPyEndAllowThreads(__tstate);
14267 if (PyErr_Occurred()) SWIG_fail;
14268 }
14269 {
14270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14271 }
14272 return resultobj;
14273 fail:
14274 return NULL;
14275 }
14276
14277
14278 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
14279 PyObject *resultobj = NULL;
14280 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14281 int arg2 = (int) wxJOY_BUTTON_ANY ;
14282 bool result;
14283 PyObject * obj0 = 0 ;
14284 PyObject * obj1 = 0 ;
14285 char *kwnames[] = {
14286 (char *) "self",(char *) "but", NULL
14287 };
14288
14289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
14290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14291 if (SWIG_arg_fail(1)) SWIG_fail;
14292 if (obj1) {
14293 {
14294 arg2 = static_cast<int >(SWIG_As_int(obj1));
14295 if (SWIG_arg_fail(2)) SWIG_fail;
14296 }
14297 }
14298 {
14299 PyThreadState* __tstate = wxPyBeginAllowThreads();
14300 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
14301
14302 wxPyEndAllowThreads(__tstate);
14303 if (PyErr_Occurred()) SWIG_fail;
14304 }
14305 {
14306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14307 }
14308 return resultobj;
14309 fail:
14310 return NULL;
14311 }
14312
14313
14314 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
14315 PyObject *obj;
14316 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14317 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
14318 Py_INCREF(obj);
14319 return Py_BuildValue((char *)"");
14320 }
14321 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
14322 PyObject *resultobj = NULL;
14323 wxString const &arg1_defvalue = wxPyEmptyString ;
14324 wxString *arg1 = (wxString *) &arg1_defvalue ;
14325 wxSound *result;
14326 bool temp1 = false ;
14327 PyObject * obj0 = 0 ;
14328 char *kwnames[] = {
14329 (char *) "fileName", NULL
14330 };
14331
14332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
14333 if (obj0) {
14334 {
14335 arg1 = wxString_in_helper(obj0);
14336 if (arg1 == NULL) SWIG_fail;
14337 temp1 = true;
14338 }
14339 }
14340 {
14341 if (!wxPyCheckForApp()) SWIG_fail;
14342 PyThreadState* __tstate = wxPyBeginAllowThreads();
14343 result = (wxSound *)new_wxSound((wxString const &)*arg1);
14344
14345 wxPyEndAllowThreads(__tstate);
14346 if (PyErr_Occurred()) SWIG_fail;
14347 }
14348 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
14349 {
14350 if (temp1)
14351 delete arg1;
14352 }
14353 return resultobj;
14354 fail:
14355 {
14356 if (temp1)
14357 delete arg1;
14358 }
14359 return NULL;
14360 }
14361
14362
14363 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
14364 PyObject *resultobj = NULL;
14365 PyObject *arg1 = (PyObject *) 0 ;
14366 wxSound *result;
14367 PyObject * obj0 = 0 ;
14368 char *kwnames[] = {
14369 (char *) "data", NULL
14370 };
14371
14372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
14373 arg1 = obj0;
14374 {
14375 if (!wxPyCheckForApp()) SWIG_fail;
14376 PyThreadState* __tstate = wxPyBeginAllowThreads();
14377 result = (wxSound *)new_wxSound(arg1);
14378
14379 wxPyEndAllowThreads(__tstate);
14380 if (PyErr_Occurred()) SWIG_fail;
14381 }
14382 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
14383 return resultobj;
14384 fail:
14385 return NULL;
14386 }
14387
14388
14389 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
14390 PyObject *resultobj = NULL;
14391 wxSound *arg1 = (wxSound *) 0 ;
14392 PyObject * obj0 = 0 ;
14393 char *kwnames[] = {
14394 (char *) "self", NULL
14395 };
14396
14397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
14398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14399 if (SWIG_arg_fail(1)) SWIG_fail;
14400 {
14401 PyThreadState* __tstate = wxPyBeginAllowThreads();
14402 delete arg1;
14403
14404 wxPyEndAllowThreads(__tstate);
14405 if (PyErr_Occurred()) SWIG_fail;
14406 }
14407 Py_INCREF(Py_None); resultobj = Py_None;
14408 return resultobj;
14409 fail:
14410 return NULL;
14411 }
14412
14413
14414 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
14415 PyObject *resultobj = NULL;
14416 wxSound *arg1 = (wxSound *) 0 ;
14417 wxString *arg2 = 0 ;
14418 bool result;
14419 bool temp2 = false ;
14420 PyObject * obj0 = 0 ;
14421 PyObject * obj1 = 0 ;
14422 char *kwnames[] = {
14423 (char *) "self",(char *) "fileName", NULL
14424 };
14425
14426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
14427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14428 if (SWIG_arg_fail(1)) SWIG_fail;
14429 {
14430 arg2 = wxString_in_helper(obj1);
14431 if (arg2 == NULL) SWIG_fail;
14432 temp2 = true;
14433 }
14434 {
14435 PyThreadState* __tstate = wxPyBeginAllowThreads();
14436 result = (bool)(arg1)->Create((wxString const &)*arg2);
14437
14438 wxPyEndAllowThreads(__tstate);
14439 if (PyErr_Occurred()) SWIG_fail;
14440 }
14441 {
14442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14443 }
14444 {
14445 if (temp2)
14446 delete arg2;
14447 }
14448 return resultobj;
14449 fail:
14450 {
14451 if (temp2)
14452 delete arg2;
14453 }
14454 return NULL;
14455 }
14456
14457
14458 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
14459 PyObject *resultobj = NULL;
14460 wxSound *arg1 = (wxSound *) 0 ;
14461 PyObject *arg2 = (PyObject *) 0 ;
14462 bool result;
14463 PyObject * obj0 = 0 ;
14464 PyObject * obj1 = 0 ;
14465 char *kwnames[] = {
14466 (char *) "self",(char *) "data", NULL
14467 };
14468
14469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
14470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14471 if (SWIG_arg_fail(1)) SWIG_fail;
14472 arg2 = obj1;
14473 {
14474 PyThreadState* __tstate = wxPyBeginAllowThreads();
14475 result = (bool)wxSound_CreateFromData(arg1,arg2);
14476
14477 wxPyEndAllowThreads(__tstate);
14478 if (PyErr_Occurred()) SWIG_fail;
14479 }
14480 {
14481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14482 }
14483 return resultobj;
14484 fail:
14485 return NULL;
14486 }
14487
14488
14489 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
14490 PyObject *resultobj = NULL;
14491 wxSound *arg1 = (wxSound *) 0 ;
14492 bool result;
14493 PyObject * obj0 = 0 ;
14494 char *kwnames[] = {
14495 (char *) "self", NULL
14496 };
14497
14498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
14499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14500 if (SWIG_arg_fail(1)) SWIG_fail;
14501 {
14502 PyThreadState* __tstate = wxPyBeginAllowThreads();
14503 result = (bool)(arg1)->IsOk();
14504
14505 wxPyEndAllowThreads(__tstate);
14506 if (PyErr_Occurred()) SWIG_fail;
14507 }
14508 {
14509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14510 }
14511 return resultobj;
14512 fail:
14513 return NULL;
14514 }
14515
14516
14517 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
14518 PyObject *resultobj = NULL;
14519 wxSound *arg1 = (wxSound *) 0 ;
14520 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
14521 bool result;
14522 PyObject * obj0 = 0 ;
14523 PyObject * obj1 = 0 ;
14524 char *kwnames[] = {
14525 (char *) "self",(char *) "flags", NULL
14526 };
14527
14528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
14529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14530 if (SWIG_arg_fail(1)) SWIG_fail;
14531 if (obj1) {
14532 {
14533 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
14534 if (SWIG_arg_fail(2)) SWIG_fail;
14535 }
14536 }
14537 {
14538 if (!wxPyCheckForApp()) SWIG_fail;
14539 PyThreadState* __tstate = wxPyBeginAllowThreads();
14540 result = (bool)((wxSound const *)arg1)->Play(arg2);
14541
14542 wxPyEndAllowThreads(__tstate);
14543 if (PyErr_Occurred()) SWIG_fail;
14544 }
14545 {
14546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14547 }
14548 return resultobj;
14549 fail:
14550 return NULL;
14551 }
14552
14553
14554 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
14555 PyObject *resultobj = NULL;
14556 wxString *arg1 = 0 ;
14557 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
14558 bool result;
14559 bool temp1 = false ;
14560 PyObject * obj0 = 0 ;
14561 PyObject * obj1 = 0 ;
14562 char *kwnames[] = {
14563 (char *) "filename",(char *) "flags", NULL
14564 };
14565
14566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
14567 {
14568 arg1 = wxString_in_helper(obj0);
14569 if (arg1 == NULL) SWIG_fail;
14570 temp1 = true;
14571 }
14572 if (obj1) {
14573 {
14574 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
14575 if (SWIG_arg_fail(2)) SWIG_fail;
14576 }
14577 }
14578 {
14579 if (!wxPyCheckForApp()) SWIG_fail;
14580 PyThreadState* __tstate = wxPyBeginAllowThreads();
14581 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
14582
14583 wxPyEndAllowThreads(__tstate);
14584 if (PyErr_Occurred()) SWIG_fail;
14585 }
14586 {
14587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14588 }
14589 {
14590 if (temp1)
14591 delete arg1;
14592 }
14593 return resultobj;
14594 fail:
14595 {
14596 if (temp1)
14597 delete arg1;
14598 }
14599 return NULL;
14600 }
14601
14602
14603 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
14604 PyObject *resultobj = NULL;
14605 char *kwnames[] = {
14606 NULL
14607 };
14608
14609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
14610 {
14611 if (!wxPyCheckForApp()) SWIG_fail;
14612 PyThreadState* __tstate = wxPyBeginAllowThreads();
14613 wxSound::Stop();
14614
14615 wxPyEndAllowThreads(__tstate);
14616 if (PyErr_Occurred()) SWIG_fail;
14617 }
14618 Py_INCREF(Py_None); resultobj = Py_None;
14619 return resultobj;
14620 fail:
14621 return NULL;
14622 }
14623
14624
14625 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
14626 PyObject *obj;
14627 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14628 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
14629 Py_INCREF(obj);
14630 return Py_BuildValue((char *)"");
14631 }
14632 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14633 PyObject *resultobj = NULL;
14634 wxString *arg1 = 0 ;
14635 wxString *arg2 = 0 ;
14636 wxString *arg3 = 0 ;
14637 wxString *arg4 = 0 ;
14638 wxFileTypeInfo *result;
14639 bool temp1 = false ;
14640 bool temp2 = false ;
14641 bool temp3 = false ;
14642 bool temp4 = false ;
14643 PyObject * obj0 = 0 ;
14644 PyObject * obj1 = 0 ;
14645 PyObject * obj2 = 0 ;
14646 PyObject * obj3 = 0 ;
14647 char *kwnames[] = {
14648 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
14649 };
14650
14651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14652 {
14653 arg1 = wxString_in_helper(obj0);
14654 if (arg1 == NULL) SWIG_fail;
14655 temp1 = true;
14656 }
14657 {
14658 arg2 = wxString_in_helper(obj1);
14659 if (arg2 == NULL) SWIG_fail;
14660 temp2 = true;
14661 }
14662 {
14663 arg3 = wxString_in_helper(obj2);
14664 if (arg3 == NULL) SWIG_fail;
14665 temp3 = true;
14666 }
14667 {
14668 arg4 = wxString_in_helper(obj3);
14669 if (arg4 == NULL) SWIG_fail;
14670 temp4 = true;
14671 }
14672 {
14673 PyThreadState* __tstate = wxPyBeginAllowThreads();
14674 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
14675
14676 wxPyEndAllowThreads(__tstate);
14677 if (PyErr_Occurred()) SWIG_fail;
14678 }
14679 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
14680 {
14681 if (temp1)
14682 delete arg1;
14683 }
14684 {
14685 if (temp2)
14686 delete arg2;
14687 }
14688 {
14689 if (temp3)
14690 delete arg3;
14691 }
14692 {
14693 if (temp4)
14694 delete arg4;
14695 }
14696 return resultobj;
14697 fail:
14698 {
14699 if (temp1)
14700 delete arg1;
14701 }
14702 {
14703 if (temp2)
14704 delete arg2;
14705 }
14706 {
14707 if (temp3)
14708 delete arg3;
14709 }
14710 {
14711 if (temp4)
14712 delete arg4;
14713 }
14714 return NULL;
14715 }
14716
14717
14718 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
14719 PyObject *resultobj = NULL;
14720 wxArrayString *arg1 = 0 ;
14721 wxFileTypeInfo *result;
14722 bool temp1 = false ;
14723 PyObject * obj0 = 0 ;
14724 char *kwnames[] = {
14725 (char *) "sArray", NULL
14726 };
14727
14728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
14729 {
14730 if (! PySequence_Check(obj0)) {
14731 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
14732 SWIG_fail;
14733 }
14734 arg1 = new wxArrayString;
14735 temp1 = true;
14736 int i, len=PySequence_Length(obj0);
14737 for (i=0; i<len; i++) {
14738 PyObject* item = PySequence_GetItem(obj0, i);
14739 wxString* s = wxString_in_helper(item);
14740 if (PyErr_Occurred()) SWIG_fail;
14741 arg1->Add(*s);
14742 delete s;
14743 Py_DECREF(item);
14744 }
14745 }
14746 {
14747 PyThreadState* __tstate = wxPyBeginAllowThreads();
14748 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
14749
14750 wxPyEndAllowThreads(__tstate);
14751 if (PyErr_Occurred()) SWIG_fail;
14752 }
14753 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
14754 {
14755 if (temp1) delete arg1;
14756 }
14757 return resultobj;
14758 fail:
14759 {
14760 if (temp1) delete arg1;
14761 }
14762 return NULL;
14763 }
14764
14765
14766 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14767 PyObject *resultobj = NULL;
14768 wxFileTypeInfo *result;
14769 char *kwnames[] = {
14770 NULL
14771 };
14772
14773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
14774 {
14775 PyThreadState* __tstate = wxPyBeginAllowThreads();
14776 result = (wxFileTypeInfo *)new wxFileTypeInfo();
14777
14778 wxPyEndAllowThreads(__tstate);
14779 if (PyErr_Occurred()) SWIG_fail;
14780 }
14781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
14782 return resultobj;
14783 fail:
14784 return NULL;
14785 }
14786
14787
14788 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
14789 PyObject *resultobj = NULL;
14790 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14791 bool result;
14792 PyObject * obj0 = 0 ;
14793 char *kwnames[] = {
14794 (char *) "self", NULL
14795 };
14796
14797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
14798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14799 if (SWIG_arg_fail(1)) SWIG_fail;
14800 {
14801 PyThreadState* __tstate = wxPyBeginAllowThreads();
14802 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
14803
14804 wxPyEndAllowThreads(__tstate);
14805 if (PyErr_Occurred()) SWIG_fail;
14806 }
14807 {
14808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14809 }
14810 return resultobj;
14811 fail:
14812 return NULL;
14813 }
14814
14815
14816 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14817 PyObject *resultobj = NULL;
14818 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14819 wxString *arg2 = 0 ;
14820 int arg3 = (int) 0 ;
14821 bool temp2 = false ;
14822 PyObject * obj0 = 0 ;
14823 PyObject * obj1 = 0 ;
14824 PyObject * obj2 = 0 ;
14825 char *kwnames[] = {
14826 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
14827 };
14828
14829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14831 if (SWIG_arg_fail(1)) SWIG_fail;
14832 {
14833 arg2 = wxString_in_helper(obj1);
14834 if (arg2 == NULL) SWIG_fail;
14835 temp2 = true;
14836 }
14837 if (obj2) {
14838 {
14839 arg3 = static_cast<int >(SWIG_As_int(obj2));
14840 if (SWIG_arg_fail(3)) SWIG_fail;
14841 }
14842 }
14843 {
14844 PyThreadState* __tstate = wxPyBeginAllowThreads();
14845 (arg1)->SetIcon((wxString const &)*arg2,arg3);
14846
14847 wxPyEndAllowThreads(__tstate);
14848 if (PyErr_Occurred()) SWIG_fail;
14849 }
14850 Py_INCREF(Py_None); resultobj = Py_None;
14851 {
14852 if (temp2)
14853 delete arg2;
14854 }
14855 return resultobj;
14856 fail:
14857 {
14858 if (temp2)
14859 delete arg2;
14860 }
14861 return NULL;
14862 }
14863
14864
14865 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14866 PyObject *resultobj = NULL;
14867 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14868 wxString *arg2 = 0 ;
14869 bool temp2 = false ;
14870 PyObject * obj0 = 0 ;
14871 PyObject * obj1 = 0 ;
14872 char *kwnames[] = {
14873 (char *) "self",(char *) "shortDesc", NULL
14874 };
14875
14876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
14877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14878 if (SWIG_arg_fail(1)) SWIG_fail;
14879 {
14880 arg2 = wxString_in_helper(obj1);
14881 if (arg2 == NULL) SWIG_fail;
14882 temp2 = true;
14883 }
14884 {
14885 PyThreadState* __tstate = wxPyBeginAllowThreads();
14886 (arg1)->SetShortDesc((wxString const &)*arg2);
14887
14888 wxPyEndAllowThreads(__tstate);
14889 if (PyErr_Occurred()) SWIG_fail;
14890 }
14891 Py_INCREF(Py_None); resultobj = Py_None;
14892 {
14893 if (temp2)
14894 delete arg2;
14895 }
14896 return resultobj;
14897 fail:
14898 {
14899 if (temp2)
14900 delete arg2;
14901 }
14902 return NULL;
14903 }
14904
14905
14906 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14907 PyObject *resultobj = NULL;
14908 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14909 wxString *result;
14910 PyObject * obj0 = 0 ;
14911 char *kwnames[] = {
14912 (char *) "self", NULL
14913 };
14914
14915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14917 if (SWIG_arg_fail(1)) SWIG_fail;
14918 {
14919 PyThreadState* __tstate = wxPyBeginAllowThreads();
14920 {
14921 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14922 result = (wxString *) &_result_ref;
14923 }
14924
14925 wxPyEndAllowThreads(__tstate);
14926 if (PyErr_Occurred()) SWIG_fail;
14927 }
14928 {
14929 #if wxUSE_UNICODE
14930 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14931 #else
14932 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14933 #endif
14934 }
14935 return resultobj;
14936 fail:
14937 return NULL;
14938 }
14939
14940
14941 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14942 PyObject *resultobj = NULL;
14943 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14944 wxString *result;
14945 PyObject * obj0 = 0 ;
14946 char *kwnames[] = {
14947 (char *) "self", NULL
14948 };
14949
14950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14952 if (SWIG_arg_fail(1)) SWIG_fail;
14953 {
14954 PyThreadState* __tstate = wxPyBeginAllowThreads();
14955 {
14956 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14957 result = (wxString *) &_result_ref;
14958 }
14959
14960 wxPyEndAllowThreads(__tstate);
14961 if (PyErr_Occurred()) SWIG_fail;
14962 }
14963 {
14964 #if wxUSE_UNICODE
14965 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14966 #else
14967 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14968 #endif
14969 }
14970 return resultobj;
14971 fail:
14972 return NULL;
14973 }
14974
14975
14976 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14977 PyObject *resultobj = NULL;
14978 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14979 wxString *result;
14980 PyObject * obj0 = 0 ;
14981 char *kwnames[] = {
14982 (char *) "self", NULL
14983 };
14984
14985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14987 if (SWIG_arg_fail(1)) SWIG_fail;
14988 {
14989 PyThreadState* __tstate = wxPyBeginAllowThreads();
14990 {
14991 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14992 result = (wxString *) &_result_ref;
14993 }
14994
14995 wxPyEndAllowThreads(__tstate);
14996 if (PyErr_Occurred()) SWIG_fail;
14997 }
14998 {
14999 #if wxUSE_UNICODE
15000 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15001 #else
15002 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15003 #endif
15004 }
15005 return resultobj;
15006 fail:
15007 return NULL;
15008 }
15009
15010
15011 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
15012 PyObject *resultobj = NULL;
15013 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15014 wxString *result;
15015 PyObject * obj0 = 0 ;
15016 char *kwnames[] = {
15017 (char *) "self", NULL
15018 };
15019
15020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
15021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15022 if (SWIG_arg_fail(1)) SWIG_fail;
15023 {
15024 PyThreadState* __tstate = wxPyBeginAllowThreads();
15025 {
15026 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
15027 result = (wxString *) &_result_ref;
15028 }
15029
15030 wxPyEndAllowThreads(__tstate);
15031 if (PyErr_Occurred()) SWIG_fail;
15032 }
15033 {
15034 #if wxUSE_UNICODE
15035 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15036 #else
15037 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15038 #endif
15039 }
15040 return resultobj;
15041 fail:
15042 return NULL;
15043 }
15044
15045
15046 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
15047 PyObject *resultobj = NULL;
15048 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15049 wxString *result;
15050 PyObject * obj0 = 0 ;
15051 char *kwnames[] = {
15052 (char *) "self", NULL
15053 };
15054
15055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
15056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15057 if (SWIG_arg_fail(1)) SWIG_fail;
15058 {
15059 PyThreadState* __tstate = wxPyBeginAllowThreads();
15060 {
15061 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
15062 result = (wxString *) &_result_ref;
15063 }
15064
15065 wxPyEndAllowThreads(__tstate);
15066 if (PyErr_Occurred()) SWIG_fail;
15067 }
15068 {
15069 #if wxUSE_UNICODE
15070 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15071 #else
15072 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15073 #endif
15074 }
15075 return resultobj;
15076 fail:
15077 return NULL;
15078 }
15079
15080
15081 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
15082 PyObject *resultobj = NULL;
15083 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15084 wxArrayString *result;
15085 PyObject * obj0 = 0 ;
15086 char *kwnames[] = {
15087 (char *) "self", NULL
15088 };
15089
15090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
15091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15092 if (SWIG_arg_fail(1)) SWIG_fail;
15093 {
15094 PyThreadState* __tstate = wxPyBeginAllowThreads();
15095 {
15096 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
15097 result = (wxArrayString *) &_result_ref;
15098 }
15099
15100 wxPyEndAllowThreads(__tstate);
15101 if (PyErr_Occurred()) SWIG_fail;
15102 }
15103 {
15104 resultobj = wxArrayString2PyList_helper(*result);
15105 }
15106 return resultobj;
15107 fail:
15108 return NULL;
15109 }
15110
15111
15112 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
15113 PyObject *resultobj = NULL;
15114 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15115 int result;
15116 PyObject * obj0 = 0 ;
15117 char *kwnames[] = {
15118 (char *) "self", NULL
15119 };
15120
15121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
15122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15123 if (SWIG_arg_fail(1)) SWIG_fail;
15124 {
15125 PyThreadState* __tstate = wxPyBeginAllowThreads();
15126 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
15127
15128 wxPyEndAllowThreads(__tstate);
15129 if (PyErr_Occurred()) SWIG_fail;
15130 }
15131 {
15132 resultobj = SWIG_From_int(static_cast<int >(result));
15133 }
15134 return resultobj;
15135 fail:
15136 return NULL;
15137 }
15138
15139
15140 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
15141 PyObject *resultobj = NULL;
15142 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15143 wxString *result;
15144 PyObject * obj0 = 0 ;
15145 char *kwnames[] = {
15146 (char *) "self", NULL
15147 };
15148
15149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
15150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15151 if (SWIG_arg_fail(1)) SWIG_fail;
15152 {
15153 PyThreadState* __tstate = wxPyBeginAllowThreads();
15154 {
15155 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
15156 result = (wxString *) &_result_ref;
15157 }
15158
15159 wxPyEndAllowThreads(__tstate);
15160 if (PyErr_Occurred()) SWIG_fail;
15161 }
15162 {
15163 #if wxUSE_UNICODE
15164 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15165 #else
15166 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15167 #endif
15168 }
15169 return resultobj;
15170 fail:
15171 return NULL;
15172 }
15173
15174
15175 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
15176 PyObject *resultobj = NULL;
15177 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15178 int result;
15179 PyObject * obj0 = 0 ;
15180 char *kwnames[] = {
15181 (char *) "self", NULL
15182 };
15183
15184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
15185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15186 if (SWIG_arg_fail(1)) SWIG_fail;
15187 {
15188 PyThreadState* __tstate = wxPyBeginAllowThreads();
15189 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
15190
15191 wxPyEndAllowThreads(__tstate);
15192 if (PyErr_Occurred()) SWIG_fail;
15193 }
15194 {
15195 resultobj = SWIG_From_int(static_cast<int >(result));
15196 }
15197 return resultobj;
15198 fail:
15199 return NULL;
15200 }
15201
15202
15203 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
15204 PyObject *obj;
15205 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15206 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
15207 Py_INCREF(obj);
15208 return Py_BuildValue((char *)"");
15209 }
15210 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
15211 PyObject *resultobj = NULL;
15212 wxFileTypeInfo *arg1 = 0 ;
15213 wxFileType *result;
15214 PyObject * obj0 = 0 ;
15215 char *kwnames[] = {
15216 (char *) "ftInfo", NULL
15217 };
15218
15219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
15220 {
15221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15222 if (SWIG_arg_fail(1)) SWIG_fail;
15223 if (arg1 == NULL) {
15224 SWIG_null_ref("wxFileTypeInfo");
15225 }
15226 if (SWIG_arg_fail(1)) SWIG_fail;
15227 }
15228 {
15229 PyThreadState* __tstate = wxPyBeginAllowThreads();
15230 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
15231
15232 wxPyEndAllowThreads(__tstate);
15233 if (PyErr_Occurred()) SWIG_fail;
15234 }
15235 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15236 return resultobj;
15237 fail:
15238 return NULL;
15239 }
15240
15241
15242 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
15243 PyObject *resultobj = NULL;
15244 wxFileType *arg1 = (wxFileType *) 0 ;
15245 PyObject * obj0 = 0 ;
15246 char *kwnames[] = {
15247 (char *) "self", NULL
15248 };
15249
15250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
15251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15252 if (SWIG_arg_fail(1)) SWIG_fail;
15253 {
15254 PyThreadState* __tstate = wxPyBeginAllowThreads();
15255 delete arg1;
15256
15257 wxPyEndAllowThreads(__tstate);
15258 if (PyErr_Occurred()) SWIG_fail;
15259 }
15260 Py_INCREF(Py_None); resultobj = Py_None;
15261 return resultobj;
15262 fail:
15263 return NULL;
15264 }
15265
15266
15267 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15268 PyObject *resultobj = NULL;
15269 wxFileType *arg1 = (wxFileType *) 0 ;
15270 PyObject *result;
15271 PyObject * obj0 = 0 ;
15272 char *kwnames[] = {
15273 (char *) "self", NULL
15274 };
15275
15276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
15277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15278 if (SWIG_arg_fail(1)) SWIG_fail;
15279 {
15280 PyThreadState* __tstate = wxPyBeginAllowThreads();
15281 result = (PyObject *)wxFileType_GetMimeType(arg1);
15282
15283 wxPyEndAllowThreads(__tstate);
15284 if (PyErr_Occurred()) SWIG_fail;
15285 }
15286 resultobj = result;
15287 return resultobj;
15288 fail:
15289 return NULL;
15290 }
15291
15292
15293 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15294 PyObject *resultobj = NULL;
15295 wxFileType *arg1 = (wxFileType *) 0 ;
15296 PyObject *result;
15297 PyObject * obj0 = 0 ;
15298 char *kwnames[] = {
15299 (char *) "self", NULL
15300 };
15301
15302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
15303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15304 if (SWIG_arg_fail(1)) SWIG_fail;
15305 {
15306 PyThreadState* __tstate = wxPyBeginAllowThreads();
15307 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
15308
15309 wxPyEndAllowThreads(__tstate);
15310 if (PyErr_Occurred()) SWIG_fail;
15311 }
15312 resultobj = result;
15313 return resultobj;
15314 fail:
15315 return NULL;
15316 }
15317
15318
15319 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
15320 PyObject *resultobj = NULL;
15321 wxFileType *arg1 = (wxFileType *) 0 ;
15322 PyObject *result;
15323 PyObject * obj0 = 0 ;
15324 char *kwnames[] = {
15325 (char *) "self", NULL
15326 };
15327
15328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
15329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15330 if (SWIG_arg_fail(1)) SWIG_fail;
15331 {
15332 PyThreadState* __tstate = wxPyBeginAllowThreads();
15333 result = (PyObject *)wxFileType_GetExtensions(arg1);
15334
15335 wxPyEndAllowThreads(__tstate);
15336 if (PyErr_Occurred()) SWIG_fail;
15337 }
15338 resultobj = result;
15339 return resultobj;
15340 fail:
15341 return NULL;
15342 }
15343
15344
15345 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
15346 PyObject *resultobj = NULL;
15347 wxFileType *arg1 = (wxFileType *) 0 ;
15348 wxIcon *result;
15349 PyObject * obj0 = 0 ;
15350 char *kwnames[] = {
15351 (char *) "self", NULL
15352 };
15353
15354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
15355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15356 if (SWIG_arg_fail(1)) SWIG_fail;
15357 {
15358 PyThreadState* __tstate = wxPyBeginAllowThreads();
15359 result = (wxIcon *)wxFileType_GetIcon(arg1);
15360
15361 wxPyEndAllowThreads(__tstate);
15362 if (PyErr_Occurred()) SWIG_fail;
15363 }
15364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
15365 return resultobj;
15366 fail:
15367 return NULL;
15368 }
15369
15370
15371 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15372 PyObject *resultobj = NULL;
15373 wxFileType *arg1 = (wxFileType *) 0 ;
15374 PyObject *result;
15375 PyObject * obj0 = 0 ;
15376 char *kwnames[] = {
15377 (char *) "self", NULL
15378 };
15379
15380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
15381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15382 if (SWIG_arg_fail(1)) SWIG_fail;
15383 {
15384 PyThreadState* __tstate = wxPyBeginAllowThreads();
15385 result = (PyObject *)wxFileType_GetIconInfo(arg1);
15386
15387 wxPyEndAllowThreads(__tstate);
15388 if (PyErr_Occurred()) SWIG_fail;
15389 }
15390 resultobj = result;
15391 return resultobj;
15392 fail:
15393 return NULL;
15394 }
15395
15396
15397 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
15398 PyObject *resultobj = NULL;
15399 wxFileType *arg1 = (wxFileType *) 0 ;
15400 PyObject *result;
15401 PyObject * obj0 = 0 ;
15402 char *kwnames[] = {
15403 (char *) "self", NULL
15404 };
15405
15406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
15407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15408 if (SWIG_arg_fail(1)) SWIG_fail;
15409 {
15410 PyThreadState* __tstate = wxPyBeginAllowThreads();
15411 result = (PyObject *)wxFileType_GetDescription(arg1);
15412
15413 wxPyEndAllowThreads(__tstate);
15414 if (PyErr_Occurred()) SWIG_fail;
15415 }
15416 resultobj = result;
15417 return resultobj;
15418 fail:
15419 return NULL;
15420 }
15421
15422
15423 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15424 PyObject *resultobj = NULL;
15425 wxFileType *arg1 = (wxFileType *) 0 ;
15426 wxString *arg2 = 0 ;
15427 wxString const &arg3_defvalue = wxPyEmptyString ;
15428 wxString *arg3 = (wxString *) &arg3_defvalue ;
15429 PyObject *result;
15430 bool temp2 = false ;
15431 bool temp3 = false ;
15432 PyObject * obj0 = 0 ;
15433 PyObject * obj1 = 0 ;
15434 PyObject * obj2 = 0 ;
15435 char *kwnames[] = {
15436 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
15437 };
15438
15439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
15440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15441 if (SWIG_arg_fail(1)) SWIG_fail;
15442 {
15443 arg2 = wxString_in_helper(obj1);
15444 if (arg2 == NULL) SWIG_fail;
15445 temp2 = true;
15446 }
15447 if (obj2) {
15448 {
15449 arg3 = wxString_in_helper(obj2);
15450 if (arg3 == NULL) SWIG_fail;
15451 temp3 = true;
15452 }
15453 }
15454 {
15455 PyThreadState* __tstate = wxPyBeginAllowThreads();
15456 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15457
15458 wxPyEndAllowThreads(__tstate);
15459 if (PyErr_Occurred()) SWIG_fail;
15460 }
15461 resultobj = result;
15462 {
15463 if (temp2)
15464 delete arg2;
15465 }
15466 {
15467 if (temp3)
15468 delete arg3;
15469 }
15470 return resultobj;
15471 fail:
15472 {
15473 if (temp2)
15474 delete arg2;
15475 }
15476 {
15477 if (temp3)
15478 delete arg3;
15479 }
15480 return NULL;
15481 }
15482
15483
15484 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15485 PyObject *resultobj = NULL;
15486 wxFileType *arg1 = (wxFileType *) 0 ;
15487 wxString *arg2 = 0 ;
15488 wxString const &arg3_defvalue = wxPyEmptyString ;
15489 wxString *arg3 = (wxString *) &arg3_defvalue ;
15490 PyObject *result;
15491 bool temp2 = false ;
15492 bool temp3 = false ;
15493 PyObject * obj0 = 0 ;
15494 PyObject * obj1 = 0 ;
15495 PyObject * obj2 = 0 ;
15496 char *kwnames[] = {
15497 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
15498 };
15499
15500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
15501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15502 if (SWIG_arg_fail(1)) SWIG_fail;
15503 {
15504 arg2 = wxString_in_helper(obj1);
15505 if (arg2 == NULL) SWIG_fail;
15506 temp2 = true;
15507 }
15508 if (obj2) {
15509 {
15510 arg3 = wxString_in_helper(obj2);
15511 if (arg3 == NULL) SWIG_fail;
15512 temp3 = true;
15513 }
15514 }
15515 {
15516 PyThreadState* __tstate = wxPyBeginAllowThreads();
15517 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15518
15519 wxPyEndAllowThreads(__tstate);
15520 if (PyErr_Occurred()) SWIG_fail;
15521 }
15522 resultobj = result;
15523 {
15524 if (temp2)
15525 delete arg2;
15526 }
15527 {
15528 if (temp3)
15529 delete arg3;
15530 }
15531 return resultobj;
15532 fail:
15533 {
15534 if (temp2)
15535 delete arg2;
15536 }
15537 {
15538 if (temp3)
15539 delete arg3;
15540 }
15541 return NULL;
15542 }
15543
15544
15545 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
15546 PyObject *resultobj = NULL;
15547 wxFileType *arg1 = (wxFileType *) 0 ;
15548 wxString *arg2 = 0 ;
15549 wxString const &arg3_defvalue = wxPyEmptyString ;
15550 wxString *arg3 = (wxString *) &arg3_defvalue ;
15551 PyObject *result;
15552 bool temp2 = false ;
15553 bool temp3 = false ;
15554 PyObject * obj0 = 0 ;
15555 PyObject * obj1 = 0 ;
15556 PyObject * obj2 = 0 ;
15557 char *kwnames[] = {
15558 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
15559 };
15560
15561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
15562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15563 if (SWIG_arg_fail(1)) SWIG_fail;
15564 {
15565 arg2 = wxString_in_helper(obj1);
15566 if (arg2 == NULL) SWIG_fail;
15567 temp2 = true;
15568 }
15569 if (obj2) {
15570 {
15571 arg3 = wxString_in_helper(obj2);
15572 if (arg3 == NULL) SWIG_fail;
15573 temp3 = true;
15574 }
15575 }
15576 {
15577 PyThreadState* __tstate = wxPyBeginAllowThreads();
15578 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15579
15580 wxPyEndAllowThreads(__tstate);
15581 if (PyErr_Occurred()) SWIG_fail;
15582 }
15583 resultobj = result;
15584 {
15585 if (temp2)
15586 delete arg2;
15587 }
15588 {
15589 if (temp3)
15590 delete arg3;
15591 }
15592 return resultobj;
15593 fail:
15594 {
15595 if (temp2)
15596 delete arg2;
15597 }
15598 {
15599 if (temp3)
15600 delete arg3;
15601 }
15602 return NULL;
15603 }
15604
15605
15606 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15607 PyObject *resultobj = NULL;
15608 wxFileType *arg1 = (wxFileType *) 0 ;
15609 wxString *arg2 = 0 ;
15610 wxString *arg3 = 0 ;
15611 bool arg4 = (bool) true ;
15612 bool result;
15613 bool temp2 = false ;
15614 bool temp3 = false ;
15615 PyObject * obj0 = 0 ;
15616 PyObject * obj1 = 0 ;
15617 PyObject * obj2 = 0 ;
15618 PyObject * obj3 = 0 ;
15619 char *kwnames[] = {
15620 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
15621 };
15622
15623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15625 if (SWIG_arg_fail(1)) SWIG_fail;
15626 {
15627 arg2 = wxString_in_helper(obj1);
15628 if (arg2 == NULL) SWIG_fail;
15629 temp2 = true;
15630 }
15631 {
15632 arg3 = wxString_in_helper(obj2);
15633 if (arg3 == NULL) SWIG_fail;
15634 temp3 = true;
15635 }
15636 if (obj3) {
15637 {
15638 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
15639 if (SWIG_arg_fail(4)) SWIG_fail;
15640 }
15641 }
15642 {
15643 PyThreadState* __tstate = wxPyBeginAllowThreads();
15644 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
15645
15646 wxPyEndAllowThreads(__tstate);
15647 if (PyErr_Occurred()) SWIG_fail;
15648 }
15649 {
15650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15651 }
15652 {
15653 if (temp2)
15654 delete arg2;
15655 }
15656 {
15657 if (temp3)
15658 delete arg3;
15659 }
15660 return resultobj;
15661 fail:
15662 {
15663 if (temp2)
15664 delete arg2;
15665 }
15666 {
15667 if (temp3)
15668 delete arg3;
15669 }
15670 return NULL;
15671 }
15672
15673
15674 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
15675 PyObject *resultobj = NULL;
15676 wxFileType *arg1 = (wxFileType *) 0 ;
15677 wxString const &arg2_defvalue = wxPyEmptyString ;
15678 wxString *arg2 = (wxString *) &arg2_defvalue ;
15679 int arg3 = (int) 0 ;
15680 bool result;
15681 bool temp2 = false ;
15682 PyObject * obj0 = 0 ;
15683 PyObject * obj1 = 0 ;
15684 PyObject * obj2 = 0 ;
15685 char *kwnames[] = {
15686 (char *) "self",(char *) "cmd",(char *) "index", NULL
15687 };
15688
15689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
15690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15691 if (SWIG_arg_fail(1)) SWIG_fail;
15692 if (obj1) {
15693 {
15694 arg2 = wxString_in_helper(obj1);
15695 if (arg2 == NULL) SWIG_fail;
15696 temp2 = true;
15697 }
15698 }
15699 if (obj2) {
15700 {
15701 arg3 = static_cast<int >(SWIG_As_int(obj2));
15702 if (SWIG_arg_fail(3)) SWIG_fail;
15703 }
15704 }
15705 {
15706 PyThreadState* __tstate = wxPyBeginAllowThreads();
15707 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
15708
15709 wxPyEndAllowThreads(__tstate);
15710 if (PyErr_Occurred()) SWIG_fail;
15711 }
15712 {
15713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15714 }
15715 {
15716 if (temp2)
15717 delete arg2;
15718 }
15719 return resultobj;
15720 fail:
15721 {
15722 if (temp2)
15723 delete arg2;
15724 }
15725 return NULL;
15726 }
15727
15728
15729 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15730 PyObject *resultobj = NULL;
15731 wxFileType *arg1 = (wxFileType *) 0 ;
15732 bool result;
15733 PyObject * obj0 = 0 ;
15734 char *kwnames[] = {
15735 (char *) "self", NULL
15736 };
15737
15738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
15739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15740 if (SWIG_arg_fail(1)) SWIG_fail;
15741 {
15742 PyThreadState* __tstate = wxPyBeginAllowThreads();
15743 result = (bool)(arg1)->Unassociate();
15744
15745 wxPyEndAllowThreads(__tstate);
15746 if (PyErr_Occurred()) SWIG_fail;
15747 }
15748 {
15749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15750 }
15751 return resultobj;
15752 fail:
15753 return NULL;
15754 }
15755
15756
15757 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15758 PyObject *resultobj = NULL;
15759 wxString *arg1 = 0 ;
15760 wxString *arg2 = 0 ;
15761 wxString const &arg3_defvalue = wxPyEmptyString ;
15762 wxString *arg3 = (wxString *) &arg3_defvalue ;
15763 wxString result;
15764 bool temp1 = false ;
15765 bool temp2 = false ;
15766 bool temp3 = false ;
15767 PyObject * obj0 = 0 ;
15768 PyObject * obj1 = 0 ;
15769 PyObject * obj2 = 0 ;
15770 char *kwnames[] = {
15771 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
15772 };
15773
15774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
15775 {
15776 arg1 = wxString_in_helper(obj0);
15777 if (arg1 == NULL) SWIG_fail;
15778 temp1 = true;
15779 }
15780 {
15781 arg2 = wxString_in_helper(obj1);
15782 if (arg2 == NULL) SWIG_fail;
15783 temp2 = true;
15784 }
15785 if (obj2) {
15786 {
15787 arg3 = wxString_in_helper(obj2);
15788 if (arg3 == NULL) SWIG_fail;
15789 temp3 = true;
15790 }
15791 }
15792 {
15793 PyThreadState* __tstate = wxPyBeginAllowThreads();
15794 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15795
15796 wxPyEndAllowThreads(__tstate);
15797 if (PyErr_Occurred()) SWIG_fail;
15798 }
15799 {
15800 #if wxUSE_UNICODE
15801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15802 #else
15803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15804 #endif
15805 }
15806 {
15807 if (temp1)
15808 delete arg1;
15809 }
15810 {
15811 if (temp2)
15812 delete arg2;
15813 }
15814 {
15815 if (temp3)
15816 delete arg3;
15817 }
15818 return resultobj;
15819 fail:
15820 {
15821 if (temp1)
15822 delete arg1;
15823 }
15824 {
15825 if (temp2)
15826 delete arg2;
15827 }
15828 {
15829 if (temp3)
15830 delete arg3;
15831 }
15832 return NULL;
15833 }
15834
15835
15836 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
15837 PyObject *obj;
15838 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15839 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
15840 Py_INCREF(obj);
15841 return Py_BuildValue((char *)"");
15842 }
15843 static int _wrap_TheMimeTypesManager_set(PyObject *) {
15844 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
15845 return 1;
15846 }
15847
15848
15849 static PyObject *_wrap_TheMimeTypesManager_get(void) {
15850 PyObject *pyobj = NULL;
15851
15852 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
15853 return pyobj;
15854 }
15855
15856
15857 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
15858 PyObject *resultobj = NULL;
15859 wxString *arg1 = 0 ;
15860 wxString *arg2 = 0 ;
15861 bool result;
15862 bool temp1 = false ;
15863 bool temp2 = false ;
15864 PyObject * obj0 = 0 ;
15865 PyObject * obj1 = 0 ;
15866 char *kwnames[] = {
15867 (char *) "mimeType",(char *) "wildcard", NULL
15868 };
15869
15870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
15871 {
15872 arg1 = wxString_in_helper(obj0);
15873 if (arg1 == NULL) SWIG_fail;
15874 temp1 = true;
15875 }
15876 {
15877 arg2 = wxString_in_helper(obj1);
15878 if (arg2 == NULL) SWIG_fail;
15879 temp2 = true;
15880 }
15881 {
15882 PyThreadState* __tstate = wxPyBeginAllowThreads();
15883 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
15884
15885 wxPyEndAllowThreads(__tstate);
15886 if (PyErr_Occurred()) SWIG_fail;
15887 }
15888 {
15889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15890 }
15891 {
15892 if (temp1)
15893 delete arg1;
15894 }
15895 {
15896 if (temp2)
15897 delete arg2;
15898 }
15899 return resultobj;
15900 fail:
15901 {
15902 if (temp1)
15903 delete arg1;
15904 }
15905 {
15906 if (temp2)
15907 delete arg2;
15908 }
15909 return NULL;
15910 }
15911
15912
15913 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15914 PyObject *resultobj = NULL;
15915 wxMimeTypesManager *result;
15916 char *kwnames[] = {
15917 NULL
15918 };
15919
15920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15921 {
15922 PyThreadState* __tstate = wxPyBeginAllowThreads();
15923 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15924
15925 wxPyEndAllowThreads(__tstate);
15926 if (PyErr_Occurred()) SWIG_fail;
15927 }
15928 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15929 return resultobj;
15930 fail:
15931 return NULL;
15932 }
15933
15934
15935 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15936 PyObject *resultobj = NULL;
15937 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15938 int arg2 = (int) wxMAILCAP_ALL ;
15939 wxString const &arg3_defvalue = wxPyEmptyString ;
15940 wxString *arg3 = (wxString *) &arg3_defvalue ;
15941 bool temp3 = false ;
15942 PyObject * obj0 = 0 ;
15943 PyObject * obj1 = 0 ;
15944 PyObject * obj2 = 0 ;
15945 char *kwnames[] = {
15946 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15947 };
15948
15949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15951 if (SWIG_arg_fail(1)) SWIG_fail;
15952 if (obj1) {
15953 {
15954 arg2 = static_cast<int >(SWIG_As_int(obj1));
15955 if (SWIG_arg_fail(2)) SWIG_fail;
15956 }
15957 }
15958 if (obj2) {
15959 {
15960 arg3 = wxString_in_helper(obj2);
15961 if (arg3 == NULL) SWIG_fail;
15962 temp3 = true;
15963 }
15964 }
15965 {
15966 PyThreadState* __tstate = wxPyBeginAllowThreads();
15967 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15968
15969 wxPyEndAllowThreads(__tstate);
15970 if (PyErr_Occurred()) SWIG_fail;
15971 }
15972 Py_INCREF(Py_None); resultobj = Py_None;
15973 {
15974 if (temp3)
15975 delete arg3;
15976 }
15977 return resultobj;
15978 fail:
15979 {
15980 if (temp3)
15981 delete arg3;
15982 }
15983 return NULL;
15984 }
15985
15986
15987 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15988 PyObject *resultobj = NULL;
15989 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15990 PyObject * obj0 = 0 ;
15991 char *kwnames[] = {
15992 (char *) "self", NULL
15993 };
15994
15995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15997 if (SWIG_arg_fail(1)) SWIG_fail;
15998 {
15999 PyThreadState* __tstate = wxPyBeginAllowThreads();
16000 (arg1)->ClearData();
16001
16002 wxPyEndAllowThreads(__tstate);
16003 if (PyErr_Occurred()) SWIG_fail;
16004 }
16005 Py_INCREF(Py_None); resultobj = Py_None;
16006 return resultobj;
16007 fail:
16008 return NULL;
16009 }
16010
16011
16012 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
16013 PyObject *resultobj = NULL;
16014 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16015 wxString *arg2 = 0 ;
16016 wxFileType *result;
16017 bool temp2 = false ;
16018 PyObject * obj0 = 0 ;
16019 PyObject * obj1 = 0 ;
16020 char *kwnames[] = {
16021 (char *) "self",(char *) "ext", NULL
16022 };
16023
16024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
16025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16026 if (SWIG_arg_fail(1)) SWIG_fail;
16027 {
16028 arg2 = wxString_in_helper(obj1);
16029 if (arg2 == NULL) SWIG_fail;
16030 temp2 = true;
16031 }
16032 {
16033 PyThreadState* __tstate = wxPyBeginAllowThreads();
16034 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
16035
16036 wxPyEndAllowThreads(__tstate);
16037 if (PyErr_Occurred()) SWIG_fail;
16038 }
16039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
16040 {
16041 if (temp2)
16042 delete arg2;
16043 }
16044 return resultobj;
16045 fail:
16046 {
16047 if (temp2)
16048 delete arg2;
16049 }
16050 return NULL;
16051 }
16052
16053
16054 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
16055 PyObject *resultobj = NULL;
16056 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16057 wxString *arg2 = 0 ;
16058 wxFileType *result;
16059 bool temp2 = false ;
16060 PyObject * obj0 = 0 ;
16061 PyObject * obj1 = 0 ;
16062 char *kwnames[] = {
16063 (char *) "self",(char *) "mimeType", NULL
16064 };
16065
16066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
16067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16068 if (SWIG_arg_fail(1)) SWIG_fail;
16069 {
16070 arg2 = wxString_in_helper(obj1);
16071 if (arg2 == NULL) SWIG_fail;
16072 temp2 = true;
16073 }
16074 {
16075 PyThreadState* __tstate = wxPyBeginAllowThreads();
16076 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
16077
16078 wxPyEndAllowThreads(__tstate);
16079 if (PyErr_Occurred()) SWIG_fail;
16080 }
16081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
16082 {
16083 if (temp2)
16084 delete arg2;
16085 }
16086 return resultobj;
16087 fail:
16088 {
16089 if (temp2)
16090 delete arg2;
16091 }
16092 return NULL;
16093 }
16094
16095
16096 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
16097 PyObject *resultobj = NULL;
16098 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16099 wxString *arg2 = 0 ;
16100 bool arg3 = (bool) false ;
16101 bool result;
16102 bool temp2 = false ;
16103 PyObject * obj0 = 0 ;
16104 PyObject * obj1 = 0 ;
16105 PyObject * obj2 = 0 ;
16106 char *kwnames[] = {
16107 (char *) "self",(char *) "filename",(char *) "fallback", NULL
16108 };
16109
16110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16112 if (SWIG_arg_fail(1)) SWIG_fail;
16113 {
16114 arg2 = wxString_in_helper(obj1);
16115 if (arg2 == NULL) SWIG_fail;
16116 temp2 = true;
16117 }
16118 if (obj2) {
16119 {
16120 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
16121 if (SWIG_arg_fail(3)) SWIG_fail;
16122 }
16123 }
16124 {
16125 PyThreadState* __tstate = wxPyBeginAllowThreads();
16126 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
16127
16128 wxPyEndAllowThreads(__tstate);
16129 if (PyErr_Occurred()) SWIG_fail;
16130 }
16131 {
16132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16133 }
16134 {
16135 if (temp2)
16136 delete arg2;
16137 }
16138 return resultobj;
16139 fail:
16140 {
16141 if (temp2)
16142 delete arg2;
16143 }
16144 return NULL;
16145 }
16146
16147
16148 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
16149 PyObject *resultobj = NULL;
16150 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16151 wxString *arg2 = 0 ;
16152 bool result;
16153 bool temp2 = false ;
16154 PyObject * obj0 = 0 ;
16155 PyObject * obj1 = 0 ;
16156 char *kwnames[] = {
16157 (char *) "self",(char *) "filename", NULL
16158 };
16159
16160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
16161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16162 if (SWIG_arg_fail(1)) SWIG_fail;
16163 {
16164 arg2 = wxString_in_helper(obj1);
16165 if (arg2 == NULL) SWIG_fail;
16166 temp2 = true;
16167 }
16168 {
16169 PyThreadState* __tstate = wxPyBeginAllowThreads();
16170 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
16171
16172 wxPyEndAllowThreads(__tstate);
16173 if (PyErr_Occurred()) SWIG_fail;
16174 }
16175 {
16176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16177 }
16178 {
16179 if (temp2)
16180 delete arg2;
16181 }
16182 return resultobj;
16183 fail:
16184 {
16185 if (temp2)
16186 delete arg2;
16187 }
16188 return NULL;
16189 }
16190
16191
16192 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
16193 PyObject *resultobj = NULL;
16194 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16195 PyObject *result;
16196 PyObject * obj0 = 0 ;
16197 char *kwnames[] = {
16198 (char *) "self", NULL
16199 };
16200
16201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
16202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16203 if (SWIG_arg_fail(1)) SWIG_fail;
16204 {
16205 PyThreadState* __tstate = wxPyBeginAllowThreads();
16206 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
16207
16208 wxPyEndAllowThreads(__tstate);
16209 if (PyErr_Occurred()) SWIG_fail;
16210 }
16211 resultobj = result;
16212 return resultobj;
16213 fail:
16214 return NULL;
16215 }
16216
16217
16218 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
16219 PyObject *resultobj = NULL;
16220 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16221 wxFileTypeInfo *arg2 = 0 ;
16222 PyObject * obj0 = 0 ;
16223 PyObject * obj1 = 0 ;
16224 char *kwnames[] = {
16225 (char *) "self",(char *) "ft", NULL
16226 };
16227
16228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
16229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16230 if (SWIG_arg_fail(1)) SWIG_fail;
16231 {
16232 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
16233 if (SWIG_arg_fail(2)) SWIG_fail;
16234 if (arg2 == NULL) {
16235 SWIG_null_ref("wxFileTypeInfo");
16236 }
16237 if (SWIG_arg_fail(2)) SWIG_fail;
16238 }
16239 {
16240 PyThreadState* __tstate = wxPyBeginAllowThreads();
16241 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
16242
16243 wxPyEndAllowThreads(__tstate);
16244 if (PyErr_Occurred()) SWIG_fail;
16245 }
16246 Py_INCREF(Py_None); resultobj = Py_None;
16247 return resultobj;
16248 fail:
16249 return NULL;
16250 }
16251
16252
16253 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
16254 PyObject *resultobj = NULL;
16255 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16256 wxFileTypeInfo *arg2 = 0 ;
16257 wxFileType *result;
16258 PyObject * obj0 = 0 ;
16259 PyObject * obj1 = 0 ;
16260 char *kwnames[] = {
16261 (char *) "self",(char *) "ftInfo", NULL
16262 };
16263
16264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
16265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16266 if (SWIG_arg_fail(1)) SWIG_fail;
16267 {
16268 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
16269 if (SWIG_arg_fail(2)) SWIG_fail;
16270 if (arg2 == NULL) {
16271 SWIG_null_ref("wxFileTypeInfo");
16272 }
16273 if (SWIG_arg_fail(2)) SWIG_fail;
16274 }
16275 {
16276 PyThreadState* __tstate = wxPyBeginAllowThreads();
16277 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
16278
16279 wxPyEndAllowThreads(__tstate);
16280 if (PyErr_Occurred()) SWIG_fail;
16281 }
16282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
16283 return resultobj;
16284 fail:
16285 return NULL;
16286 }
16287
16288
16289 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
16290 PyObject *resultobj = NULL;
16291 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16292 wxFileType *arg2 = (wxFileType *) 0 ;
16293 bool result;
16294 PyObject * obj0 = 0 ;
16295 PyObject * obj1 = 0 ;
16296 char *kwnames[] = {
16297 (char *) "self",(char *) "ft", NULL
16298 };
16299
16300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
16301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16302 if (SWIG_arg_fail(1)) SWIG_fail;
16303 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
16304 if (SWIG_arg_fail(2)) SWIG_fail;
16305 {
16306 PyThreadState* __tstate = wxPyBeginAllowThreads();
16307 result = (bool)(arg1)->Unassociate(arg2);
16308
16309 wxPyEndAllowThreads(__tstate);
16310 if (PyErr_Occurred()) SWIG_fail;
16311 }
16312 {
16313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16314 }
16315 return resultobj;
16316 fail:
16317 return NULL;
16318 }
16319
16320
16321 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
16322 PyObject *resultobj = NULL;
16323 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16324 PyObject * obj0 = 0 ;
16325 char *kwnames[] = {
16326 (char *) "self", NULL
16327 };
16328
16329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
16330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16331 if (SWIG_arg_fail(1)) SWIG_fail;
16332 {
16333 PyThreadState* __tstate = wxPyBeginAllowThreads();
16334 delete arg1;
16335
16336 wxPyEndAllowThreads(__tstate);
16337 if (PyErr_Occurred()) SWIG_fail;
16338 }
16339 Py_INCREF(Py_None); resultobj = Py_None;
16340 return resultobj;
16341 fail:
16342 return NULL;
16343 }
16344
16345
16346 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
16347 PyObject *obj;
16348 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16349 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
16350 Py_INCREF(obj);
16351 return Py_BuildValue((char *)"");
16352 }
16353 static int _wrap_ART_TOOLBAR_set(PyObject *) {
16354 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
16355 return 1;
16356 }
16357
16358
16359 static PyObject *_wrap_ART_TOOLBAR_get(void) {
16360 PyObject *pyobj = NULL;
16361
16362 {
16363 #if wxUSE_UNICODE
16364 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
16365 #else
16366 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
16367 #endif
16368 }
16369 return pyobj;
16370 }
16371
16372
16373 static int _wrap_ART_MENU_set(PyObject *) {
16374 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
16375 return 1;
16376 }
16377
16378
16379 static PyObject *_wrap_ART_MENU_get(void) {
16380 PyObject *pyobj = NULL;
16381
16382 {
16383 #if wxUSE_UNICODE
16384 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
16385 #else
16386 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
16387 #endif
16388 }
16389 return pyobj;
16390 }
16391
16392
16393 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
16394 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
16395 return 1;
16396 }
16397
16398
16399 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
16400 PyObject *pyobj = NULL;
16401
16402 {
16403 #if wxUSE_UNICODE
16404 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
16405 #else
16406 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
16407 #endif
16408 }
16409 return pyobj;
16410 }
16411
16412
16413 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
16414 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
16415 return 1;
16416 }
16417
16418
16419 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
16420 PyObject *pyobj = NULL;
16421
16422 {
16423 #if wxUSE_UNICODE
16424 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
16425 #else
16426 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
16427 #endif
16428 }
16429 return pyobj;
16430 }
16431
16432
16433 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
16434 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
16435 return 1;
16436 }
16437
16438
16439 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
16440 PyObject *pyobj = NULL;
16441
16442 {
16443 #if wxUSE_UNICODE
16444 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
16445 #else
16446 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
16447 #endif
16448 }
16449 return pyobj;
16450 }
16451
16452
16453 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
16454 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
16455 return 1;
16456 }
16457
16458
16459 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
16460 PyObject *pyobj = NULL;
16461
16462 {
16463 #if wxUSE_UNICODE
16464 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
16465 #else
16466 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
16467 #endif
16468 }
16469 return pyobj;
16470 }
16471
16472
16473 static int _wrap_ART_BUTTON_set(PyObject *) {
16474 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
16475 return 1;
16476 }
16477
16478
16479 static PyObject *_wrap_ART_BUTTON_get(void) {
16480 PyObject *pyobj = NULL;
16481
16482 {
16483 #if wxUSE_UNICODE
16484 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
16485 #else
16486 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
16487 #endif
16488 }
16489 return pyobj;
16490 }
16491
16492
16493 static int _wrap_ART_OTHER_set(PyObject *) {
16494 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
16495 return 1;
16496 }
16497
16498
16499 static PyObject *_wrap_ART_OTHER_get(void) {
16500 PyObject *pyobj = NULL;
16501
16502 {
16503 #if wxUSE_UNICODE
16504 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
16505 #else
16506 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
16507 #endif
16508 }
16509 return pyobj;
16510 }
16511
16512
16513 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
16514 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
16515 return 1;
16516 }
16517
16518
16519 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
16520 PyObject *pyobj = NULL;
16521
16522 {
16523 #if wxUSE_UNICODE
16524 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
16525 #else
16526 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
16527 #endif
16528 }
16529 return pyobj;
16530 }
16531
16532
16533 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
16534 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
16535 return 1;
16536 }
16537
16538
16539 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
16540 PyObject *pyobj = NULL;
16541
16542 {
16543 #if wxUSE_UNICODE
16544 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
16545 #else
16546 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
16547 #endif
16548 }
16549 return pyobj;
16550 }
16551
16552
16553 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
16554 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
16555 return 1;
16556 }
16557
16558
16559 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
16560 PyObject *pyobj = NULL;
16561
16562 {
16563 #if wxUSE_UNICODE
16564 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
16565 #else
16566 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
16567 #endif
16568 }
16569 return pyobj;
16570 }
16571
16572
16573 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
16574 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
16575 return 1;
16576 }
16577
16578
16579 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
16580 PyObject *pyobj = NULL;
16581
16582 {
16583 #if wxUSE_UNICODE
16584 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
16585 #else
16586 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
16587 #endif
16588 }
16589 return pyobj;
16590 }
16591
16592
16593 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
16594 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
16595 return 1;
16596 }
16597
16598
16599 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
16600 PyObject *pyobj = NULL;
16601
16602 {
16603 #if wxUSE_UNICODE
16604 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
16605 #else
16606 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
16607 #endif
16608 }
16609 return pyobj;
16610 }
16611
16612
16613 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
16614 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
16615 return 1;
16616 }
16617
16618
16619 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
16620 PyObject *pyobj = NULL;
16621
16622 {
16623 #if wxUSE_UNICODE
16624 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
16625 #else
16626 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
16627 #endif
16628 }
16629 return pyobj;
16630 }
16631
16632
16633 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
16634 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
16635 return 1;
16636 }
16637
16638
16639 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
16640 PyObject *pyobj = NULL;
16641
16642 {
16643 #if wxUSE_UNICODE
16644 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
16645 #else
16646 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
16647 #endif
16648 }
16649 return pyobj;
16650 }
16651
16652
16653 static int _wrap_ART_GO_BACK_set(PyObject *) {
16654 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
16655 return 1;
16656 }
16657
16658
16659 static PyObject *_wrap_ART_GO_BACK_get(void) {
16660 PyObject *pyobj = NULL;
16661
16662 {
16663 #if wxUSE_UNICODE
16664 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
16665 #else
16666 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
16667 #endif
16668 }
16669 return pyobj;
16670 }
16671
16672
16673 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
16674 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
16675 return 1;
16676 }
16677
16678
16679 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
16680 PyObject *pyobj = NULL;
16681
16682 {
16683 #if wxUSE_UNICODE
16684 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
16685 #else
16686 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
16687 #endif
16688 }
16689 return pyobj;
16690 }
16691
16692
16693 static int _wrap_ART_GO_UP_set(PyObject *) {
16694 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
16695 return 1;
16696 }
16697
16698
16699 static PyObject *_wrap_ART_GO_UP_get(void) {
16700 PyObject *pyobj = NULL;
16701
16702 {
16703 #if wxUSE_UNICODE
16704 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
16705 #else
16706 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
16707 #endif
16708 }
16709 return pyobj;
16710 }
16711
16712
16713 static int _wrap_ART_GO_DOWN_set(PyObject *) {
16714 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
16715 return 1;
16716 }
16717
16718
16719 static PyObject *_wrap_ART_GO_DOWN_get(void) {
16720 PyObject *pyobj = NULL;
16721
16722 {
16723 #if wxUSE_UNICODE
16724 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
16725 #else
16726 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
16727 #endif
16728 }
16729 return pyobj;
16730 }
16731
16732
16733 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
16734 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
16735 return 1;
16736 }
16737
16738
16739 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
16740 PyObject *pyobj = NULL;
16741
16742 {
16743 #if wxUSE_UNICODE
16744 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
16745 #else
16746 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
16747 #endif
16748 }
16749 return pyobj;
16750 }
16751
16752
16753 static int _wrap_ART_GO_HOME_set(PyObject *) {
16754 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
16755 return 1;
16756 }
16757
16758
16759 static PyObject *_wrap_ART_GO_HOME_get(void) {
16760 PyObject *pyobj = NULL;
16761
16762 {
16763 #if wxUSE_UNICODE
16764 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
16765 #else
16766 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
16767 #endif
16768 }
16769 return pyobj;
16770 }
16771
16772
16773 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
16774 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
16775 return 1;
16776 }
16777
16778
16779 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
16780 PyObject *pyobj = NULL;
16781
16782 {
16783 #if wxUSE_UNICODE
16784 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
16785 #else
16786 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
16787 #endif
16788 }
16789 return pyobj;
16790 }
16791
16792
16793 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
16794 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
16795 return 1;
16796 }
16797
16798
16799 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
16800 PyObject *pyobj = NULL;
16801
16802 {
16803 #if wxUSE_UNICODE
16804 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
16805 #else
16806 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
16807 #endif
16808 }
16809 return pyobj;
16810 }
16811
16812
16813 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
16814 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
16815 return 1;
16816 }
16817
16818
16819 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
16820 PyObject *pyobj = NULL;
16821
16822 {
16823 #if wxUSE_UNICODE
16824 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
16825 #else
16826 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
16827 #endif
16828 }
16829 return pyobj;
16830 }
16831
16832
16833 static int _wrap_ART_PRINT_set(PyObject *) {
16834 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
16835 return 1;
16836 }
16837
16838
16839 static PyObject *_wrap_ART_PRINT_get(void) {
16840 PyObject *pyobj = NULL;
16841
16842 {
16843 #if wxUSE_UNICODE
16844 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16845 #else
16846 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16847 #endif
16848 }
16849 return pyobj;
16850 }
16851
16852
16853 static int _wrap_ART_HELP_set(PyObject *) {
16854 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
16855 return 1;
16856 }
16857
16858
16859 static PyObject *_wrap_ART_HELP_get(void) {
16860 PyObject *pyobj = NULL;
16861
16862 {
16863 #if wxUSE_UNICODE
16864 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16865 #else
16866 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16867 #endif
16868 }
16869 return pyobj;
16870 }
16871
16872
16873 static int _wrap_ART_TIP_set(PyObject *) {
16874 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
16875 return 1;
16876 }
16877
16878
16879 static PyObject *_wrap_ART_TIP_get(void) {
16880 PyObject *pyobj = NULL;
16881
16882 {
16883 #if wxUSE_UNICODE
16884 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16885 #else
16886 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16887 #endif
16888 }
16889 return pyobj;
16890 }
16891
16892
16893 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16894 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16895 return 1;
16896 }
16897
16898
16899 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16900 PyObject *pyobj = NULL;
16901
16902 {
16903 #if wxUSE_UNICODE
16904 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16905 #else
16906 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16907 #endif
16908 }
16909 return pyobj;
16910 }
16911
16912
16913 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16914 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16915 return 1;
16916 }
16917
16918
16919 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16920 PyObject *pyobj = NULL;
16921
16922 {
16923 #if wxUSE_UNICODE
16924 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16925 #else
16926 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16927 #endif
16928 }
16929 return pyobj;
16930 }
16931
16932
16933 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16934 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16935 return 1;
16936 }
16937
16938
16939 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16940 PyObject *pyobj = NULL;
16941
16942 {
16943 #if wxUSE_UNICODE
16944 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16945 #else
16946 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16947 #endif
16948 }
16949 return pyobj;
16950 }
16951
16952
16953 static int _wrap_ART_HARDDISK_set(PyObject *) {
16954 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16955 return 1;
16956 }
16957
16958
16959 static PyObject *_wrap_ART_HARDDISK_get(void) {
16960 PyObject *pyobj = NULL;
16961
16962 {
16963 #if wxUSE_UNICODE
16964 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16965 #else
16966 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16967 #endif
16968 }
16969 return pyobj;
16970 }
16971
16972
16973 static int _wrap_ART_FLOPPY_set(PyObject *) {
16974 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16975 return 1;
16976 }
16977
16978
16979 static PyObject *_wrap_ART_FLOPPY_get(void) {
16980 PyObject *pyobj = NULL;
16981
16982 {
16983 #if wxUSE_UNICODE
16984 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16985 #else
16986 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16987 #endif
16988 }
16989 return pyobj;
16990 }
16991
16992
16993 static int _wrap_ART_CDROM_set(PyObject *) {
16994 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16995 return 1;
16996 }
16997
16998
16999 static PyObject *_wrap_ART_CDROM_get(void) {
17000 PyObject *pyobj = NULL;
17001
17002 {
17003 #if wxUSE_UNICODE
17004 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
17005 #else
17006 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
17007 #endif
17008 }
17009 return pyobj;
17010 }
17011
17012
17013 static int _wrap_ART_REMOVABLE_set(PyObject *) {
17014 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
17015 return 1;
17016 }
17017
17018
17019 static PyObject *_wrap_ART_REMOVABLE_get(void) {
17020 PyObject *pyobj = NULL;
17021
17022 {
17023 #if wxUSE_UNICODE
17024 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
17025 #else
17026 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
17027 #endif
17028 }
17029 return pyobj;
17030 }
17031
17032
17033 static int _wrap_ART_FOLDER_set(PyObject *) {
17034 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
17035 return 1;
17036 }
17037
17038
17039 static PyObject *_wrap_ART_FOLDER_get(void) {
17040 PyObject *pyobj = NULL;
17041
17042 {
17043 #if wxUSE_UNICODE
17044 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
17045 #else
17046 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
17047 #endif
17048 }
17049 return pyobj;
17050 }
17051
17052
17053 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
17054 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
17055 return 1;
17056 }
17057
17058
17059 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
17060 PyObject *pyobj = NULL;
17061
17062 {
17063 #if wxUSE_UNICODE
17064 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
17065 #else
17066 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
17067 #endif
17068 }
17069 return pyobj;
17070 }
17071
17072
17073 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
17074 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
17075 return 1;
17076 }
17077
17078
17079 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
17080 PyObject *pyobj = NULL;
17081
17082 {
17083 #if wxUSE_UNICODE
17084 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
17085 #else
17086 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
17087 #endif
17088 }
17089 return pyobj;
17090 }
17091
17092
17093 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
17094 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
17095 return 1;
17096 }
17097
17098
17099 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
17100 PyObject *pyobj = NULL;
17101
17102 {
17103 #if wxUSE_UNICODE
17104 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
17105 #else
17106 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
17107 #endif
17108 }
17109 return pyobj;
17110 }
17111
17112
17113 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
17114 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
17115 return 1;
17116 }
17117
17118
17119 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
17120 PyObject *pyobj = NULL;
17121
17122 {
17123 #if wxUSE_UNICODE
17124 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
17125 #else
17126 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
17127 #endif
17128 }
17129 return pyobj;
17130 }
17131
17132
17133 static int _wrap_ART_TICK_MARK_set(PyObject *) {
17134 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
17135 return 1;
17136 }
17137
17138
17139 static PyObject *_wrap_ART_TICK_MARK_get(void) {
17140 PyObject *pyobj = NULL;
17141
17142 {
17143 #if wxUSE_UNICODE
17144 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
17145 #else
17146 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
17147 #endif
17148 }
17149 return pyobj;
17150 }
17151
17152
17153 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
17154 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
17155 return 1;
17156 }
17157
17158
17159 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
17160 PyObject *pyobj = NULL;
17161
17162 {
17163 #if wxUSE_UNICODE
17164 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
17165 #else
17166 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
17167 #endif
17168 }
17169 return pyobj;
17170 }
17171
17172
17173 static int _wrap_ART_ERROR_set(PyObject *) {
17174 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
17175 return 1;
17176 }
17177
17178
17179 static PyObject *_wrap_ART_ERROR_get(void) {
17180 PyObject *pyobj = NULL;
17181
17182 {
17183 #if wxUSE_UNICODE
17184 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
17185 #else
17186 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
17187 #endif
17188 }
17189 return pyobj;
17190 }
17191
17192
17193 static int _wrap_ART_QUESTION_set(PyObject *) {
17194 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
17195 return 1;
17196 }
17197
17198
17199 static PyObject *_wrap_ART_QUESTION_get(void) {
17200 PyObject *pyobj = NULL;
17201
17202 {
17203 #if wxUSE_UNICODE
17204 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
17205 #else
17206 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
17207 #endif
17208 }
17209 return pyobj;
17210 }
17211
17212
17213 static int _wrap_ART_WARNING_set(PyObject *) {
17214 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
17215 return 1;
17216 }
17217
17218
17219 static PyObject *_wrap_ART_WARNING_get(void) {
17220 PyObject *pyobj = NULL;
17221
17222 {
17223 #if wxUSE_UNICODE
17224 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
17225 #else
17226 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
17227 #endif
17228 }
17229 return pyobj;
17230 }
17231
17232
17233 static int _wrap_ART_INFORMATION_set(PyObject *) {
17234 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
17235 return 1;
17236 }
17237
17238
17239 static PyObject *_wrap_ART_INFORMATION_get(void) {
17240 PyObject *pyobj = NULL;
17241
17242 {
17243 #if wxUSE_UNICODE
17244 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
17245 #else
17246 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
17247 #endif
17248 }
17249 return pyobj;
17250 }
17251
17252
17253 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
17254 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
17255 return 1;
17256 }
17257
17258
17259 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
17260 PyObject *pyobj = NULL;
17261
17262 {
17263 #if wxUSE_UNICODE
17264 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
17265 #else
17266 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
17267 #endif
17268 }
17269 return pyobj;
17270 }
17271
17272
17273 static int _wrap_ART_COPY_set(PyObject *) {
17274 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
17275 return 1;
17276 }
17277
17278
17279 static PyObject *_wrap_ART_COPY_get(void) {
17280 PyObject *pyobj = NULL;
17281
17282 {
17283 #if wxUSE_UNICODE
17284 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
17285 #else
17286 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
17287 #endif
17288 }
17289 return pyobj;
17290 }
17291
17292
17293 static int _wrap_ART_CUT_set(PyObject *) {
17294 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
17295 return 1;
17296 }
17297
17298
17299 static PyObject *_wrap_ART_CUT_get(void) {
17300 PyObject *pyobj = NULL;
17301
17302 {
17303 #if wxUSE_UNICODE
17304 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
17305 #else
17306 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
17307 #endif
17308 }
17309 return pyobj;
17310 }
17311
17312
17313 static int _wrap_ART_PASTE_set(PyObject *) {
17314 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
17315 return 1;
17316 }
17317
17318
17319 static PyObject *_wrap_ART_PASTE_get(void) {
17320 PyObject *pyobj = NULL;
17321
17322 {
17323 #if wxUSE_UNICODE
17324 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
17325 #else
17326 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
17327 #endif
17328 }
17329 return pyobj;
17330 }
17331
17332
17333 static int _wrap_ART_DELETE_set(PyObject *) {
17334 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
17335 return 1;
17336 }
17337
17338
17339 static PyObject *_wrap_ART_DELETE_get(void) {
17340 PyObject *pyobj = NULL;
17341
17342 {
17343 #if wxUSE_UNICODE
17344 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
17345 #else
17346 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
17347 #endif
17348 }
17349 return pyobj;
17350 }
17351
17352
17353 static int _wrap_ART_NEW_set(PyObject *) {
17354 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW is read-only.");
17355 return 1;
17356 }
17357
17358
17359 static PyObject *_wrap_ART_NEW_get(void) {
17360 PyObject *pyobj = NULL;
17361
17362 {
17363 #if wxUSE_UNICODE
17364 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
17365 #else
17366 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
17367 #endif
17368 }
17369 return pyobj;
17370 }
17371
17372
17373 static int _wrap_ART_UNDO_set(PyObject *) {
17374 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
17375 return 1;
17376 }
17377
17378
17379 static PyObject *_wrap_ART_UNDO_get(void) {
17380 PyObject *pyobj = NULL;
17381
17382 {
17383 #if wxUSE_UNICODE
17384 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
17385 #else
17386 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
17387 #endif
17388 }
17389 return pyobj;
17390 }
17391
17392
17393 static int _wrap_ART_REDO_set(PyObject *) {
17394 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
17395 return 1;
17396 }
17397
17398
17399 static PyObject *_wrap_ART_REDO_get(void) {
17400 PyObject *pyobj = NULL;
17401
17402 {
17403 #if wxUSE_UNICODE
17404 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
17405 #else
17406 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
17407 #endif
17408 }
17409 return pyobj;
17410 }
17411
17412
17413 static int _wrap_ART_QUIT_set(PyObject *) {
17414 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
17415 return 1;
17416 }
17417
17418
17419 static PyObject *_wrap_ART_QUIT_get(void) {
17420 PyObject *pyobj = NULL;
17421
17422 {
17423 #if wxUSE_UNICODE
17424 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
17425 #else
17426 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
17427 #endif
17428 }
17429 return pyobj;
17430 }
17431
17432
17433 static int _wrap_ART_FIND_set(PyObject *) {
17434 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
17435 return 1;
17436 }
17437
17438
17439 static PyObject *_wrap_ART_FIND_get(void) {
17440 PyObject *pyobj = NULL;
17441
17442 {
17443 #if wxUSE_UNICODE
17444 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
17445 #else
17446 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
17447 #endif
17448 }
17449 return pyobj;
17450 }
17451
17452
17453 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
17454 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
17455 return 1;
17456 }
17457
17458
17459 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
17460 PyObject *pyobj = NULL;
17461
17462 {
17463 #if wxUSE_UNICODE
17464 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
17465 #else
17466 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
17467 #endif
17468 }
17469 return pyobj;
17470 }
17471
17472
17473 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17474 PyObject *resultobj = NULL;
17475 wxPyArtProvider *result;
17476 char *kwnames[] = {
17477 NULL
17478 };
17479
17480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
17481 {
17482 if (!wxPyCheckForApp()) SWIG_fail;
17483 PyThreadState* __tstate = wxPyBeginAllowThreads();
17484 result = (wxPyArtProvider *)new wxPyArtProvider();
17485
17486 wxPyEndAllowThreads(__tstate);
17487 if (PyErr_Occurred()) SWIG_fail;
17488 }
17489 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
17490 return resultobj;
17491 fail:
17492 return NULL;
17493 }
17494
17495
17496 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
17497 PyObject *resultobj = NULL;
17498 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17499 PyObject *arg2 = (PyObject *) 0 ;
17500 PyObject *arg3 = (PyObject *) 0 ;
17501 PyObject * obj0 = 0 ;
17502 PyObject * obj1 = 0 ;
17503 PyObject * obj2 = 0 ;
17504 char *kwnames[] = {
17505 (char *) "self",(char *) "self",(char *) "_class", NULL
17506 };
17507
17508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
17509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17510 if (SWIG_arg_fail(1)) SWIG_fail;
17511 arg2 = obj1;
17512 arg3 = obj2;
17513 {
17514 PyThreadState* __tstate = wxPyBeginAllowThreads();
17515 (arg1)->_setCallbackInfo(arg2,arg3);
17516
17517 wxPyEndAllowThreads(__tstate);
17518 if (PyErr_Occurred()) SWIG_fail;
17519 }
17520 Py_INCREF(Py_None); resultobj = Py_None;
17521 return resultobj;
17522 fail:
17523 return NULL;
17524 }
17525
17526
17527 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17528 PyObject *resultobj = NULL;
17529 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17530 PyObject * obj0 = 0 ;
17531 char *kwnames[] = {
17532 (char *) "provider", NULL
17533 };
17534
17535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
17536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17537 if (SWIG_arg_fail(1)) SWIG_fail;
17538 {
17539 PyThreadState* __tstate = wxPyBeginAllowThreads();
17540 wxPyArtProvider::PushProvider(arg1);
17541
17542 wxPyEndAllowThreads(__tstate);
17543 if (PyErr_Occurred()) SWIG_fail;
17544 }
17545 Py_INCREF(Py_None); resultobj = Py_None;
17546 return resultobj;
17547 fail:
17548 return NULL;
17549 }
17550
17551
17552 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17553 PyObject *resultobj = NULL;
17554 bool result;
17555 char *kwnames[] = {
17556 NULL
17557 };
17558
17559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
17560 {
17561 PyThreadState* __tstate = wxPyBeginAllowThreads();
17562 result = (bool)wxPyArtProvider::PopProvider();
17563
17564 wxPyEndAllowThreads(__tstate);
17565 if (PyErr_Occurred()) SWIG_fail;
17566 }
17567 {
17568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17569 }
17570 return resultobj;
17571 fail:
17572 return NULL;
17573 }
17574
17575
17576 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17577 PyObject *resultobj = NULL;
17578 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17579 bool result;
17580 PyObject * obj0 = 0 ;
17581 char *kwnames[] = {
17582 (char *) "provider", NULL
17583 };
17584
17585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
17586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17587 if (SWIG_arg_fail(1)) SWIG_fail;
17588 {
17589 PyThreadState* __tstate = wxPyBeginAllowThreads();
17590 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
17591
17592 wxPyEndAllowThreads(__tstate);
17593 if (PyErr_Occurred()) SWIG_fail;
17594 }
17595 {
17596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17597 }
17598 return resultobj;
17599 fail:
17600 return NULL;
17601 }
17602
17603
17604 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
17605 PyObject *resultobj = NULL;
17606 wxString *arg1 = 0 ;
17607 wxString const &arg2_defvalue = wxPyART_OTHER ;
17608 wxString *arg2 = (wxString *) &arg2_defvalue ;
17609 wxSize const &arg3_defvalue = wxDefaultSize ;
17610 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
17611 wxBitmap result;
17612 bool temp1 = false ;
17613 bool temp2 = false ;
17614 wxSize temp3 ;
17615 PyObject * obj0 = 0 ;
17616 PyObject * obj1 = 0 ;
17617 PyObject * obj2 = 0 ;
17618 char *kwnames[] = {
17619 (char *) "id",(char *) "client",(char *) "size", NULL
17620 };
17621
17622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
17623 {
17624 arg1 = wxString_in_helper(obj0);
17625 if (arg1 == NULL) SWIG_fail;
17626 temp1 = true;
17627 }
17628 if (obj1) {
17629 {
17630 arg2 = wxString_in_helper(obj1);
17631 if (arg2 == NULL) SWIG_fail;
17632 temp2 = true;
17633 }
17634 }
17635 if (obj2) {
17636 {
17637 arg3 = &temp3;
17638 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
17639 }
17640 }
17641 {
17642 if (!wxPyCheckForApp()) SWIG_fail;
17643 PyThreadState* __tstate = wxPyBeginAllowThreads();
17644 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
17645
17646 wxPyEndAllowThreads(__tstate);
17647 if (PyErr_Occurred()) SWIG_fail;
17648 }
17649 {
17650 wxBitmap * resultptr;
17651 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
17652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
17653 }
17654 {
17655 if (temp1)
17656 delete arg1;
17657 }
17658 {
17659 if (temp2)
17660 delete arg2;
17661 }
17662 return resultobj;
17663 fail:
17664 {
17665 if (temp1)
17666 delete arg1;
17667 }
17668 {
17669 if (temp2)
17670 delete arg2;
17671 }
17672 return NULL;
17673 }
17674
17675
17676 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
17677 PyObject *resultobj = NULL;
17678 wxString *arg1 = 0 ;
17679 wxString const &arg2_defvalue = wxPyART_OTHER ;
17680 wxString *arg2 = (wxString *) &arg2_defvalue ;
17681 wxSize const &arg3_defvalue = wxDefaultSize ;
17682 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
17683 wxIcon result;
17684 bool temp1 = false ;
17685 bool temp2 = false ;
17686 wxSize temp3 ;
17687 PyObject * obj0 = 0 ;
17688 PyObject * obj1 = 0 ;
17689 PyObject * obj2 = 0 ;
17690 char *kwnames[] = {
17691 (char *) "id",(char *) "client",(char *) "size", NULL
17692 };
17693
17694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
17695 {
17696 arg1 = wxString_in_helper(obj0);
17697 if (arg1 == NULL) SWIG_fail;
17698 temp1 = true;
17699 }
17700 if (obj1) {
17701 {
17702 arg2 = wxString_in_helper(obj1);
17703 if (arg2 == NULL) SWIG_fail;
17704 temp2 = true;
17705 }
17706 }
17707 if (obj2) {
17708 {
17709 arg3 = &temp3;
17710 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
17711 }
17712 }
17713 {
17714 if (!wxPyCheckForApp()) SWIG_fail;
17715 PyThreadState* __tstate = wxPyBeginAllowThreads();
17716 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
17717
17718 wxPyEndAllowThreads(__tstate);
17719 if (PyErr_Occurred()) SWIG_fail;
17720 }
17721 {
17722 wxIcon * resultptr;
17723 resultptr = new wxIcon(static_cast<wxIcon & >(result));
17724 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
17725 }
17726 {
17727 if (temp1)
17728 delete arg1;
17729 }
17730 {
17731 if (temp2)
17732 delete arg2;
17733 }
17734 return resultobj;
17735 fail:
17736 {
17737 if (temp1)
17738 delete arg1;
17739 }
17740 {
17741 if (temp2)
17742 delete arg2;
17743 }
17744 return NULL;
17745 }
17746
17747
17748 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
17749 PyObject *resultobj = NULL;
17750 wxString *arg1 = 0 ;
17751 bool arg2 = (bool) false ;
17752 wxSize result;
17753 bool temp1 = false ;
17754 PyObject * obj0 = 0 ;
17755 PyObject * obj1 = 0 ;
17756 char *kwnames[] = {
17757 (char *) "client",(char *) "platform_dependent", NULL
17758 };
17759
17760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
17761 {
17762 arg1 = wxString_in_helper(obj0);
17763 if (arg1 == NULL) SWIG_fail;
17764 temp1 = true;
17765 }
17766 if (obj1) {
17767 {
17768 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
17769 if (SWIG_arg_fail(2)) SWIG_fail;
17770 }
17771 }
17772 {
17773 PyThreadState* __tstate = wxPyBeginAllowThreads();
17774 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
17775
17776 wxPyEndAllowThreads(__tstate);
17777 if (PyErr_Occurred()) SWIG_fail;
17778 }
17779 {
17780 wxSize * resultptr;
17781 resultptr = new wxSize(static_cast<wxSize & >(result));
17782 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
17783 }
17784 {
17785 if (temp1)
17786 delete arg1;
17787 }
17788 return resultobj;
17789 fail:
17790 {
17791 if (temp1)
17792 delete arg1;
17793 }
17794 return NULL;
17795 }
17796
17797
17798 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
17799 PyObject *resultobj = NULL;
17800 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17801 PyObject * obj0 = 0 ;
17802 char *kwnames[] = {
17803 (char *) "self", NULL
17804 };
17805
17806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
17807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17808 if (SWIG_arg_fail(1)) SWIG_fail;
17809 {
17810 PyThreadState* __tstate = wxPyBeginAllowThreads();
17811 wxPyArtProvider_Destroy(arg1);
17812
17813 wxPyEndAllowThreads(__tstate);
17814 if (PyErr_Occurred()) SWIG_fail;
17815 }
17816 Py_INCREF(Py_None); resultobj = Py_None;
17817 return resultobj;
17818 fail:
17819 return NULL;
17820 }
17821
17822
17823 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
17824 PyObject *obj;
17825 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17826 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
17827 Py_INCREF(obj);
17828 return Py_BuildValue((char *)"");
17829 }
17830 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
17831 PyObject *resultobj = NULL;
17832 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17833 PyObject * obj0 = 0 ;
17834 char *kwnames[] = {
17835 (char *) "self", NULL
17836 };
17837
17838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
17839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17840 if (SWIG_arg_fail(1)) SWIG_fail;
17841 {
17842 PyThreadState* __tstate = wxPyBeginAllowThreads();
17843 delete arg1;
17844
17845 wxPyEndAllowThreads(__tstate);
17846 if (PyErr_Occurred()) SWIG_fail;
17847 }
17848 Py_INCREF(Py_None); resultobj = Py_None;
17849 return resultobj;
17850 fail:
17851 return NULL;
17852 }
17853
17854
17855 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
17856 PyObject *resultobj = NULL;
17857 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17858 wxConfigBase *result;
17859 PyObject * obj0 = 0 ;
17860 char *kwnames[] = {
17861 (char *) "config", NULL
17862 };
17863
17864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
17865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
17866 if (SWIG_arg_fail(1)) SWIG_fail;
17867 {
17868 PyThreadState* __tstate = wxPyBeginAllowThreads();
17869 result = (wxConfigBase *)wxConfigBase::Set(arg1);
17870
17871 wxPyEndAllowThreads(__tstate);
17872 if (PyErr_Occurred()) SWIG_fail;
17873 }
17874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17875 return resultobj;
17876 fail:
17877 return NULL;
17878 }
17879
17880
17881 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
17882 PyObject *resultobj = NULL;
17883 bool arg1 = (bool) true ;
17884 wxConfigBase *result;
17885 PyObject * obj0 = 0 ;
17886 char *kwnames[] = {
17887 (char *) "createOnDemand", NULL
17888 };
17889
17890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
17891 if (obj0) {
17892 {
17893 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
17894 if (SWIG_arg_fail(1)) SWIG_fail;
17895 }
17896 }
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 result = (wxConfigBase *)wxConfigBase::Get(arg1);
17900
17901 wxPyEndAllowThreads(__tstate);
17902 if (PyErr_Occurred()) SWIG_fail;
17903 }
17904 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17905 return resultobj;
17906 fail:
17907 return NULL;
17908 }
17909
17910
17911 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17912 PyObject *resultobj = NULL;
17913 wxConfigBase *result;
17914 char *kwnames[] = {
17915 NULL
17916 };
17917
17918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
17919 {
17920 PyThreadState* __tstate = wxPyBeginAllowThreads();
17921 result = (wxConfigBase *)wxConfigBase::Create();
17922
17923 wxPyEndAllowThreads(__tstate);
17924 if (PyErr_Occurred()) SWIG_fail;
17925 }
17926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17927 return resultobj;
17928 fail:
17929 return NULL;
17930 }
17931
17932
17933 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17934 PyObject *resultobj = NULL;
17935 char *kwnames[] = {
17936 NULL
17937 };
17938
17939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17940 {
17941 PyThreadState* __tstate = wxPyBeginAllowThreads();
17942 wxConfigBase::DontCreateOnDemand();
17943
17944 wxPyEndAllowThreads(__tstate);
17945 if (PyErr_Occurred()) SWIG_fail;
17946 }
17947 Py_INCREF(Py_None); resultobj = Py_None;
17948 return resultobj;
17949 fail:
17950 return NULL;
17951 }
17952
17953
17954 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17955 PyObject *resultobj = NULL;
17956 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17957 wxString *arg2 = 0 ;
17958 bool temp2 = false ;
17959 PyObject * obj0 = 0 ;
17960 PyObject * obj1 = 0 ;
17961 char *kwnames[] = {
17962 (char *) "self",(char *) "path", NULL
17963 };
17964
17965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17967 if (SWIG_arg_fail(1)) SWIG_fail;
17968 {
17969 arg2 = wxString_in_helper(obj1);
17970 if (arg2 == NULL) SWIG_fail;
17971 temp2 = true;
17972 }
17973 {
17974 PyThreadState* __tstate = wxPyBeginAllowThreads();
17975 (arg1)->SetPath((wxString const &)*arg2);
17976
17977 wxPyEndAllowThreads(__tstate);
17978 if (PyErr_Occurred()) SWIG_fail;
17979 }
17980 Py_INCREF(Py_None); resultobj = Py_None;
17981 {
17982 if (temp2)
17983 delete arg2;
17984 }
17985 return resultobj;
17986 fail:
17987 {
17988 if (temp2)
17989 delete arg2;
17990 }
17991 return NULL;
17992 }
17993
17994
17995 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17996 PyObject *resultobj = NULL;
17997 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17998 wxString *result;
17999 PyObject * obj0 = 0 ;
18000 char *kwnames[] = {
18001 (char *) "self", NULL
18002 };
18003
18004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
18005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18006 if (SWIG_arg_fail(1)) SWIG_fail;
18007 {
18008 PyThreadState* __tstate = wxPyBeginAllowThreads();
18009 {
18010 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
18011 result = (wxString *) &_result_ref;
18012 }
18013
18014 wxPyEndAllowThreads(__tstate);
18015 if (PyErr_Occurred()) SWIG_fail;
18016 }
18017 {
18018 #if wxUSE_UNICODE
18019 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18020 #else
18021 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18022 #endif
18023 }
18024 return resultobj;
18025 fail:
18026 return NULL;
18027 }
18028
18029
18030 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18031 PyObject *resultobj = NULL;
18032 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18033 PyObject *result;
18034 PyObject * obj0 = 0 ;
18035 char *kwnames[] = {
18036 (char *) "self", NULL
18037 };
18038
18039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
18040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18041 if (SWIG_arg_fail(1)) SWIG_fail;
18042 {
18043 PyThreadState* __tstate = wxPyBeginAllowThreads();
18044 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
18045
18046 wxPyEndAllowThreads(__tstate);
18047 if (PyErr_Occurred()) SWIG_fail;
18048 }
18049 resultobj = result;
18050 return resultobj;
18051 fail:
18052 return NULL;
18053 }
18054
18055
18056 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18057 PyObject *resultobj = NULL;
18058 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18059 long arg2 ;
18060 PyObject *result;
18061 PyObject * obj0 = 0 ;
18062 PyObject * obj1 = 0 ;
18063 char *kwnames[] = {
18064 (char *) "self",(char *) "index", NULL
18065 };
18066
18067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
18068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18069 if (SWIG_arg_fail(1)) SWIG_fail;
18070 {
18071 arg2 = static_cast<long >(SWIG_As_long(obj1));
18072 if (SWIG_arg_fail(2)) SWIG_fail;
18073 }
18074 {
18075 PyThreadState* __tstate = wxPyBeginAllowThreads();
18076 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
18077
18078 wxPyEndAllowThreads(__tstate);
18079 if (PyErr_Occurred()) SWIG_fail;
18080 }
18081 resultobj = result;
18082 return resultobj;
18083 fail:
18084 return NULL;
18085 }
18086
18087
18088 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18089 PyObject *resultobj = NULL;
18090 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18091 PyObject *result;
18092 PyObject * obj0 = 0 ;
18093 char *kwnames[] = {
18094 (char *) "self", NULL
18095 };
18096
18097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
18098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18099 if (SWIG_arg_fail(1)) SWIG_fail;
18100 {
18101 PyThreadState* __tstate = wxPyBeginAllowThreads();
18102 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
18103
18104 wxPyEndAllowThreads(__tstate);
18105 if (PyErr_Occurred()) SWIG_fail;
18106 }
18107 resultobj = result;
18108 return resultobj;
18109 fail:
18110 return NULL;
18111 }
18112
18113
18114 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18115 PyObject *resultobj = NULL;
18116 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18117 long arg2 ;
18118 PyObject *result;
18119 PyObject * obj0 = 0 ;
18120 PyObject * obj1 = 0 ;
18121 char *kwnames[] = {
18122 (char *) "self",(char *) "index", NULL
18123 };
18124
18125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
18126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18127 if (SWIG_arg_fail(1)) SWIG_fail;
18128 {
18129 arg2 = static_cast<long >(SWIG_As_long(obj1));
18130 if (SWIG_arg_fail(2)) SWIG_fail;
18131 }
18132 {
18133 PyThreadState* __tstate = wxPyBeginAllowThreads();
18134 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
18135
18136 wxPyEndAllowThreads(__tstate);
18137 if (PyErr_Occurred()) SWIG_fail;
18138 }
18139 resultobj = result;
18140 return resultobj;
18141 fail:
18142 return NULL;
18143 }
18144
18145
18146 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
18147 PyObject *resultobj = NULL;
18148 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18149 bool arg2 = (bool) false ;
18150 size_t result;
18151 PyObject * obj0 = 0 ;
18152 PyObject * obj1 = 0 ;
18153 char *kwnames[] = {
18154 (char *) "self",(char *) "recursive", NULL
18155 };
18156
18157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
18158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18159 if (SWIG_arg_fail(1)) SWIG_fail;
18160 if (obj1) {
18161 {
18162 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18163 if (SWIG_arg_fail(2)) SWIG_fail;
18164 }
18165 }
18166 {
18167 PyThreadState* __tstate = wxPyBeginAllowThreads();
18168 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
18169
18170 wxPyEndAllowThreads(__tstate);
18171 if (PyErr_Occurred()) SWIG_fail;
18172 }
18173 {
18174 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
18175 }
18176 return resultobj;
18177 fail:
18178 return NULL;
18179 }
18180
18181
18182 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
18183 PyObject *resultobj = NULL;
18184 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18185 bool arg2 = (bool) false ;
18186 size_t result;
18187 PyObject * obj0 = 0 ;
18188 PyObject * obj1 = 0 ;
18189 char *kwnames[] = {
18190 (char *) "self",(char *) "recursive", NULL
18191 };
18192
18193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
18194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18195 if (SWIG_arg_fail(1)) SWIG_fail;
18196 if (obj1) {
18197 {
18198 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18199 if (SWIG_arg_fail(2)) SWIG_fail;
18200 }
18201 }
18202 {
18203 PyThreadState* __tstate = wxPyBeginAllowThreads();
18204 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
18205
18206 wxPyEndAllowThreads(__tstate);
18207 if (PyErr_Occurred()) SWIG_fail;
18208 }
18209 {
18210 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
18211 }
18212 return resultobj;
18213 fail:
18214 return NULL;
18215 }
18216
18217
18218 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18219 PyObject *resultobj = NULL;
18220 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18221 wxString *arg2 = 0 ;
18222 bool result;
18223 bool temp2 = false ;
18224 PyObject * obj0 = 0 ;
18225 PyObject * obj1 = 0 ;
18226 char *kwnames[] = {
18227 (char *) "self",(char *) "name", NULL
18228 };
18229
18230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
18231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18232 if (SWIG_arg_fail(1)) SWIG_fail;
18233 {
18234 arg2 = wxString_in_helper(obj1);
18235 if (arg2 == NULL) SWIG_fail;
18236 temp2 = true;
18237 }
18238 {
18239 PyThreadState* __tstate = wxPyBeginAllowThreads();
18240 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
18241
18242 wxPyEndAllowThreads(__tstate);
18243 if (PyErr_Occurred()) SWIG_fail;
18244 }
18245 {
18246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18247 }
18248 {
18249 if (temp2)
18250 delete arg2;
18251 }
18252 return resultobj;
18253 fail:
18254 {
18255 if (temp2)
18256 delete arg2;
18257 }
18258 return NULL;
18259 }
18260
18261
18262 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18263 PyObject *resultobj = NULL;
18264 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18265 wxString *arg2 = 0 ;
18266 bool result;
18267 bool temp2 = false ;
18268 PyObject * obj0 = 0 ;
18269 PyObject * obj1 = 0 ;
18270 char *kwnames[] = {
18271 (char *) "self",(char *) "name", NULL
18272 };
18273
18274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
18275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18276 if (SWIG_arg_fail(1)) SWIG_fail;
18277 {
18278 arg2 = wxString_in_helper(obj1);
18279 if (arg2 == NULL) SWIG_fail;
18280 temp2 = true;
18281 }
18282 {
18283 PyThreadState* __tstate = wxPyBeginAllowThreads();
18284 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
18285
18286 wxPyEndAllowThreads(__tstate);
18287 if (PyErr_Occurred()) SWIG_fail;
18288 }
18289 {
18290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18291 }
18292 {
18293 if (temp2)
18294 delete arg2;
18295 }
18296 return resultobj;
18297 fail:
18298 {
18299 if (temp2)
18300 delete arg2;
18301 }
18302 return NULL;
18303 }
18304
18305
18306 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
18307 PyObject *resultobj = NULL;
18308 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18309 wxString *arg2 = 0 ;
18310 bool result;
18311 bool temp2 = false ;
18312 PyObject * obj0 = 0 ;
18313 PyObject * obj1 = 0 ;
18314 char *kwnames[] = {
18315 (char *) "self",(char *) "name", NULL
18316 };
18317
18318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
18319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18320 if (SWIG_arg_fail(1)) SWIG_fail;
18321 {
18322 arg2 = wxString_in_helper(obj1);
18323 if (arg2 == NULL) SWIG_fail;
18324 temp2 = true;
18325 }
18326 {
18327 PyThreadState* __tstate = wxPyBeginAllowThreads();
18328 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
18329
18330 wxPyEndAllowThreads(__tstate);
18331 if (PyErr_Occurred()) SWIG_fail;
18332 }
18333 {
18334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18335 }
18336 {
18337 if (temp2)
18338 delete arg2;
18339 }
18340 return resultobj;
18341 fail:
18342 {
18343 if (temp2)
18344 delete arg2;
18345 }
18346 return NULL;
18347 }
18348
18349
18350 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
18351 PyObject *resultobj = NULL;
18352 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18353 wxString *arg2 = 0 ;
18354 wxConfigBase::EntryType result;
18355 bool temp2 = false ;
18356 PyObject * obj0 = 0 ;
18357 PyObject * obj1 = 0 ;
18358 char *kwnames[] = {
18359 (char *) "self",(char *) "name", NULL
18360 };
18361
18362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
18363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18364 if (SWIG_arg_fail(1)) SWIG_fail;
18365 {
18366 arg2 = wxString_in_helper(obj1);
18367 if (arg2 == NULL) SWIG_fail;
18368 temp2 = true;
18369 }
18370 {
18371 PyThreadState* __tstate = wxPyBeginAllowThreads();
18372 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
18373
18374 wxPyEndAllowThreads(__tstate);
18375 if (PyErr_Occurred()) SWIG_fail;
18376 }
18377 resultobj = SWIG_From_int((result));
18378 {
18379 if (temp2)
18380 delete arg2;
18381 }
18382 return resultobj;
18383 fail:
18384 {
18385 if (temp2)
18386 delete arg2;
18387 }
18388 return NULL;
18389 }
18390
18391
18392 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
18393 PyObject *resultobj = NULL;
18394 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18395 wxString *arg2 = 0 ;
18396 wxString const &arg3_defvalue = wxPyEmptyString ;
18397 wxString *arg3 = (wxString *) &arg3_defvalue ;
18398 wxString result;
18399 bool temp2 = false ;
18400 bool temp3 = false ;
18401 PyObject * obj0 = 0 ;
18402 PyObject * obj1 = 0 ;
18403 PyObject * obj2 = 0 ;
18404 char *kwnames[] = {
18405 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
18406 };
18407
18408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
18409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18410 if (SWIG_arg_fail(1)) SWIG_fail;
18411 {
18412 arg2 = wxString_in_helper(obj1);
18413 if (arg2 == NULL) SWIG_fail;
18414 temp2 = true;
18415 }
18416 if (obj2) {
18417 {
18418 arg3 = wxString_in_helper(obj2);
18419 if (arg3 == NULL) SWIG_fail;
18420 temp3 = true;
18421 }
18422 }
18423 {
18424 PyThreadState* __tstate = wxPyBeginAllowThreads();
18425 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
18426
18427 wxPyEndAllowThreads(__tstate);
18428 if (PyErr_Occurred()) SWIG_fail;
18429 }
18430 {
18431 #if wxUSE_UNICODE
18432 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18433 #else
18434 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18435 #endif
18436 }
18437 {
18438 if (temp2)
18439 delete arg2;
18440 }
18441 {
18442 if (temp3)
18443 delete arg3;
18444 }
18445 return resultobj;
18446 fail:
18447 {
18448 if (temp2)
18449 delete arg2;
18450 }
18451 {
18452 if (temp3)
18453 delete arg3;
18454 }
18455 return NULL;
18456 }
18457
18458
18459 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
18460 PyObject *resultobj = NULL;
18461 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18462 wxString *arg2 = 0 ;
18463 long arg3 = (long) 0 ;
18464 long result;
18465 bool temp2 = false ;
18466 PyObject * obj0 = 0 ;
18467 PyObject * obj1 = 0 ;
18468 PyObject * obj2 = 0 ;
18469 char *kwnames[] = {
18470 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
18471 };
18472
18473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
18474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18475 if (SWIG_arg_fail(1)) SWIG_fail;
18476 {
18477 arg2 = wxString_in_helper(obj1);
18478 if (arg2 == NULL) SWIG_fail;
18479 temp2 = true;
18480 }
18481 if (obj2) {
18482 {
18483 arg3 = static_cast<long >(SWIG_As_long(obj2));
18484 if (SWIG_arg_fail(3)) SWIG_fail;
18485 }
18486 }
18487 {
18488 PyThreadState* __tstate = wxPyBeginAllowThreads();
18489 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
18490
18491 wxPyEndAllowThreads(__tstate);
18492 if (PyErr_Occurred()) SWIG_fail;
18493 }
18494 {
18495 resultobj = SWIG_From_long(static_cast<long >(result));
18496 }
18497 {
18498 if (temp2)
18499 delete arg2;
18500 }
18501 return resultobj;
18502 fail:
18503 {
18504 if (temp2)
18505 delete arg2;
18506 }
18507 return NULL;
18508 }
18509
18510
18511 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
18512 PyObject *resultobj = NULL;
18513 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18514 wxString *arg2 = 0 ;
18515 double arg3 = (double) 0.0 ;
18516 double result;
18517 bool temp2 = false ;
18518 PyObject * obj0 = 0 ;
18519 PyObject * obj1 = 0 ;
18520 PyObject * obj2 = 0 ;
18521 char *kwnames[] = {
18522 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
18523 };
18524
18525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
18526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18527 if (SWIG_arg_fail(1)) SWIG_fail;
18528 {
18529 arg2 = wxString_in_helper(obj1);
18530 if (arg2 == NULL) SWIG_fail;
18531 temp2 = true;
18532 }
18533 if (obj2) {
18534 {
18535 arg3 = static_cast<double >(SWIG_As_double(obj2));
18536 if (SWIG_arg_fail(3)) SWIG_fail;
18537 }
18538 }
18539 {
18540 PyThreadState* __tstate = wxPyBeginAllowThreads();
18541 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
18542
18543 wxPyEndAllowThreads(__tstate);
18544 if (PyErr_Occurred()) SWIG_fail;
18545 }
18546 {
18547 resultobj = SWIG_From_double(static_cast<double >(result));
18548 }
18549 {
18550 if (temp2)
18551 delete arg2;
18552 }
18553 return resultobj;
18554 fail:
18555 {
18556 if (temp2)
18557 delete arg2;
18558 }
18559 return NULL;
18560 }
18561
18562
18563 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
18564 PyObject *resultobj = NULL;
18565 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18566 wxString *arg2 = 0 ;
18567 bool arg3 = (bool) false ;
18568 bool result;
18569 bool temp2 = false ;
18570 PyObject * obj0 = 0 ;
18571 PyObject * obj1 = 0 ;
18572 PyObject * obj2 = 0 ;
18573 char *kwnames[] = {
18574 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
18575 };
18576
18577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
18578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18579 if (SWIG_arg_fail(1)) SWIG_fail;
18580 {
18581 arg2 = wxString_in_helper(obj1);
18582 if (arg2 == NULL) SWIG_fail;
18583 temp2 = true;
18584 }
18585 if (obj2) {
18586 {
18587 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
18588 if (SWIG_arg_fail(3)) SWIG_fail;
18589 }
18590 }
18591 {
18592 PyThreadState* __tstate = wxPyBeginAllowThreads();
18593 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
18594
18595 wxPyEndAllowThreads(__tstate);
18596 if (PyErr_Occurred()) SWIG_fail;
18597 }
18598 {
18599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18600 }
18601 {
18602 if (temp2)
18603 delete arg2;
18604 }
18605 return resultobj;
18606 fail:
18607 {
18608 if (temp2)
18609 delete arg2;
18610 }
18611 return NULL;
18612 }
18613
18614
18615 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
18616 PyObject *resultobj = NULL;
18617 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18618 wxString *arg2 = 0 ;
18619 wxString *arg3 = 0 ;
18620 bool result;
18621 bool temp2 = false ;
18622 bool temp3 = false ;
18623 PyObject * obj0 = 0 ;
18624 PyObject * obj1 = 0 ;
18625 PyObject * obj2 = 0 ;
18626 char *kwnames[] = {
18627 (char *) "self",(char *) "key",(char *) "value", NULL
18628 };
18629
18630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
18631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18632 if (SWIG_arg_fail(1)) SWIG_fail;
18633 {
18634 arg2 = wxString_in_helper(obj1);
18635 if (arg2 == NULL) SWIG_fail;
18636 temp2 = true;
18637 }
18638 {
18639 arg3 = wxString_in_helper(obj2);
18640 if (arg3 == NULL) SWIG_fail;
18641 temp3 = true;
18642 }
18643 {
18644 PyThreadState* __tstate = wxPyBeginAllowThreads();
18645 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
18646
18647 wxPyEndAllowThreads(__tstate);
18648 if (PyErr_Occurred()) SWIG_fail;
18649 }
18650 {
18651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18652 }
18653 {
18654 if (temp2)
18655 delete arg2;
18656 }
18657 {
18658 if (temp3)
18659 delete arg3;
18660 }
18661 return resultobj;
18662 fail:
18663 {
18664 if (temp2)
18665 delete arg2;
18666 }
18667 {
18668 if (temp3)
18669 delete arg3;
18670 }
18671 return NULL;
18672 }
18673
18674
18675 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
18676 PyObject *resultobj = NULL;
18677 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18678 wxString *arg2 = 0 ;
18679 long arg3 ;
18680 bool result;
18681 bool temp2 = false ;
18682 PyObject * obj0 = 0 ;
18683 PyObject * obj1 = 0 ;
18684 PyObject * obj2 = 0 ;
18685 char *kwnames[] = {
18686 (char *) "self",(char *) "key",(char *) "value", NULL
18687 };
18688
18689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
18690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18691 if (SWIG_arg_fail(1)) SWIG_fail;
18692 {
18693 arg2 = wxString_in_helper(obj1);
18694 if (arg2 == NULL) SWIG_fail;
18695 temp2 = true;
18696 }
18697 {
18698 arg3 = static_cast<long >(SWIG_As_long(obj2));
18699 if (SWIG_arg_fail(3)) SWIG_fail;
18700 }
18701 {
18702 PyThreadState* __tstate = wxPyBeginAllowThreads();
18703 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
18704
18705 wxPyEndAllowThreads(__tstate);
18706 if (PyErr_Occurred()) SWIG_fail;
18707 }
18708 {
18709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18710 }
18711 {
18712 if (temp2)
18713 delete arg2;
18714 }
18715 return resultobj;
18716 fail:
18717 {
18718 if (temp2)
18719 delete arg2;
18720 }
18721 return NULL;
18722 }
18723
18724
18725 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
18726 PyObject *resultobj = NULL;
18727 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18728 wxString *arg2 = 0 ;
18729 double arg3 ;
18730 bool result;
18731 bool temp2 = false ;
18732 PyObject * obj0 = 0 ;
18733 PyObject * obj1 = 0 ;
18734 PyObject * obj2 = 0 ;
18735 char *kwnames[] = {
18736 (char *) "self",(char *) "key",(char *) "value", NULL
18737 };
18738
18739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
18740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18741 if (SWIG_arg_fail(1)) SWIG_fail;
18742 {
18743 arg2 = wxString_in_helper(obj1);
18744 if (arg2 == NULL) SWIG_fail;
18745 temp2 = true;
18746 }
18747 {
18748 arg3 = static_cast<double >(SWIG_As_double(obj2));
18749 if (SWIG_arg_fail(3)) SWIG_fail;
18750 }
18751 {
18752 PyThreadState* __tstate = wxPyBeginAllowThreads();
18753 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
18754
18755 wxPyEndAllowThreads(__tstate);
18756 if (PyErr_Occurred()) SWIG_fail;
18757 }
18758 {
18759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18760 }
18761 {
18762 if (temp2)
18763 delete arg2;
18764 }
18765 return resultobj;
18766 fail:
18767 {
18768 if (temp2)
18769 delete arg2;
18770 }
18771 return NULL;
18772 }
18773
18774
18775 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
18776 PyObject *resultobj = NULL;
18777 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18778 wxString *arg2 = 0 ;
18779 bool arg3 ;
18780 bool result;
18781 bool temp2 = false ;
18782 PyObject * obj0 = 0 ;
18783 PyObject * obj1 = 0 ;
18784 PyObject * obj2 = 0 ;
18785 char *kwnames[] = {
18786 (char *) "self",(char *) "key",(char *) "value", NULL
18787 };
18788
18789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
18790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18791 if (SWIG_arg_fail(1)) SWIG_fail;
18792 {
18793 arg2 = wxString_in_helper(obj1);
18794 if (arg2 == NULL) SWIG_fail;
18795 temp2 = true;
18796 }
18797 {
18798 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
18799 if (SWIG_arg_fail(3)) SWIG_fail;
18800 }
18801 {
18802 PyThreadState* __tstate = wxPyBeginAllowThreads();
18803 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
18804
18805 wxPyEndAllowThreads(__tstate);
18806 if (PyErr_Occurred()) SWIG_fail;
18807 }
18808 {
18809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18810 }
18811 {
18812 if (temp2)
18813 delete arg2;
18814 }
18815 return resultobj;
18816 fail:
18817 {
18818 if (temp2)
18819 delete arg2;
18820 }
18821 return NULL;
18822 }
18823
18824
18825 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
18826 PyObject *resultobj = NULL;
18827 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18828 bool arg2 = (bool) false ;
18829 bool result;
18830 PyObject * obj0 = 0 ;
18831 PyObject * obj1 = 0 ;
18832 char *kwnames[] = {
18833 (char *) "self",(char *) "currentOnly", NULL
18834 };
18835
18836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
18837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18838 if (SWIG_arg_fail(1)) SWIG_fail;
18839 if (obj1) {
18840 {
18841 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18842 if (SWIG_arg_fail(2)) SWIG_fail;
18843 }
18844 }
18845 {
18846 PyThreadState* __tstate = wxPyBeginAllowThreads();
18847 result = (bool)(arg1)->Flush(arg2);
18848
18849 wxPyEndAllowThreads(__tstate);
18850 if (PyErr_Occurred()) SWIG_fail;
18851 }
18852 {
18853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18854 }
18855 return resultobj;
18856 fail:
18857 return NULL;
18858 }
18859
18860
18861 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18862 PyObject *resultobj = NULL;
18863 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18864 wxString *arg2 = 0 ;
18865 wxString *arg3 = 0 ;
18866 bool result;
18867 bool temp2 = false ;
18868 bool temp3 = false ;
18869 PyObject * obj0 = 0 ;
18870 PyObject * obj1 = 0 ;
18871 PyObject * obj2 = 0 ;
18872 char *kwnames[] = {
18873 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18874 };
18875
18876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18878 if (SWIG_arg_fail(1)) SWIG_fail;
18879 {
18880 arg2 = wxString_in_helper(obj1);
18881 if (arg2 == NULL) SWIG_fail;
18882 temp2 = true;
18883 }
18884 {
18885 arg3 = wxString_in_helper(obj2);
18886 if (arg3 == NULL) SWIG_fail;
18887 temp3 = true;
18888 }
18889 {
18890 PyThreadState* __tstate = wxPyBeginAllowThreads();
18891 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
18892
18893 wxPyEndAllowThreads(__tstate);
18894 if (PyErr_Occurred()) SWIG_fail;
18895 }
18896 {
18897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18898 }
18899 {
18900 if (temp2)
18901 delete arg2;
18902 }
18903 {
18904 if (temp3)
18905 delete arg3;
18906 }
18907 return resultobj;
18908 fail:
18909 {
18910 if (temp2)
18911 delete arg2;
18912 }
18913 {
18914 if (temp3)
18915 delete arg3;
18916 }
18917 return NULL;
18918 }
18919
18920
18921 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18922 PyObject *resultobj = NULL;
18923 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18924 wxString *arg2 = 0 ;
18925 wxString *arg3 = 0 ;
18926 bool result;
18927 bool temp2 = false ;
18928 bool temp3 = false ;
18929 PyObject * obj0 = 0 ;
18930 PyObject * obj1 = 0 ;
18931 PyObject * obj2 = 0 ;
18932 char *kwnames[] = {
18933 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18934 };
18935
18936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18938 if (SWIG_arg_fail(1)) SWIG_fail;
18939 {
18940 arg2 = wxString_in_helper(obj1);
18941 if (arg2 == NULL) SWIG_fail;
18942 temp2 = true;
18943 }
18944 {
18945 arg3 = wxString_in_helper(obj2);
18946 if (arg3 == NULL) SWIG_fail;
18947 temp3 = true;
18948 }
18949 {
18950 PyThreadState* __tstate = wxPyBeginAllowThreads();
18951 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18952
18953 wxPyEndAllowThreads(__tstate);
18954 if (PyErr_Occurred()) SWIG_fail;
18955 }
18956 {
18957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18958 }
18959 {
18960 if (temp2)
18961 delete arg2;
18962 }
18963 {
18964 if (temp3)
18965 delete arg3;
18966 }
18967 return resultobj;
18968 fail:
18969 {
18970 if (temp2)
18971 delete arg2;
18972 }
18973 {
18974 if (temp3)
18975 delete arg3;
18976 }
18977 return NULL;
18978 }
18979
18980
18981 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18982 PyObject *resultobj = NULL;
18983 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18984 wxString *arg2 = 0 ;
18985 bool arg3 = (bool) true ;
18986 bool result;
18987 bool temp2 = false ;
18988 PyObject * obj0 = 0 ;
18989 PyObject * obj1 = 0 ;
18990 PyObject * obj2 = 0 ;
18991 char *kwnames[] = {
18992 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18993 };
18994
18995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18997 if (SWIG_arg_fail(1)) SWIG_fail;
18998 {
18999 arg2 = wxString_in_helper(obj1);
19000 if (arg2 == NULL) SWIG_fail;
19001 temp2 = true;
19002 }
19003 if (obj2) {
19004 {
19005 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
19006 if (SWIG_arg_fail(3)) SWIG_fail;
19007 }
19008 }
19009 {
19010 PyThreadState* __tstate = wxPyBeginAllowThreads();
19011 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
19012
19013 wxPyEndAllowThreads(__tstate);
19014 if (PyErr_Occurred()) SWIG_fail;
19015 }
19016 {
19017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19018 }
19019 {
19020 if (temp2)
19021 delete arg2;
19022 }
19023 return resultobj;
19024 fail:
19025 {
19026 if (temp2)
19027 delete arg2;
19028 }
19029 return NULL;
19030 }
19031
19032
19033 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
19034 PyObject *resultobj = NULL;
19035 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19036 wxString *arg2 = 0 ;
19037 bool result;
19038 bool temp2 = false ;
19039 PyObject * obj0 = 0 ;
19040 PyObject * obj1 = 0 ;
19041 char *kwnames[] = {
19042 (char *) "self",(char *) "key", NULL
19043 };
19044
19045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
19046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19047 if (SWIG_arg_fail(1)) SWIG_fail;
19048 {
19049 arg2 = wxString_in_helper(obj1);
19050 if (arg2 == NULL) SWIG_fail;
19051 temp2 = true;
19052 }
19053 {
19054 PyThreadState* __tstate = wxPyBeginAllowThreads();
19055 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
19056
19057 wxPyEndAllowThreads(__tstate);
19058 if (PyErr_Occurred()) SWIG_fail;
19059 }
19060 {
19061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19062 }
19063 {
19064 if (temp2)
19065 delete arg2;
19066 }
19067 return resultobj;
19068 fail:
19069 {
19070 if (temp2)
19071 delete arg2;
19072 }
19073 return NULL;
19074 }
19075
19076
19077 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
19078 PyObject *resultobj = NULL;
19079 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19080 bool result;
19081 PyObject * obj0 = 0 ;
19082 char *kwnames[] = {
19083 (char *) "self", NULL
19084 };
19085
19086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
19087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19088 if (SWIG_arg_fail(1)) SWIG_fail;
19089 {
19090 PyThreadState* __tstate = wxPyBeginAllowThreads();
19091 result = (bool)(arg1)->DeleteAll();
19092
19093 wxPyEndAllowThreads(__tstate);
19094 if (PyErr_Occurred()) SWIG_fail;
19095 }
19096 {
19097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19098 }
19099 return resultobj;
19100 fail:
19101 return NULL;
19102 }
19103
19104
19105 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19106 PyObject *resultobj = NULL;
19107 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19108 bool arg2 = (bool) true ;
19109 PyObject * obj0 = 0 ;
19110 PyObject * obj1 = 0 ;
19111 char *kwnames[] = {
19112 (char *) "self",(char *) "doIt", NULL
19113 };
19114
19115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
19116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19117 if (SWIG_arg_fail(1)) SWIG_fail;
19118 if (obj1) {
19119 {
19120 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19121 if (SWIG_arg_fail(2)) SWIG_fail;
19122 }
19123 }
19124 {
19125 PyThreadState* __tstate = wxPyBeginAllowThreads();
19126 (arg1)->SetExpandEnvVars(arg2);
19127
19128 wxPyEndAllowThreads(__tstate);
19129 if (PyErr_Occurred()) SWIG_fail;
19130 }
19131 Py_INCREF(Py_None); resultobj = Py_None;
19132 return resultobj;
19133 fail:
19134 return NULL;
19135 }
19136
19137
19138 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19139 PyObject *resultobj = NULL;
19140 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19141 bool result;
19142 PyObject * obj0 = 0 ;
19143 char *kwnames[] = {
19144 (char *) "self", NULL
19145 };
19146
19147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
19148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19149 if (SWIG_arg_fail(1)) SWIG_fail;
19150 {
19151 PyThreadState* __tstate = wxPyBeginAllowThreads();
19152 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
19153
19154 wxPyEndAllowThreads(__tstate);
19155 if (PyErr_Occurred()) SWIG_fail;
19156 }
19157 {
19158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19159 }
19160 return resultobj;
19161 fail:
19162 return NULL;
19163 }
19164
19165
19166 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
19167 PyObject *resultobj = NULL;
19168 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19169 bool arg2 = (bool) true ;
19170 PyObject * obj0 = 0 ;
19171 PyObject * obj1 = 0 ;
19172 char *kwnames[] = {
19173 (char *) "self",(char *) "doIt", NULL
19174 };
19175
19176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
19177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19178 if (SWIG_arg_fail(1)) SWIG_fail;
19179 if (obj1) {
19180 {
19181 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19182 if (SWIG_arg_fail(2)) SWIG_fail;
19183 }
19184 }
19185 {
19186 PyThreadState* __tstate = wxPyBeginAllowThreads();
19187 (arg1)->SetRecordDefaults(arg2);
19188
19189 wxPyEndAllowThreads(__tstate);
19190 if (PyErr_Occurred()) SWIG_fail;
19191 }
19192 Py_INCREF(Py_None); resultobj = Py_None;
19193 return resultobj;
19194 fail:
19195 return NULL;
19196 }
19197
19198
19199 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
19200 PyObject *resultobj = NULL;
19201 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19202 bool result;
19203 PyObject * obj0 = 0 ;
19204 char *kwnames[] = {
19205 (char *) "self", NULL
19206 };
19207
19208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
19209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19210 if (SWIG_arg_fail(1)) SWIG_fail;
19211 {
19212 PyThreadState* __tstate = wxPyBeginAllowThreads();
19213 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
19214
19215 wxPyEndAllowThreads(__tstate);
19216 if (PyErr_Occurred()) SWIG_fail;
19217 }
19218 {
19219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19220 }
19221 return resultobj;
19222 fail:
19223 return NULL;
19224 }
19225
19226
19227 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19228 PyObject *resultobj = NULL;
19229 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19230 wxString *arg2 = 0 ;
19231 wxString result;
19232 bool temp2 = false ;
19233 PyObject * obj0 = 0 ;
19234 PyObject * obj1 = 0 ;
19235 char *kwnames[] = {
19236 (char *) "self",(char *) "str", NULL
19237 };
19238
19239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
19240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19241 if (SWIG_arg_fail(1)) SWIG_fail;
19242 {
19243 arg2 = wxString_in_helper(obj1);
19244 if (arg2 == NULL) SWIG_fail;
19245 temp2 = true;
19246 }
19247 {
19248 PyThreadState* __tstate = wxPyBeginAllowThreads();
19249 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
19250
19251 wxPyEndAllowThreads(__tstate);
19252 if (PyErr_Occurred()) SWIG_fail;
19253 }
19254 {
19255 #if wxUSE_UNICODE
19256 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19257 #else
19258 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19259 #endif
19260 }
19261 {
19262 if (temp2)
19263 delete arg2;
19264 }
19265 return resultobj;
19266 fail:
19267 {
19268 if (temp2)
19269 delete arg2;
19270 }
19271 return NULL;
19272 }
19273
19274
19275 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
19276 PyObject *resultobj = NULL;
19277 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19278 wxString result;
19279 PyObject * obj0 = 0 ;
19280 char *kwnames[] = {
19281 (char *) "self", NULL
19282 };
19283
19284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
19289 result = ((wxConfigBase const *)arg1)->GetAppName();
19290
19291 wxPyEndAllowThreads(__tstate);
19292 if (PyErr_Occurred()) SWIG_fail;
19293 }
19294 {
19295 #if wxUSE_UNICODE
19296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19297 #else
19298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19299 #endif
19300 }
19301 return resultobj;
19302 fail:
19303 return NULL;
19304 }
19305
19306
19307 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
19308 PyObject *resultobj = NULL;
19309 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19310 wxString result;
19311 PyObject * obj0 = 0 ;
19312 char *kwnames[] = {
19313 (char *) "self", NULL
19314 };
19315
19316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
19317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19318 if (SWIG_arg_fail(1)) SWIG_fail;
19319 {
19320 PyThreadState* __tstate = wxPyBeginAllowThreads();
19321 result = ((wxConfigBase const *)arg1)->GetVendorName();
19322
19323 wxPyEndAllowThreads(__tstate);
19324 if (PyErr_Occurred()) SWIG_fail;
19325 }
19326 {
19327 #if wxUSE_UNICODE
19328 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19329 #else
19330 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19331 #endif
19332 }
19333 return resultobj;
19334 fail:
19335 return NULL;
19336 }
19337
19338
19339 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
19340 PyObject *resultobj = NULL;
19341 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19342 wxString *arg2 = 0 ;
19343 bool temp2 = false ;
19344 PyObject * obj0 = 0 ;
19345 PyObject * obj1 = 0 ;
19346 char *kwnames[] = {
19347 (char *) "self",(char *) "appName", NULL
19348 };
19349
19350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
19351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19352 if (SWIG_arg_fail(1)) SWIG_fail;
19353 {
19354 arg2 = wxString_in_helper(obj1);
19355 if (arg2 == NULL) SWIG_fail;
19356 temp2 = true;
19357 }
19358 {
19359 PyThreadState* __tstate = wxPyBeginAllowThreads();
19360 (arg1)->SetAppName((wxString const &)*arg2);
19361
19362 wxPyEndAllowThreads(__tstate);
19363 if (PyErr_Occurred()) SWIG_fail;
19364 }
19365 Py_INCREF(Py_None); resultobj = Py_None;
19366 {
19367 if (temp2)
19368 delete arg2;
19369 }
19370 return resultobj;
19371 fail:
19372 {
19373 if (temp2)
19374 delete arg2;
19375 }
19376 return NULL;
19377 }
19378
19379
19380 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
19381 PyObject *resultobj = NULL;
19382 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19383 wxString *arg2 = 0 ;
19384 bool temp2 = false ;
19385 PyObject * obj0 = 0 ;
19386 PyObject * obj1 = 0 ;
19387 char *kwnames[] = {
19388 (char *) "self",(char *) "vendorName", NULL
19389 };
19390
19391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
19392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19393 if (SWIG_arg_fail(1)) SWIG_fail;
19394 {
19395 arg2 = wxString_in_helper(obj1);
19396 if (arg2 == NULL) SWIG_fail;
19397 temp2 = true;
19398 }
19399 {
19400 PyThreadState* __tstate = wxPyBeginAllowThreads();
19401 (arg1)->SetVendorName((wxString const &)*arg2);
19402
19403 wxPyEndAllowThreads(__tstate);
19404 if (PyErr_Occurred()) SWIG_fail;
19405 }
19406 Py_INCREF(Py_None); resultobj = Py_None;
19407 {
19408 if (temp2)
19409 delete arg2;
19410 }
19411 return resultobj;
19412 fail:
19413 {
19414 if (temp2)
19415 delete arg2;
19416 }
19417 return NULL;
19418 }
19419
19420
19421 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
19422 PyObject *resultobj = NULL;
19423 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19424 long arg2 ;
19425 PyObject * obj0 = 0 ;
19426 PyObject * obj1 = 0 ;
19427 char *kwnames[] = {
19428 (char *) "self",(char *) "style", NULL
19429 };
19430
19431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
19432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19433 if (SWIG_arg_fail(1)) SWIG_fail;
19434 {
19435 arg2 = static_cast<long >(SWIG_As_long(obj1));
19436 if (SWIG_arg_fail(2)) SWIG_fail;
19437 }
19438 {
19439 PyThreadState* __tstate = wxPyBeginAllowThreads();
19440 (arg1)->SetStyle(arg2);
19441
19442 wxPyEndAllowThreads(__tstate);
19443 if (PyErr_Occurred()) SWIG_fail;
19444 }
19445 Py_INCREF(Py_None); resultobj = Py_None;
19446 return resultobj;
19447 fail:
19448 return NULL;
19449 }
19450
19451
19452 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
19453 PyObject *resultobj = NULL;
19454 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19455 long result;
19456 PyObject * obj0 = 0 ;
19457 char *kwnames[] = {
19458 (char *) "self", NULL
19459 };
19460
19461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
19462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19463 if (SWIG_arg_fail(1)) SWIG_fail;
19464 {
19465 PyThreadState* __tstate = wxPyBeginAllowThreads();
19466 result = (long)((wxConfigBase const *)arg1)->GetStyle();
19467
19468 wxPyEndAllowThreads(__tstate);
19469 if (PyErr_Occurred()) SWIG_fail;
19470 }
19471 {
19472 resultobj = SWIG_From_long(static_cast<long >(result));
19473 }
19474 return resultobj;
19475 fail:
19476 return NULL;
19477 }
19478
19479
19480 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
19481 PyObject *obj;
19482 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19483 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
19484 Py_INCREF(obj);
19485 return Py_BuildValue((char *)"");
19486 }
19487 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
19488 PyObject *resultobj = NULL;
19489 wxString const &arg1_defvalue = wxPyEmptyString ;
19490 wxString *arg1 = (wxString *) &arg1_defvalue ;
19491 wxString const &arg2_defvalue = wxPyEmptyString ;
19492 wxString *arg2 = (wxString *) &arg2_defvalue ;
19493 wxString const &arg3_defvalue = wxPyEmptyString ;
19494 wxString *arg3 = (wxString *) &arg3_defvalue ;
19495 wxString const &arg4_defvalue = wxPyEmptyString ;
19496 wxString *arg4 = (wxString *) &arg4_defvalue ;
19497 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
19498 wxConfig *result;
19499 bool temp1 = false ;
19500 bool temp2 = false ;
19501 bool temp3 = false ;
19502 bool temp4 = false ;
19503 PyObject * obj0 = 0 ;
19504 PyObject * obj1 = 0 ;
19505 PyObject * obj2 = 0 ;
19506 PyObject * obj3 = 0 ;
19507 PyObject * obj4 = 0 ;
19508 char *kwnames[] = {
19509 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
19510 };
19511
19512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19513 if (obj0) {
19514 {
19515 arg1 = wxString_in_helper(obj0);
19516 if (arg1 == NULL) SWIG_fail;
19517 temp1 = true;
19518 }
19519 }
19520 if (obj1) {
19521 {
19522 arg2 = wxString_in_helper(obj1);
19523 if (arg2 == NULL) SWIG_fail;
19524 temp2 = true;
19525 }
19526 }
19527 if (obj2) {
19528 {
19529 arg3 = wxString_in_helper(obj2);
19530 if (arg3 == NULL) SWIG_fail;
19531 temp3 = true;
19532 }
19533 }
19534 if (obj3) {
19535 {
19536 arg4 = wxString_in_helper(obj3);
19537 if (arg4 == NULL) SWIG_fail;
19538 temp4 = true;
19539 }
19540 }
19541 if (obj4) {
19542 {
19543 arg5 = static_cast<long >(SWIG_As_long(obj4));
19544 if (SWIG_arg_fail(5)) SWIG_fail;
19545 }
19546 }
19547 {
19548 PyThreadState* __tstate = wxPyBeginAllowThreads();
19549 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
19550
19551 wxPyEndAllowThreads(__tstate);
19552 if (PyErr_Occurred()) SWIG_fail;
19553 }
19554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
19555 {
19556 if (temp1)
19557 delete arg1;
19558 }
19559 {
19560 if (temp2)
19561 delete arg2;
19562 }
19563 {
19564 if (temp3)
19565 delete arg3;
19566 }
19567 {
19568 if (temp4)
19569 delete arg4;
19570 }
19571 return resultobj;
19572 fail:
19573 {
19574 if (temp1)
19575 delete arg1;
19576 }
19577 {
19578 if (temp2)
19579 delete arg2;
19580 }
19581 {
19582 if (temp3)
19583 delete arg3;
19584 }
19585 {
19586 if (temp4)
19587 delete arg4;
19588 }
19589 return NULL;
19590 }
19591
19592
19593 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
19594 PyObject *resultobj = NULL;
19595 wxConfig *arg1 = (wxConfig *) 0 ;
19596 PyObject * obj0 = 0 ;
19597 char *kwnames[] = {
19598 (char *) "self", NULL
19599 };
19600
19601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
19602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
19603 if (SWIG_arg_fail(1)) SWIG_fail;
19604 {
19605 PyThreadState* __tstate = wxPyBeginAllowThreads();
19606 delete arg1;
19607
19608 wxPyEndAllowThreads(__tstate);
19609 if (PyErr_Occurred()) SWIG_fail;
19610 }
19611 Py_INCREF(Py_None); resultobj = Py_None;
19612 return resultobj;
19613 fail:
19614 return NULL;
19615 }
19616
19617
19618 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
19619 PyObject *obj;
19620 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19621 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
19622 Py_INCREF(obj);
19623 return Py_BuildValue((char *)"");
19624 }
19625 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
19626 PyObject *resultobj = NULL;
19627 wxString const &arg1_defvalue = wxPyEmptyString ;
19628 wxString *arg1 = (wxString *) &arg1_defvalue ;
19629 wxString const &arg2_defvalue = wxPyEmptyString ;
19630 wxString *arg2 = (wxString *) &arg2_defvalue ;
19631 wxString const &arg3_defvalue = wxPyEmptyString ;
19632 wxString *arg3 = (wxString *) &arg3_defvalue ;
19633 wxString const &arg4_defvalue = wxPyEmptyString ;
19634 wxString *arg4 = (wxString *) &arg4_defvalue ;
19635 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
19636 wxFileConfig *result;
19637 bool temp1 = false ;
19638 bool temp2 = false ;
19639 bool temp3 = false ;
19640 bool temp4 = false ;
19641 PyObject * obj0 = 0 ;
19642 PyObject * obj1 = 0 ;
19643 PyObject * obj2 = 0 ;
19644 PyObject * obj3 = 0 ;
19645 PyObject * obj4 = 0 ;
19646 char *kwnames[] = {
19647 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
19648 };
19649
19650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19651 if (obj0) {
19652 {
19653 arg1 = wxString_in_helper(obj0);
19654 if (arg1 == NULL) SWIG_fail;
19655 temp1 = true;
19656 }
19657 }
19658 if (obj1) {
19659 {
19660 arg2 = wxString_in_helper(obj1);
19661 if (arg2 == NULL) SWIG_fail;
19662 temp2 = true;
19663 }
19664 }
19665 if (obj2) {
19666 {
19667 arg3 = wxString_in_helper(obj2);
19668 if (arg3 == NULL) SWIG_fail;
19669 temp3 = true;
19670 }
19671 }
19672 if (obj3) {
19673 {
19674 arg4 = wxString_in_helper(obj3);
19675 if (arg4 == NULL) SWIG_fail;
19676 temp4 = true;
19677 }
19678 }
19679 if (obj4) {
19680 {
19681 arg5 = static_cast<long >(SWIG_As_long(obj4));
19682 if (SWIG_arg_fail(5)) SWIG_fail;
19683 }
19684 }
19685 {
19686 PyThreadState* __tstate = wxPyBeginAllowThreads();
19687 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
19688
19689 wxPyEndAllowThreads(__tstate);
19690 if (PyErr_Occurred()) SWIG_fail;
19691 }
19692 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
19693 {
19694 if (temp1)
19695 delete arg1;
19696 }
19697 {
19698 if (temp2)
19699 delete arg2;
19700 }
19701 {
19702 if (temp3)
19703 delete arg3;
19704 }
19705 {
19706 if (temp4)
19707 delete arg4;
19708 }
19709 return resultobj;
19710 fail:
19711 {
19712 if (temp1)
19713 delete arg1;
19714 }
19715 {
19716 if (temp2)
19717 delete arg2;
19718 }
19719 {
19720 if (temp3)
19721 delete arg3;
19722 }
19723 {
19724 if (temp4)
19725 delete arg4;
19726 }
19727 return NULL;
19728 }
19729
19730
19731 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
19732 PyObject *resultobj = NULL;
19733 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
19734 PyObject * obj0 = 0 ;
19735 char *kwnames[] = {
19736 (char *) "self", NULL
19737 };
19738
19739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
19740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
19741 if (SWIG_arg_fail(1)) SWIG_fail;
19742 {
19743 PyThreadState* __tstate = wxPyBeginAllowThreads();
19744 delete arg1;
19745
19746 wxPyEndAllowThreads(__tstate);
19747 if (PyErr_Occurred()) SWIG_fail;
19748 }
19749 Py_INCREF(Py_None); resultobj = Py_None;
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
19757 PyObject *obj;
19758 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19759 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
19760 Py_INCREF(obj);
19761 return Py_BuildValue((char *)"");
19762 }
19763 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
19764 PyObject *resultobj = NULL;
19765 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19766 wxString *arg2 = 0 ;
19767 wxConfigPathChanger *result;
19768 bool temp2 = false ;
19769 PyObject * obj0 = 0 ;
19770 PyObject * obj1 = 0 ;
19771 char *kwnames[] = {
19772 (char *) "config",(char *) "entry", NULL
19773 };
19774
19775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
19776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19777 if (SWIG_arg_fail(1)) SWIG_fail;
19778 {
19779 arg2 = wxString_in_helper(obj1);
19780 if (arg2 == NULL) SWIG_fail;
19781 temp2 = true;
19782 }
19783 {
19784 PyThreadState* __tstate = wxPyBeginAllowThreads();
19785 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
19786
19787 wxPyEndAllowThreads(__tstate);
19788 if (PyErr_Occurred()) SWIG_fail;
19789 }
19790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
19791 {
19792 if (temp2)
19793 delete arg2;
19794 }
19795 return resultobj;
19796 fail:
19797 {
19798 if (temp2)
19799 delete arg2;
19800 }
19801 return NULL;
19802 }
19803
19804
19805 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
19806 PyObject *resultobj = NULL;
19807 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
19808 PyObject * obj0 = 0 ;
19809 char *kwnames[] = {
19810 (char *) "self", NULL
19811 };
19812
19813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
19814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
19815 if (SWIG_arg_fail(1)) SWIG_fail;
19816 {
19817 PyThreadState* __tstate = wxPyBeginAllowThreads();
19818 delete arg1;
19819
19820 wxPyEndAllowThreads(__tstate);
19821 if (PyErr_Occurred()) SWIG_fail;
19822 }
19823 Py_INCREF(Py_None); resultobj = Py_None;
19824 return resultobj;
19825 fail:
19826 return NULL;
19827 }
19828
19829
19830 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
19831 PyObject *resultobj = NULL;
19832 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
19833 wxString *result;
19834 PyObject * obj0 = 0 ;
19835 char *kwnames[] = {
19836 (char *) "self", NULL
19837 };
19838
19839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
19840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
19841 if (SWIG_arg_fail(1)) SWIG_fail;
19842 {
19843 PyThreadState* __tstate = wxPyBeginAllowThreads();
19844 {
19845 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
19846 result = (wxString *) &_result_ref;
19847 }
19848
19849 wxPyEndAllowThreads(__tstate);
19850 if (PyErr_Occurred()) SWIG_fail;
19851 }
19852 {
19853 #if wxUSE_UNICODE
19854 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19855 #else
19856 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19857 #endif
19858 }
19859 return resultobj;
19860 fail:
19861 return NULL;
19862 }
19863
19864
19865 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
19866 PyObject *obj;
19867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19868 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
19869 Py_INCREF(obj);
19870 return Py_BuildValue((char *)"");
19871 }
19872 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19873 PyObject *resultobj = NULL;
19874 wxString *arg1 = 0 ;
19875 wxString result;
19876 bool temp1 = false ;
19877 PyObject * obj0 = 0 ;
19878 char *kwnames[] = {
19879 (char *) "sz", NULL
19880 };
19881
19882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
19883 {
19884 arg1 = wxString_in_helper(obj0);
19885 if (arg1 == NULL) SWIG_fail;
19886 temp1 = true;
19887 }
19888 {
19889 PyThreadState* __tstate = wxPyBeginAllowThreads();
19890 result = wxExpandEnvVars((wxString const &)*arg1);
19891
19892 wxPyEndAllowThreads(__tstate);
19893 if (PyErr_Occurred()) SWIG_fail;
19894 }
19895 {
19896 #if wxUSE_UNICODE
19897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19898 #else
19899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19900 #endif
19901 }
19902 {
19903 if (temp1)
19904 delete arg1;
19905 }
19906 return resultobj;
19907 fail:
19908 {
19909 if (temp1)
19910 delete arg1;
19911 }
19912 return NULL;
19913 }
19914
19915
19916 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
19917 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
19918 return 1;
19919 }
19920
19921
19922 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19923 PyObject *pyobj = NULL;
19924
19925 {
19926 #if wxUSE_UNICODE
19927 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19928 #else
19929 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19930 #endif
19931 }
19932 return pyobj;
19933 }
19934
19935
19936 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19937 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19938 return 1;
19939 }
19940
19941
19942 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19943 PyObject *pyobj = NULL;
19944
19945 {
19946 #if wxUSE_UNICODE
19947 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19948 #else
19949 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19950 #endif
19951 }
19952 return pyobj;
19953 }
19954
19955
19956 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19957 PyObject *resultobj = NULL;
19958 wxDateTime::Country arg1 ;
19959 PyObject * obj0 = 0 ;
19960 char *kwnames[] = {
19961 (char *) "country", NULL
19962 };
19963
19964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19965 {
19966 arg1 = static_cast<wxDateTime::Country >(SWIG_As_int(obj0));
19967 if (SWIG_arg_fail(1)) SWIG_fail;
19968 }
19969 {
19970 PyThreadState* __tstate = wxPyBeginAllowThreads();
19971 wxDateTime::SetCountry(arg1);
19972
19973 wxPyEndAllowThreads(__tstate);
19974 if (PyErr_Occurred()) SWIG_fail;
19975 }
19976 Py_INCREF(Py_None); resultobj = Py_None;
19977 return resultobj;
19978 fail:
19979 return NULL;
19980 }
19981
19982
19983 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19984 PyObject *resultobj = NULL;
19985 wxDateTime::Country result;
19986 char *kwnames[] = {
19987 NULL
19988 };
19989
19990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19991 {
19992 PyThreadState* __tstate = wxPyBeginAllowThreads();
19993 result = (wxDateTime::Country)wxDateTime::GetCountry();
19994
19995 wxPyEndAllowThreads(__tstate);
19996 if (PyErr_Occurred()) SWIG_fail;
19997 }
19998 resultobj = SWIG_From_int((result));
19999 return resultobj;
20000 fail:
20001 return NULL;
20002 }
20003
20004
20005 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
20006 PyObject *resultobj = NULL;
20007 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
20008 bool result;
20009 PyObject * obj0 = 0 ;
20010 char *kwnames[] = {
20011 (char *) "country", NULL
20012 };
20013
20014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
20015 if (obj0) {
20016 {
20017 arg1 = static_cast<wxDateTime::Country >(SWIG_As_int(obj0));
20018 if (SWIG_arg_fail(1)) SWIG_fail;
20019 }
20020 }
20021 {
20022 PyThreadState* __tstate = wxPyBeginAllowThreads();
20023 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
20024
20025 wxPyEndAllowThreads(__tstate);
20026 if (PyErr_Occurred()) SWIG_fail;
20027 }
20028 {
20029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20030 }
20031 return resultobj;
20032 fail:
20033 return NULL;
20034 }
20035
20036
20037 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
20038 PyObject *resultobj = NULL;
20039 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20040 int result;
20041 PyObject * obj0 = 0 ;
20042 char *kwnames[] = {
20043 (char *) "cal", NULL
20044 };
20045
20046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
20047 if (obj0) {
20048 {
20049 arg1 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj0));
20050 if (SWIG_arg_fail(1)) SWIG_fail;
20051 }
20052 }
20053 {
20054 PyThreadState* __tstate = wxPyBeginAllowThreads();
20055 result = (int)wxDateTime::GetCurrentYear(arg1);
20056
20057 wxPyEndAllowThreads(__tstate);
20058 if (PyErr_Occurred()) SWIG_fail;
20059 }
20060 {
20061 resultobj = SWIG_From_int(static_cast<int >(result));
20062 }
20063 return resultobj;
20064 fail:
20065 return NULL;
20066 }
20067
20068
20069 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
20070 PyObject *resultobj = NULL;
20071 int arg1 ;
20072 int result;
20073 PyObject * obj0 = 0 ;
20074 char *kwnames[] = {
20075 (char *) "year", NULL
20076 };
20077
20078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
20079 {
20080 arg1 = static_cast<int >(SWIG_As_int(obj0));
20081 if (SWIG_arg_fail(1)) SWIG_fail;
20082 }
20083 {
20084 PyThreadState* __tstate = wxPyBeginAllowThreads();
20085 result = (int)wxDateTime::ConvertYearToBC(arg1);
20086
20087 wxPyEndAllowThreads(__tstate);
20088 if (PyErr_Occurred()) SWIG_fail;
20089 }
20090 {
20091 resultobj = SWIG_From_int(static_cast<int >(result));
20092 }
20093 return resultobj;
20094 fail:
20095 return NULL;
20096 }
20097
20098
20099 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20100 PyObject *resultobj = NULL;
20101 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20102 wxDateTime::Month result;
20103 PyObject * obj0 = 0 ;
20104 char *kwnames[] = {
20105 (char *) "cal", NULL
20106 };
20107
20108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
20109 if (obj0) {
20110 {
20111 arg1 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj0));
20112 if (SWIG_arg_fail(1)) SWIG_fail;
20113 }
20114 }
20115 {
20116 PyThreadState* __tstate = wxPyBeginAllowThreads();
20117 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
20118
20119 wxPyEndAllowThreads(__tstate);
20120 if (PyErr_Occurred()) SWIG_fail;
20121 }
20122 resultobj = SWIG_From_int((result));
20123 return resultobj;
20124 fail:
20125 return NULL;
20126 }
20127
20128
20129 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
20130 PyObject *resultobj = NULL;
20131 int arg1 = (int) wxDateTime::Inv_Year ;
20132 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20133 bool result;
20134 PyObject * obj0 = 0 ;
20135 PyObject * obj1 = 0 ;
20136 char *kwnames[] = {
20137 (char *) "year",(char *) "cal", NULL
20138 };
20139
20140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
20141 if (obj0) {
20142 {
20143 arg1 = static_cast<int >(SWIG_As_int(obj0));
20144 if (SWIG_arg_fail(1)) SWIG_fail;
20145 }
20146 }
20147 if (obj1) {
20148 {
20149 arg2 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj1));
20150 if (SWIG_arg_fail(2)) SWIG_fail;
20151 }
20152 }
20153 {
20154 PyThreadState* __tstate = wxPyBeginAllowThreads();
20155 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
20156
20157 wxPyEndAllowThreads(__tstate);
20158 if (PyErr_Occurred()) SWIG_fail;
20159 }
20160 {
20161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20162 }
20163 return resultobj;
20164 fail:
20165 return NULL;
20166 }
20167
20168
20169 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
20170 PyObject *resultobj = NULL;
20171 int arg1 = (int) wxDateTime::Inv_Year ;
20172 int result;
20173 PyObject * obj0 = 0 ;
20174 char *kwnames[] = {
20175 (char *) "year", NULL
20176 };
20177
20178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
20179 if (obj0) {
20180 {
20181 arg1 = static_cast<int >(SWIG_As_int(obj0));
20182 if (SWIG_arg_fail(1)) SWIG_fail;
20183 }
20184 }
20185 {
20186 PyThreadState* __tstate = wxPyBeginAllowThreads();
20187 result = (int)wxDateTime::GetCentury(arg1);
20188
20189 wxPyEndAllowThreads(__tstate);
20190 if (PyErr_Occurred()) SWIG_fail;
20191 }
20192 {
20193 resultobj = SWIG_From_int(static_cast<int >(result));
20194 }
20195 return resultobj;
20196 fail:
20197 return NULL;
20198 }
20199
20200
20201 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
20202 PyObject *resultobj = NULL;
20203 int arg1 ;
20204 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20205 int result;
20206 PyObject * obj0 = 0 ;
20207 PyObject * obj1 = 0 ;
20208 char *kwnames[] = {
20209 (char *) "year",(char *) "cal", NULL
20210 };
20211
20212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
20213 {
20214 arg1 = static_cast<int >(SWIG_As_int(obj0));
20215 if (SWIG_arg_fail(1)) SWIG_fail;
20216 }
20217 if (obj1) {
20218 {
20219 arg2 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj1));
20220 if (SWIG_arg_fail(2)) SWIG_fail;
20221 }
20222 }
20223 {
20224 PyThreadState* __tstate = wxPyBeginAllowThreads();
20225 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
20226
20227 wxPyEndAllowThreads(__tstate);
20228 if (PyErr_Occurred()) SWIG_fail;
20229 }
20230 {
20231 resultobj = SWIG_From_int(static_cast<int >(result));
20232 }
20233 return resultobj;
20234 fail:
20235 return NULL;
20236 }
20237
20238
20239 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20240 PyObject *resultobj = NULL;
20241 wxDateTime::Month arg1 ;
20242 int arg2 = (int) wxDateTime::Inv_Year ;
20243 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20244 int result;
20245 PyObject * obj0 = 0 ;
20246 PyObject * obj1 = 0 ;
20247 PyObject * obj2 = 0 ;
20248 char *kwnames[] = {
20249 (char *) "month",(char *) "year",(char *) "cal", NULL
20250 };
20251
20252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
20253 {
20254 arg1 = static_cast<wxDateTime::Month >(SWIG_As_int(obj0));
20255 if (SWIG_arg_fail(1)) SWIG_fail;
20256 }
20257 if (obj1) {
20258 {
20259 arg2 = static_cast<int >(SWIG_As_int(obj1));
20260 if (SWIG_arg_fail(2)) SWIG_fail;
20261 }
20262 }
20263 if (obj2) {
20264 {
20265 arg3 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj2));
20266 if (SWIG_arg_fail(3)) SWIG_fail;
20267 }
20268 }
20269 {
20270 PyThreadState* __tstate = wxPyBeginAllowThreads();
20271 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
20272
20273 wxPyEndAllowThreads(__tstate);
20274 if (PyErr_Occurred()) SWIG_fail;
20275 }
20276 {
20277 resultobj = SWIG_From_int(static_cast<int >(result));
20278 }
20279 return resultobj;
20280 fail:
20281 return NULL;
20282 }
20283
20284
20285 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
20286 PyObject *resultobj = NULL;
20287 wxDateTime::Month arg1 ;
20288 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
20289 wxString result;
20290 PyObject * obj0 = 0 ;
20291 PyObject * obj1 = 0 ;
20292 char *kwnames[] = {
20293 (char *) "month",(char *) "flags", NULL
20294 };
20295
20296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
20297 {
20298 arg1 = static_cast<wxDateTime::Month >(SWIG_As_int(obj0));
20299 if (SWIG_arg_fail(1)) SWIG_fail;
20300 }
20301 if (obj1) {
20302 {
20303 arg2 = static_cast<wxDateTime::NameFlags >(SWIG_As_int(obj1));
20304 if (SWIG_arg_fail(2)) SWIG_fail;
20305 }
20306 }
20307 {
20308 PyThreadState* __tstate = wxPyBeginAllowThreads();
20309 result = wxDateTime::GetMonthName(arg1,arg2);
20310
20311 wxPyEndAllowThreads(__tstate);
20312 if (PyErr_Occurred()) SWIG_fail;
20313 }
20314 {
20315 #if wxUSE_UNICODE
20316 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20317 #else
20318 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20319 #endif
20320 }
20321 return resultobj;
20322 fail:
20323 return NULL;
20324 }
20325
20326
20327 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
20328 PyObject *resultobj = NULL;
20329 wxDateTime::WeekDay arg1 ;
20330 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
20331 wxString result;
20332 PyObject * obj0 = 0 ;
20333 PyObject * obj1 = 0 ;
20334 char *kwnames[] = {
20335 (char *) "weekday",(char *) "flags", NULL
20336 };
20337
20338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
20339 {
20340 arg1 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj0));
20341 if (SWIG_arg_fail(1)) SWIG_fail;
20342 }
20343 if (obj1) {
20344 {
20345 arg2 = static_cast<wxDateTime::NameFlags >(SWIG_As_int(obj1));
20346 if (SWIG_arg_fail(2)) SWIG_fail;
20347 }
20348 }
20349 {
20350 PyThreadState* __tstate = wxPyBeginAllowThreads();
20351 result = wxDateTime::GetWeekDayName(arg1,arg2);
20352
20353 wxPyEndAllowThreads(__tstate);
20354 if (PyErr_Occurred()) SWIG_fail;
20355 }
20356 {
20357 #if wxUSE_UNICODE
20358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20359 #else
20360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20361 #endif
20362 }
20363 return resultobj;
20364 fail:
20365 return NULL;
20366 }
20367
20368
20369 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
20370 PyObject *resultobj = NULL;
20371 PyObject *result;
20372 char *kwnames[] = {
20373 NULL
20374 };
20375
20376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
20377 {
20378 PyThreadState* __tstate = wxPyBeginAllowThreads();
20379 result = (PyObject *)wxDateTime_GetAmPmStrings();
20380
20381 wxPyEndAllowThreads(__tstate);
20382 if (PyErr_Occurred()) SWIG_fail;
20383 }
20384 resultobj = result;
20385 return resultobj;
20386 fail:
20387 return NULL;
20388 }
20389
20390
20391 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
20392 PyObject *resultobj = NULL;
20393 int arg1 = (int) wxDateTime::Inv_Year ;
20394 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20395 bool result;
20396 PyObject * obj0 = 0 ;
20397 PyObject * obj1 = 0 ;
20398 char *kwnames[] = {
20399 (char *) "year",(char *) "country", NULL
20400 };
20401
20402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
20403 if (obj0) {
20404 {
20405 arg1 = static_cast<int >(SWIG_As_int(obj0));
20406 if (SWIG_arg_fail(1)) SWIG_fail;
20407 }
20408 }
20409 if (obj1) {
20410 {
20411 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
20412 if (SWIG_arg_fail(2)) SWIG_fail;
20413 }
20414 }
20415 {
20416 PyThreadState* __tstate = wxPyBeginAllowThreads();
20417 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
20418
20419 wxPyEndAllowThreads(__tstate);
20420 if (PyErr_Occurred()) SWIG_fail;
20421 }
20422 {
20423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20424 }
20425 return resultobj;
20426 fail:
20427 return NULL;
20428 }
20429
20430
20431 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
20432 PyObject *resultobj = NULL;
20433 int arg1 = (int) wxDateTime::Inv_Year ;
20434 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20435 wxDateTime result;
20436 PyObject * obj0 = 0 ;
20437 PyObject * obj1 = 0 ;
20438 char *kwnames[] = {
20439 (char *) "year",(char *) "country", NULL
20440 };
20441
20442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
20443 if (obj0) {
20444 {
20445 arg1 = static_cast<int >(SWIG_As_int(obj0));
20446 if (SWIG_arg_fail(1)) SWIG_fail;
20447 }
20448 }
20449 if (obj1) {
20450 {
20451 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
20452 if (SWIG_arg_fail(2)) SWIG_fail;
20453 }
20454 }
20455 {
20456 PyThreadState* __tstate = wxPyBeginAllowThreads();
20457 result = wxDateTime::GetBeginDST(arg1,arg2);
20458
20459 wxPyEndAllowThreads(__tstate);
20460 if (PyErr_Occurred()) SWIG_fail;
20461 }
20462 {
20463 wxDateTime * resultptr;
20464 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20465 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20466 }
20467 return resultobj;
20468 fail:
20469 return NULL;
20470 }
20471
20472
20473 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
20474 PyObject *resultobj = NULL;
20475 int arg1 = (int) wxDateTime::Inv_Year ;
20476 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20477 wxDateTime result;
20478 PyObject * obj0 = 0 ;
20479 PyObject * obj1 = 0 ;
20480 char *kwnames[] = {
20481 (char *) "year",(char *) "country", NULL
20482 };
20483
20484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
20485 if (obj0) {
20486 {
20487 arg1 = static_cast<int >(SWIG_As_int(obj0));
20488 if (SWIG_arg_fail(1)) SWIG_fail;
20489 }
20490 }
20491 if (obj1) {
20492 {
20493 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
20494 if (SWIG_arg_fail(2)) SWIG_fail;
20495 }
20496 }
20497 {
20498 PyThreadState* __tstate = wxPyBeginAllowThreads();
20499 result = wxDateTime::GetEndDST(arg1,arg2);
20500
20501 wxPyEndAllowThreads(__tstate);
20502 if (PyErr_Occurred()) SWIG_fail;
20503 }
20504 {
20505 wxDateTime * resultptr;
20506 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20507 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20508 }
20509 return resultobj;
20510 fail:
20511 return NULL;
20512 }
20513
20514
20515 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
20516 PyObject *resultobj = NULL;
20517 wxDateTime result;
20518 char *kwnames[] = {
20519 NULL
20520 };
20521
20522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
20523 {
20524 PyThreadState* __tstate = wxPyBeginAllowThreads();
20525 result = wxDateTime::Now();
20526
20527 wxPyEndAllowThreads(__tstate);
20528 if (PyErr_Occurred()) SWIG_fail;
20529 }
20530 {
20531 wxDateTime * resultptr;
20532 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20533 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20534 }
20535 return resultobj;
20536 fail:
20537 return NULL;
20538 }
20539
20540
20541 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
20542 PyObject *resultobj = NULL;
20543 wxDateTime result;
20544 char *kwnames[] = {
20545 NULL
20546 };
20547
20548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
20549 {
20550 PyThreadState* __tstate = wxPyBeginAllowThreads();
20551 result = wxDateTime::UNow();
20552
20553 wxPyEndAllowThreads(__tstate);
20554 if (PyErr_Occurred()) SWIG_fail;
20555 }
20556 {
20557 wxDateTime * resultptr;
20558 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20559 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20560 }
20561 return resultobj;
20562 fail:
20563 return NULL;
20564 }
20565
20566
20567 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
20568 PyObject *resultobj = NULL;
20569 wxDateTime result;
20570 char *kwnames[] = {
20571 NULL
20572 };
20573
20574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
20575 {
20576 PyThreadState* __tstate = wxPyBeginAllowThreads();
20577 result = wxDateTime::Today();
20578
20579 wxPyEndAllowThreads(__tstate);
20580 if (PyErr_Occurred()) SWIG_fail;
20581 }
20582 {
20583 wxDateTime * resultptr;
20584 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20585 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20586 }
20587 return resultobj;
20588 fail:
20589 return NULL;
20590 }
20591
20592
20593 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20594 PyObject *resultobj = NULL;
20595 wxDateTime *result;
20596 char *kwnames[] = {
20597 NULL
20598 };
20599
20600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
20601 {
20602 PyThreadState* __tstate = wxPyBeginAllowThreads();
20603 result = (wxDateTime *)new wxDateTime();
20604
20605 wxPyEndAllowThreads(__tstate);
20606 if (PyErr_Occurred()) SWIG_fail;
20607 }
20608 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20609 return resultobj;
20610 fail:
20611 return NULL;
20612 }
20613
20614
20615 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
20616 PyObject *resultobj = NULL;
20617 time_t arg1 ;
20618 wxDateTime *result;
20619 PyObject * obj0 = 0 ;
20620 char *kwnames[] = {
20621 (char *) "timet", NULL
20622 };
20623
20624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
20625 {
20626 arg1 = static_cast<time_t >(SWIG_As_unsigned_SS_int(obj0));
20627 if (SWIG_arg_fail(1)) SWIG_fail;
20628 }
20629 {
20630 PyThreadState* __tstate = wxPyBeginAllowThreads();
20631 result = (wxDateTime *)new wxDateTime(arg1);
20632
20633 wxPyEndAllowThreads(__tstate);
20634 if (PyErr_Occurred()) SWIG_fail;
20635 }
20636 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20637 return resultobj;
20638 fail:
20639 return NULL;
20640 }
20641
20642
20643 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20644 PyObject *resultobj = NULL;
20645 double arg1 ;
20646 wxDateTime *result;
20647 PyObject * obj0 = 0 ;
20648 char *kwnames[] = {
20649 (char *) "jdn", NULL
20650 };
20651
20652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
20653 {
20654 arg1 = static_cast<double >(SWIG_As_double(obj0));
20655 if (SWIG_arg_fail(1)) SWIG_fail;
20656 }
20657 {
20658 PyThreadState* __tstate = wxPyBeginAllowThreads();
20659 result = (wxDateTime *)new wxDateTime(arg1);
20660
20661 wxPyEndAllowThreads(__tstate);
20662 if (PyErr_Occurred()) SWIG_fail;
20663 }
20664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20665 return resultobj;
20666 fail:
20667 return NULL;
20668 }
20669
20670
20671 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20672 PyObject *resultobj = NULL;
20673 int arg1 ;
20674 int arg2 = (int) 0 ;
20675 int arg3 = (int) 0 ;
20676 int arg4 = (int) 0 ;
20677 wxDateTime *result;
20678 PyObject * obj0 = 0 ;
20679 PyObject * obj1 = 0 ;
20680 PyObject * obj2 = 0 ;
20681 PyObject * obj3 = 0 ;
20682 char *kwnames[] = {
20683 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20684 };
20685
20686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20687 {
20688 arg1 = static_cast<int >(SWIG_As_int(obj0));
20689 if (SWIG_arg_fail(1)) SWIG_fail;
20690 }
20691 if (obj1) {
20692 {
20693 arg2 = static_cast<int >(SWIG_As_int(obj1));
20694 if (SWIG_arg_fail(2)) SWIG_fail;
20695 }
20696 }
20697 if (obj2) {
20698 {
20699 arg3 = static_cast<int >(SWIG_As_int(obj2));
20700 if (SWIG_arg_fail(3)) SWIG_fail;
20701 }
20702 }
20703 if (obj3) {
20704 {
20705 arg4 = static_cast<int >(SWIG_As_int(obj3));
20706 if (SWIG_arg_fail(4)) SWIG_fail;
20707 }
20708 }
20709 {
20710 PyThreadState* __tstate = wxPyBeginAllowThreads();
20711 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
20712
20713 wxPyEndAllowThreads(__tstate);
20714 if (PyErr_Occurred()) SWIG_fail;
20715 }
20716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20717 return resultobj;
20718 fail:
20719 return NULL;
20720 }
20721
20722
20723 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
20724 PyObject *resultobj = NULL;
20725 int arg1 ;
20726 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20727 int arg3 = (int) wxDateTime::Inv_Year ;
20728 int arg4 = (int) 0 ;
20729 int arg5 = (int) 0 ;
20730 int arg6 = (int) 0 ;
20731 int arg7 = (int) 0 ;
20732 wxDateTime *result;
20733 PyObject * obj0 = 0 ;
20734 PyObject * obj1 = 0 ;
20735 PyObject * obj2 = 0 ;
20736 PyObject * obj3 = 0 ;
20737 PyObject * obj4 = 0 ;
20738 PyObject * obj5 = 0 ;
20739 PyObject * obj6 = 0 ;
20740 char *kwnames[] = {
20741 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20742 };
20743
20744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
20745 {
20746 arg1 = static_cast<int >(SWIG_As_int(obj0));
20747 if (SWIG_arg_fail(1)) SWIG_fail;
20748 }
20749 if (obj1) {
20750 {
20751 arg2 = static_cast<wxDateTime::Month >(SWIG_As_int(obj1));
20752 if (SWIG_arg_fail(2)) SWIG_fail;
20753 }
20754 }
20755 if (obj2) {
20756 {
20757 arg3 = static_cast<int >(SWIG_As_int(obj2));
20758 if (SWIG_arg_fail(3)) SWIG_fail;
20759 }
20760 }
20761 if (obj3) {
20762 {
20763 arg4 = static_cast<int >(SWIG_As_int(obj3));
20764 if (SWIG_arg_fail(4)) SWIG_fail;
20765 }
20766 }
20767 if (obj4) {
20768 {
20769 arg5 = static_cast<int >(SWIG_As_int(obj4));
20770 if (SWIG_arg_fail(5)) SWIG_fail;
20771 }
20772 }
20773 if (obj5) {
20774 {
20775 arg6 = static_cast<int >(SWIG_As_int(obj5));
20776 if (SWIG_arg_fail(6)) SWIG_fail;
20777 }
20778 }
20779 if (obj6) {
20780 {
20781 arg7 = static_cast<int >(SWIG_As_int(obj6));
20782 if (SWIG_arg_fail(7)) SWIG_fail;
20783 }
20784 }
20785 {
20786 PyThreadState* __tstate = wxPyBeginAllowThreads();
20787 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
20788
20789 wxPyEndAllowThreads(__tstate);
20790 if (PyErr_Occurred()) SWIG_fail;
20791 }
20792 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20793 return resultobj;
20794 fail:
20795 return NULL;
20796 }
20797
20798
20799 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20800 PyObject *resultobj = NULL;
20801 wxDateTime *arg1 = (wxDateTime *) 0 ;
20802 PyObject * obj0 = 0 ;
20803 char *kwnames[] = {
20804 (char *) "self", NULL
20805 };
20806
20807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
20808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20809 if (SWIG_arg_fail(1)) SWIG_fail;
20810 {
20811 PyThreadState* __tstate = wxPyBeginAllowThreads();
20812 delete arg1;
20813
20814 wxPyEndAllowThreads(__tstate);
20815 if (PyErr_Occurred()) SWIG_fail;
20816 }
20817 Py_INCREF(Py_None); resultobj = Py_None;
20818 return resultobj;
20819 fail:
20820 return NULL;
20821 }
20822
20823
20824 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
20825 PyObject *resultobj = NULL;
20826 wxDateTime *arg1 = (wxDateTime *) 0 ;
20827 wxDateTime *result;
20828 PyObject * obj0 = 0 ;
20829 char *kwnames[] = {
20830 (char *) "self", NULL
20831 };
20832
20833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
20834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20835 if (SWIG_arg_fail(1)) SWIG_fail;
20836 {
20837 PyThreadState* __tstate = wxPyBeginAllowThreads();
20838 {
20839 wxDateTime &_result_ref = (arg1)->SetToCurrent();
20840 result = (wxDateTime *) &_result_ref;
20841 }
20842
20843 wxPyEndAllowThreads(__tstate);
20844 if (PyErr_Occurred()) SWIG_fail;
20845 }
20846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20847 return resultobj;
20848 fail:
20849 return NULL;
20850 }
20851
20852
20853 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
20854 PyObject *resultobj = NULL;
20855 wxDateTime *arg1 = (wxDateTime *) 0 ;
20856 time_t arg2 ;
20857 wxDateTime *result;
20858 PyObject * obj0 = 0 ;
20859 PyObject * obj1 = 0 ;
20860 char *kwnames[] = {
20861 (char *) "self",(char *) "timet", NULL
20862 };
20863
20864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
20865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20866 if (SWIG_arg_fail(1)) SWIG_fail;
20867 {
20868 arg2 = static_cast<time_t >(SWIG_As_unsigned_SS_int(obj1));
20869 if (SWIG_arg_fail(2)) SWIG_fail;
20870 }
20871 {
20872 PyThreadState* __tstate = wxPyBeginAllowThreads();
20873 {
20874 wxDateTime &_result_ref = (arg1)->Set(arg2);
20875 result = (wxDateTime *) &_result_ref;
20876 }
20877
20878 wxPyEndAllowThreads(__tstate);
20879 if (PyErr_Occurred()) SWIG_fail;
20880 }
20881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20882 return resultobj;
20883 fail:
20884 return NULL;
20885 }
20886
20887
20888 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20889 PyObject *resultobj = NULL;
20890 wxDateTime *arg1 = (wxDateTime *) 0 ;
20891 double arg2 ;
20892 wxDateTime *result;
20893 PyObject * obj0 = 0 ;
20894 PyObject * obj1 = 0 ;
20895 char *kwnames[] = {
20896 (char *) "self",(char *) "jdn", NULL
20897 };
20898
20899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
20900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20901 if (SWIG_arg_fail(1)) SWIG_fail;
20902 {
20903 arg2 = static_cast<double >(SWIG_As_double(obj1));
20904 if (SWIG_arg_fail(2)) SWIG_fail;
20905 }
20906 {
20907 PyThreadState* __tstate = wxPyBeginAllowThreads();
20908 {
20909 wxDateTime &_result_ref = (arg1)->Set(arg2);
20910 result = (wxDateTime *) &_result_ref;
20911 }
20912
20913 wxPyEndAllowThreads(__tstate);
20914 if (PyErr_Occurred()) SWIG_fail;
20915 }
20916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20917 return resultobj;
20918 fail:
20919 return NULL;
20920 }
20921
20922
20923 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20924 PyObject *resultobj = NULL;
20925 wxDateTime *arg1 = (wxDateTime *) 0 ;
20926 int arg2 ;
20927 int arg3 = (int) 0 ;
20928 int arg4 = (int) 0 ;
20929 int arg5 = (int) 0 ;
20930 wxDateTime *result;
20931 PyObject * obj0 = 0 ;
20932 PyObject * obj1 = 0 ;
20933 PyObject * obj2 = 0 ;
20934 PyObject * obj3 = 0 ;
20935 PyObject * obj4 = 0 ;
20936 char *kwnames[] = {
20937 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20938 };
20939
20940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20942 if (SWIG_arg_fail(1)) SWIG_fail;
20943 {
20944 arg2 = static_cast<int >(SWIG_As_int(obj1));
20945 if (SWIG_arg_fail(2)) SWIG_fail;
20946 }
20947 if (obj2) {
20948 {
20949 arg3 = static_cast<int >(SWIG_As_int(obj2));
20950 if (SWIG_arg_fail(3)) SWIG_fail;
20951 }
20952 }
20953 if (obj3) {
20954 {
20955 arg4 = static_cast<int >(SWIG_As_int(obj3));
20956 if (SWIG_arg_fail(4)) SWIG_fail;
20957 }
20958 }
20959 if (obj4) {
20960 {
20961 arg5 = static_cast<int >(SWIG_As_int(obj4));
20962 if (SWIG_arg_fail(5)) SWIG_fail;
20963 }
20964 }
20965 {
20966 PyThreadState* __tstate = wxPyBeginAllowThreads();
20967 {
20968 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20969 result = (wxDateTime *) &_result_ref;
20970 }
20971
20972 wxPyEndAllowThreads(__tstate);
20973 if (PyErr_Occurred()) SWIG_fail;
20974 }
20975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20976 return resultobj;
20977 fail:
20978 return NULL;
20979 }
20980
20981
20982 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20983 PyObject *resultobj = NULL;
20984 wxDateTime *arg1 = (wxDateTime *) 0 ;
20985 int arg2 ;
20986 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20987 int arg4 = (int) wxDateTime::Inv_Year ;
20988 int arg5 = (int) 0 ;
20989 int arg6 = (int) 0 ;
20990 int arg7 = (int) 0 ;
20991 int arg8 = (int) 0 ;
20992 wxDateTime *result;
20993 PyObject * obj0 = 0 ;
20994 PyObject * obj1 = 0 ;
20995 PyObject * obj2 = 0 ;
20996 PyObject * obj3 = 0 ;
20997 PyObject * obj4 = 0 ;
20998 PyObject * obj5 = 0 ;
20999 PyObject * obj6 = 0 ;
21000 PyObject * obj7 = 0 ;
21001 char *kwnames[] = {
21002 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
21003 };
21004
21005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
21006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21007 if (SWIG_arg_fail(1)) SWIG_fail;
21008 {
21009 arg2 = static_cast<int >(SWIG_As_int(obj1));
21010 if (SWIG_arg_fail(2)) SWIG_fail;
21011 }
21012 if (obj2) {
21013 {
21014 arg3 = static_cast<wxDateTime::Month >(SWIG_As_int(obj2));
21015 if (SWIG_arg_fail(3)) SWIG_fail;
21016 }
21017 }
21018 if (obj3) {
21019 {
21020 arg4 = static_cast<int >(SWIG_As_int(obj3));
21021 if (SWIG_arg_fail(4)) SWIG_fail;
21022 }
21023 }
21024 if (obj4) {
21025 {
21026 arg5 = static_cast<int >(SWIG_As_int(obj4));
21027 if (SWIG_arg_fail(5)) SWIG_fail;
21028 }
21029 }
21030 if (obj5) {
21031 {
21032 arg6 = static_cast<int >(SWIG_As_int(obj5));
21033 if (SWIG_arg_fail(6)) SWIG_fail;
21034 }
21035 }
21036 if (obj6) {
21037 {
21038 arg7 = static_cast<int >(SWIG_As_int(obj6));
21039 if (SWIG_arg_fail(7)) SWIG_fail;
21040 }
21041 }
21042 if (obj7) {
21043 {
21044 arg8 = static_cast<int >(SWIG_As_int(obj7));
21045 if (SWIG_arg_fail(8)) SWIG_fail;
21046 }
21047 }
21048 {
21049 PyThreadState* __tstate = wxPyBeginAllowThreads();
21050 {
21051 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21052 result = (wxDateTime *) &_result_ref;
21053 }
21054
21055 wxPyEndAllowThreads(__tstate);
21056 if (PyErr_Occurred()) SWIG_fail;
21057 }
21058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21059 return resultobj;
21060 fail:
21061 return NULL;
21062 }
21063
21064
21065 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
21066 PyObject *resultobj = NULL;
21067 wxDateTime *arg1 = (wxDateTime *) 0 ;
21068 wxDateTime *result;
21069 PyObject * obj0 = 0 ;
21070 char *kwnames[] = {
21071 (char *) "self", NULL
21072 };
21073
21074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
21075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21076 if (SWIG_arg_fail(1)) SWIG_fail;
21077 {
21078 PyThreadState* __tstate = wxPyBeginAllowThreads();
21079 {
21080 wxDateTime &_result_ref = (arg1)->ResetTime();
21081 result = (wxDateTime *) &_result_ref;
21082 }
21083
21084 wxPyEndAllowThreads(__tstate);
21085 if (PyErr_Occurred()) SWIG_fail;
21086 }
21087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21088 return resultobj;
21089 fail:
21090 return NULL;
21091 }
21092
21093
21094 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21095 PyObject *resultobj = NULL;
21096 wxDateTime *arg1 = (wxDateTime *) 0 ;
21097 int arg2 ;
21098 wxDateTime *result;
21099 PyObject * obj0 = 0 ;
21100 PyObject * obj1 = 0 ;
21101 char *kwnames[] = {
21102 (char *) "self",(char *) "year", NULL
21103 };
21104
21105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
21106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21107 if (SWIG_arg_fail(1)) SWIG_fail;
21108 {
21109 arg2 = static_cast<int >(SWIG_As_int(obj1));
21110 if (SWIG_arg_fail(2)) SWIG_fail;
21111 }
21112 {
21113 PyThreadState* __tstate = wxPyBeginAllowThreads();
21114 {
21115 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
21116 result = (wxDateTime *) &_result_ref;
21117 }
21118
21119 wxPyEndAllowThreads(__tstate);
21120 if (PyErr_Occurred()) SWIG_fail;
21121 }
21122 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21123 return resultobj;
21124 fail:
21125 return NULL;
21126 }
21127
21128
21129 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21130 PyObject *resultobj = NULL;
21131 wxDateTime *arg1 = (wxDateTime *) 0 ;
21132 wxDateTime::Month arg2 ;
21133 wxDateTime *result;
21134 PyObject * obj0 = 0 ;
21135 PyObject * obj1 = 0 ;
21136 char *kwnames[] = {
21137 (char *) "self",(char *) "month", NULL
21138 };
21139
21140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
21141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21142 if (SWIG_arg_fail(1)) SWIG_fail;
21143 {
21144 arg2 = static_cast<wxDateTime::Month >(SWIG_As_int(obj1));
21145 if (SWIG_arg_fail(2)) SWIG_fail;
21146 }
21147 {
21148 PyThreadState* __tstate = wxPyBeginAllowThreads();
21149 {
21150 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
21151 result = (wxDateTime *) &_result_ref;
21152 }
21153
21154 wxPyEndAllowThreads(__tstate);
21155 if (PyErr_Occurred()) SWIG_fail;
21156 }
21157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21158 return resultobj;
21159 fail:
21160 return NULL;
21161 }
21162
21163
21164 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21165 PyObject *resultobj = NULL;
21166 wxDateTime *arg1 = (wxDateTime *) 0 ;
21167 int arg2 ;
21168 wxDateTime *result;
21169 PyObject * obj0 = 0 ;
21170 PyObject * obj1 = 0 ;
21171 char *kwnames[] = {
21172 (char *) "self",(char *) "day", NULL
21173 };
21174
21175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
21176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21177 if (SWIG_arg_fail(1)) SWIG_fail;
21178 {
21179 arg2 = static_cast<int >(SWIG_As_int(obj1));
21180 if (SWIG_arg_fail(2)) SWIG_fail;
21181 }
21182 {
21183 PyThreadState* __tstate = wxPyBeginAllowThreads();
21184 {
21185 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
21186 result = (wxDateTime *) &_result_ref;
21187 }
21188
21189 wxPyEndAllowThreads(__tstate);
21190 if (PyErr_Occurred()) SWIG_fail;
21191 }
21192 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21193 return resultobj;
21194 fail:
21195 return NULL;
21196 }
21197
21198
21199 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21200 PyObject *resultobj = NULL;
21201 wxDateTime *arg1 = (wxDateTime *) 0 ;
21202 int arg2 ;
21203 wxDateTime *result;
21204 PyObject * obj0 = 0 ;
21205 PyObject * obj1 = 0 ;
21206 char *kwnames[] = {
21207 (char *) "self",(char *) "hour", NULL
21208 };
21209
21210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
21211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21212 if (SWIG_arg_fail(1)) SWIG_fail;
21213 {
21214 arg2 = static_cast<int >(SWIG_As_int(obj1));
21215 if (SWIG_arg_fail(2)) SWIG_fail;
21216 }
21217 {
21218 PyThreadState* __tstate = wxPyBeginAllowThreads();
21219 {
21220 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
21221 result = (wxDateTime *) &_result_ref;
21222 }
21223
21224 wxPyEndAllowThreads(__tstate);
21225 if (PyErr_Occurred()) SWIG_fail;
21226 }
21227 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21228 return resultobj;
21229 fail:
21230 return NULL;
21231 }
21232
21233
21234 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21235 PyObject *resultobj = NULL;
21236 wxDateTime *arg1 = (wxDateTime *) 0 ;
21237 int arg2 ;
21238 wxDateTime *result;
21239 PyObject * obj0 = 0 ;
21240 PyObject * obj1 = 0 ;
21241 char *kwnames[] = {
21242 (char *) "self",(char *) "minute", NULL
21243 };
21244
21245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
21246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21247 if (SWIG_arg_fail(1)) SWIG_fail;
21248 {
21249 arg2 = static_cast<int >(SWIG_As_int(obj1));
21250 if (SWIG_arg_fail(2)) SWIG_fail;
21251 }
21252 {
21253 PyThreadState* __tstate = wxPyBeginAllowThreads();
21254 {
21255 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
21256 result = (wxDateTime *) &_result_ref;
21257 }
21258
21259 wxPyEndAllowThreads(__tstate);
21260 if (PyErr_Occurred()) SWIG_fail;
21261 }
21262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21263 return resultobj;
21264 fail:
21265 return NULL;
21266 }
21267
21268
21269 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21270 PyObject *resultobj = NULL;
21271 wxDateTime *arg1 = (wxDateTime *) 0 ;
21272 int arg2 ;
21273 wxDateTime *result;
21274 PyObject * obj0 = 0 ;
21275 PyObject * obj1 = 0 ;
21276 char *kwnames[] = {
21277 (char *) "self",(char *) "second", NULL
21278 };
21279
21280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
21281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21282 if (SWIG_arg_fail(1)) SWIG_fail;
21283 {
21284 arg2 = static_cast<int >(SWIG_As_int(obj1));
21285 if (SWIG_arg_fail(2)) SWIG_fail;
21286 }
21287 {
21288 PyThreadState* __tstate = wxPyBeginAllowThreads();
21289 {
21290 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
21291 result = (wxDateTime *) &_result_ref;
21292 }
21293
21294 wxPyEndAllowThreads(__tstate);
21295 if (PyErr_Occurred()) SWIG_fail;
21296 }
21297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21298 return resultobj;
21299 fail:
21300 return NULL;
21301 }
21302
21303
21304 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21305 PyObject *resultobj = NULL;
21306 wxDateTime *arg1 = (wxDateTime *) 0 ;
21307 int arg2 ;
21308 wxDateTime *result;
21309 PyObject * obj0 = 0 ;
21310 PyObject * obj1 = 0 ;
21311 char *kwnames[] = {
21312 (char *) "self",(char *) "millisecond", NULL
21313 };
21314
21315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21317 if (SWIG_arg_fail(1)) SWIG_fail;
21318 {
21319 arg2 = static_cast<int >(SWIG_As_int(obj1));
21320 if (SWIG_arg_fail(2)) SWIG_fail;
21321 }
21322 {
21323 PyThreadState* __tstate = wxPyBeginAllowThreads();
21324 {
21325 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
21326 result = (wxDateTime *) &_result_ref;
21327 }
21328
21329 wxPyEndAllowThreads(__tstate);
21330 if (PyErr_Occurred()) SWIG_fail;
21331 }
21332 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21333 return resultobj;
21334 fail:
21335 return NULL;
21336 }
21337
21338
21339 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21340 PyObject *resultobj = NULL;
21341 wxDateTime *arg1 = (wxDateTime *) 0 ;
21342 wxDateTime::WeekDay arg2 ;
21343 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21344 wxDateTime *result;
21345 PyObject * obj0 = 0 ;
21346 PyObject * obj1 = 0 ;
21347 PyObject * obj2 = 0 ;
21348 char *kwnames[] = {
21349 (char *) "self",(char *) "weekday",(char *) "flags", NULL
21350 };
21351
21352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
21353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21354 if (SWIG_arg_fail(1)) SWIG_fail;
21355 {
21356 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21357 if (SWIG_arg_fail(2)) SWIG_fail;
21358 }
21359 if (obj2) {
21360 {
21361 arg3 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj2));
21362 if (SWIG_arg_fail(3)) SWIG_fail;
21363 }
21364 }
21365 {
21366 PyThreadState* __tstate = wxPyBeginAllowThreads();
21367 {
21368 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
21369 result = (wxDateTime *) &_result_ref;
21370 }
21371
21372 wxPyEndAllowThreads(__tstate);
21373 if (PyErr_Occurred()) SWIG_fail;
21374 }
21375 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21376 return resultobj;
21377 fail:
21378 return NULL;
21379 }
21380
21381
21382 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21383 PyObject *resultobj = NULL;
21384 wxDateTime *arg1 = (wxDateTime *) 0 ;
21385 wxDateTime::WeekDay arg2 ;
21386 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21387 wxDateTime result;
21388 PyObject * obj0 = 0 ;
21389 PyObject * obj1 = 0 ;
21390 PyObject * obj2 = 0 ;
21391 char *kwnames[] = {
21392 (char *) "self",(char *) "weekday",(char *) "flags", NULL
21393 };
21394
21395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
21396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21397 if (SWIG_arg_fail(1)) SWIG_fail;
21398 {
21399 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21400 if (SWIG_arg_fail(2)) SWIG_fail;
21401 }
21402 if (obj2) {
21403 {
21404 arg3 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj2));
21405 if (SWIG_arg_fail(3)) SWIG_fail;
21406 }
21407 }
21408 {
21409 PyThreadState* __tstate = wxPyBeginAllowThreads();
21410 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
21411
21412 wxPyEndAllowThreads(__tstate);
21413 if (PyErr_Occurred()) SWIG_fail;
21414 }
21415 {
21416 wxDateTime * resultptr;
21417 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21418 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21419 }
21420 return resultobj;
21421 fail:
21422 return NULL;
21423 }
21424
21425
21426 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21427 PyObject *resultobj = NULL;
21428 wxDateTime *arg1 = (wxDateTime *) 0 ;
21429 wxDateTime::WeekDay arg2 ;
21430 wxDateTime *result;
21431 PyObject * obj0 = 0 ;
21432 PyObject * obj1 = 0 ;
21433 char *kwnames[] = {
21434 (char *) "self",(char *) "weekday", NULL
21435 };
21436
21437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
21438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21439 if (SWIG_arg_fail(1)) SWIG_fail;
21440 {
21441 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21442 if (SWIG_arg_fail(2)) SWIG_fail;
21443 }
21444 {
21445 PyThreadState* __tstate = wxPyBeginAllowThreads();
21446 {
21447 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
21448 result = (wxDateTime *) &_result_ref;
21449 }
21450
21451 wxPyEndAllowThreads(__tstate);
21452 if (PyErr_Occurred()) SWIG_fail;
21453 }
21454 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21455 return resultobj;
21456 fail:
21457 return NULL;
21458 }
21459
21460
21461 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21462 PyObject *resultobj = NULL;
21463 wxDateTime *arg1 = (wxDateTime *) 0 ;
21464 wxDateTime::WeekDay arg2 ;
21465 wxDateTime result;
21466 PyObject * obj0 = 0 ;
21467 PyObject * obj1 = 0 ;
21468 char *kwnames[] = {
21469 (char *) "self",(char *) "weekday", NULL
21470 };
21471
21472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
21473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21474 if (SWIG_arg_fail(1)) SWIG_fail;
21475 {
21476 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21477 if (SWIG_arg_fail(2)) SWIG_fail;
21478 }
21479 {
21480 PyThreadState* __tstate = wxPyBeginAllowThreads();
21481 result = (arg1)->GetNextWeekDay(arg2);
21482
21483 wxPyEndAllowThreads(__tstate);
21484 if (PyErr_Occurred()) SWIG_fail;
21485 }
21486 {
21487 wxDateTime * resultptr;
21488 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21489 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21490 }
21491 return resultobj;
21492 fail:
21493 return NULL;
21494 }
21495
21496
21497 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21498 PyObject *resultobj = NULL;
21499 wxDateTime *arg1 = (wxDateTime *) 0 ;
21500 wxDateTime::WeekDay arg2 ;
21501 wxDateTime *result;
21502 PyObject * obj0 = 0 ;
21503 PyObject * obj1 = 0 ;
21504 char *kwnames[] = {
21505 (char *) "self",(char *) "weekday", NULL
21506 };
21507
21508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
21509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21510 if (SWIG_arg_fail(1)) SWIG_fail;
21511 {
21512 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21513 if (SWIG_arg_fail(2)) SWIG_fail;
21514 }
21515 {
21516 PyThreadState* __tstate = wxPyBeginAllowThreads();
21517 {
21518 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
21519 result = (wxDateTime *) &_result_ref;
21520 }
21521
21522 wxPyEndAllowThreads(__tstate);
21523 if (PyErr_Occurred()) SWIG_fail;
21524 }
21525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21526 return resultobj;
21527 fail:
21528 return NULL;
21529 }
21530
21531
21532 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21533 PyObject *resultobj = NULL;
21534 wxDateTime *arg1 = (wxDateTime *) 0 ;
21535 wxDateTime::WeekDay arg2 ;
21536 wxDateTime result;
21537 PyObject * obj0 = 0 ;
21538 PyObject * obj1 = 0 ;
21539 char *kwnames[] = {
21540 (char *) "self",(char *) "weekday", NULL
21541 };
21542
21543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
21544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21545 if (SWIG_arg_fail(1)) SWIG_fail;
21546 {
21547 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21548 if (SWIG_arg_fail(2)) SWIG_fail;
21549 }
21550 {
21551 PyThreadState* __tstate = wxPyBeginAllowThreads();
21552 result = (arg1)->GetPrevWeekDay(arg2);
21553
21554 wxPyEndAllowThreads(__tstate);
21555 if (PyErr_Occurred()) SWIG_fail;
21556 }
21557 {
21558 wxDateTime * resultptr;
21559 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21560 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21561 }
21562 return resultobj;
21563 fail:
21564 return NULL;
21565 }
21566
21567
21568 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21569 PyObject *resultobj = NULL;
21570 wxDateTime *arg1 = (wxDateTime *) 0 ;
21571 wxDateTime::WeekDay arg2 ;
21572 int arg3 = (int) 1 ;
21573 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21574 int arg5 = (int) wxDateTime::Inv_Year ;
21575 bool result;
21576 PyObject * obj0 = 0 ;
21577 PyObject * obj1 = 0 ;
21578 PyObject * obj2 = 0 ;
21579 PyObject * obj3 = 0 ;
21580 PyObject * obj4 = 0 ;
21581 char *kwnames[] = {
21582 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
21583 };
21584
21585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21587 if (SWIG_arg_fail(1)) SWIG_fail;
21588 {
21589 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21590 if (SWIG_arg_fail(2)) SWIG_fail;
21591 }
21592 if (obj2) {
21593 {
21594 arg3 = static_cast<int >(SWIG_As_int(obj2));
21595 if (SWIG_arg_fail(3)) SWIG_fail;
21596 }
21597 }
21598 if (obj3) {
21599 {
21600 arg4 = static_cast<wxDateTime::Month >(SWIG_As_int(obj3));
21601 if (SWIG_arg_fail(4)) SWIG_fail;
21602 }
21603 }
21604 if (obj4) {
21605 {
21606 arg5 = static_cast<int >(SWIG_As_int(obj4));
21607 if (SWIG_arg_fail(5)) SWIG_fail;
21608 }
21609 }
21610 {
21611 PyThreadState* __tstate = wxPyBeginAllowThreads();
21612 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
21613
21614 wxPyEndAllowThreads(__tstate);
21615 if (PyErr_Occurred()) SWIG_fail;
21616 }
21617 {
21618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21619 }
21620 return resultobj;
21621 fail:
21622 return NULL;
21623 }
21624
21625
21626 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21627 PyObject *resultobj = NULL;
21628 wxDateTime *arg1 = (wxDateTime *) 0 ;
21629 wxDateTime::WeekDay arg2 ;
21630 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21631 int arg4 = (int) wxDateTime::Inv_Year ;
21632 bool result;
21633 PyObject * obj0 = 0 ;
21634 PyObject * obj1 = 0 ;
21635 PyObject * obj2 = 0 ;
21636 PyObject * obj3 = 0 ;
21637 char *kwnames[] = {
21638 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
21639 };
21640
21641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21643 if (SWIG_arg_fail(1)) SWIG_fail;
21644 {
21645 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21646 if (SWIG_arg_fail(2)) SWIG_fail;
21647 }
21648 if (obj2) {
21649 {
21650 arg3 = static_cast<wxDateTime::Month >(SWIG_As_int(obj2));
21651 if (SWIG_arg_fail(3)) SWIG_fail;
21652 }
21653 }
21654 if (obj3) {
21655 {
21656 arg4 = static_cast<int >(SWIG_As_int(obj3));
21657 if (SWIG_arg_fail(4)) SWIG_fail;
21658 }
21659 }
21660 {
21661 PyThreadState* __tstate = wxPyBeginAllowThreads();
21662 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
21663
21664 wxPyEndAllowThreads(__tstate);
21665 if (PyErr_Occurred()) SWIG_fail;
21666 }
21667 {
21668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21669 }
21670 return resultobj;
21671 fail:
21672 return NULL;
21673 }
21674
21675
21676 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21677 PyObject *resultobj = NULL;
21678 wxDateTime *arg1 = (wxDateTime *) 0 ;
21679 wxDateTime::WeekDay arg2 ;
21680 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21681 int arg4 = (int) wxDateTime::Inv_Year ;
21682 wxDateTime result;
21683 PyObject * obj0 = 0 ;
21684 PyObject * obj1 = 0 ;
21685 PyObject * obj2 = 0 ;
21686 PyObject * obj3 = 0 ;
21687 char *kwnames[] = {
21688 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
21689 };
21690
21691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21693 if (SWIG_arg_fail(1)) SWIG_fail;
21694 {
21695 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21696 if (SWIG_arg_fail(2)) SWIG_fail;
21697 }
21698 if (obj2) {
21699 {
21700 arg3 = static_cast<wxDateTime::Month >(SWIG_As_int(obj2));
21701 if (SWIG_arg_fail(3)) SWIG_fail;
21702 }
21703 }
21704 if (obj3) {
21705 {
21706 arg4 = static_cast<int >(SWIG_As_int(obj3));
21707 if (SWIG_arg_fail(4)) SWIG_fail;
21708 }
21709 }
21710 {
21711 PyThreadState* __tstate = wxPyBeginAllowThreads();
21712 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
21713
21714 wxPyEndAllowThreads(__tstate);
21715 if (PyErr_Occurred()) SWIG_fail;
21716 }
21717 {
21718 wxDateTime * resultptr;
21719 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21720 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21721 }
21722 return resultobj;
21723 fail:
21724 return NULL;
21725 }
21726
21727
21728 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21729 PyObject *resultobj = NULL;
21730 wxDateTime *arg1 = (wxDateTime *) 0 ;
21731 int arg2 ;
21732 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21733 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21734 bool result;
21735 PyObject * obj0 = 0 ;
21736 PyObject * obj1 = 0 ;
21737 PyObject * obj2 = 0 ;
21738 PyObject * obj3 = 0 ;
21739 char *kwnames[] = {
21740 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
21741 };
21742
21743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21745 if (SWIG_arg_fail(1)) SWIG_fail;
21746 {
21747 arg2 = static_cast<int >(SWIG_As_int(obj1));
21748 if (SWIG_arg_fail(2)) SWIG_fail;
21749 }
21750 if (obj2) {
21751 {
21752 arg3 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj2));
21753 if (SWIG_arg_fail(3)) SWIG_fail;
21754 }
21755 }
21756 if (obj3) {
21757 {
21758 arg4 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj3));
21759 if (SWIG_arg_fail(4)) SWIG_fail;
21760 }
21761 }
21762 {
21763 PyThreadState* __tstate = wxPyBeginAllowThreads();
21764 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
21765
21766 wxPyEndAllowThreads(__tstate);
21767 if (PyErr_Occurred()) SWIG_fail;
21768 }
21769 {
21770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21771 }
21772 return resultobj;
21773 fail:
21774 return NULL;
21775 }
21776
21777
21778 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21779 PyObject *resultobj = NULL;
21780 wxDateTime *arg1 = (wxDateTime *) 0 ;
21781 int arg2 ;
21782 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21783 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21784 wxDateTime result;
21785 PyObject * obj0 = 0 ;
21786 PyObject * obj1 = 0 ;
21787 PyObject * obj2 = 0 ;
21788 PyObject * obj3 = 0 ;
21789 char *kwnames[] = {
21790 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
21791 };
21792
21793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21795 if (SWIG_arg_fail(1)) SWIG_fail;
21796 {
21797 arg2 = static_cast<int >(SWIG_As_int(obj1));
21798 if (SWIG_arg_fail(2)) SWIG_fail;
21799 }
21800 if (obj2) {
21801 {
21802 arg3 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj2));
21803 if (SWIG_arg_fail(3)) SWIG_fail;
21804 }
21805 }
21806 if (obj3) {
21807 {
21808 arg4 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj3));
21809 if (SWIG_arg_fail(4)) SWIG_fail;
21810 }
21811 }
21812 {
21813 PyThreadState* __tstate = wxPyBeginAllowThreads();
21814 result = (arg1)->GetWeek(arg2,arg3,arg4);
21815
21816 wxPyEndAllowThreads(__tstate);
21817 if (PyErr_Occurred()) SWIG_fail;
21818 }
21819 {
21820 wxDateTime * resultptr;
21821 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21822 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21823 }
21824 return resultobj;
21825 fail:
21826 return NULL;
21827 }
21828
21829
21830 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21831 PyObject *resultobj = NULL;
21832 int arg1 ;
21833 int arg2 ;
21834 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21835 wxDateTime result;
21836 PyObject * obj0 = 0 ;
21837 PyObject * obj1 = 0 ;
21838 PyObject * obj2 = 0 ;
21839 char *kwnames[] = {
21840 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
21841 };
21842
21843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21844 {
21845 arg1 = static_cast<int >(SWIG_As_int(obj0));
21846 if (SWIG_arg_fail(1)) SWIG_fail;
21847 }
21848 {
21849 arg2 = static_cast<int >(SWIG_As_int(obj1));
21850 if (SWIG_arg_fail(2)) SWIG_fail;
21851 }
21852 if (obj2) {
21853 {
21854 arg3 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj2));
21855 if (SWIG_arg_fail(3)) SWIG_fail;
21856 }
21857 }
21858 {
21859 PyThreadState* __tstate = wxPyBeginAllowThreads();
21860 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
21861
21862 wxPyEndAllowThreads(__tstate);
21863 if (PyErr_Occurred()) SWIG_fail;
21864 }
21865 {
21866 wxDateTime * resultptr;
21867 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21868 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21869 }
21870 return resultobj;
21871 fail:
21872 return NULL;
21873 }
21874
21875
21876 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21877 PyObject *resultobj = NULL;
21878 wxDateTime *arg1 = (wxDateTime *) 0 ;
21879 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21880 int arg3 = (int) wxDateTime::Inv_Year ;
21881 wxDateTime *result;
21882 PyObject * obj0 = 0 ;
21883 PyObject * obj1 = 0 ;
21884 PyObject * obj2 = 0 ;
21885 char *kwnames[] = {
21886 (char *) "self",(char *) "month",(char *) "year", NULL
21887 };
21888
21889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21891 if (SWIG_arg_fail(1)) SWIG_fail;
21892 if (obj1) {
21893 {
21894 arg2 = static_cast<wxDateTime::Month >(SWIG_As_int(obj1));
21895 if (SWIG_arg_fail(2)) SWIG_fail;
21896 }
21897 }
21898 if (obj2) {
21899 {
21900 arg3 = static_cast<int >(SWIG_As_int(obj2));
21901 if (SWIG_arg_fail(3)) SWIG_fail;
21902 }
21903 }
21904 {
21905 PyThreadState* __tstate = wxPyBeginAllowThreads();
21906 {
21907 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
21908 result = (wxDateTime *) &_result_ref;
21909 }
21910
21911 wxPyEndAllowThreads(__tstate);
21912 if (PyErr_Occurred()) SWIG_fail;
21913 }
21914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21915 return resultobj;
21916 fail:
21917 return NULL;
21918 }
21919
21920
21921 static PyObject *_wrap_DateTime_GetLastMonthDay(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_GetLastMonthDay",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 result = (arg1)->GetLastMonthDay(arg2,arg3);
21952
21953 wxPyEndAllowThreads(__tstate);
21954 if (PyErr_Occurred()) SWIG_fail;
21955 }
21956 {
21957 wxDateTime * resultptr;
21958 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21959 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21960 }
21961 return resultobj;
21962 fail:
21963 return NULL;
21964 }
21965
21966
21967 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21968 PyObject *resultobj = NULL;
21969 wxDateTime *arg1 = (wxDateTime *) 0 ;
21970 int arg2 ;
21971 wxDateTime *result;
21972 PyObject * obj0 = 0 ;
21973 PyObject * obj1 = 0 ;
21974 char *kwnames[] = {
21975 (char *) "self",(char *) "yday", NULL
21976 };
21977
21978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21980 if (SWIG_arg_fail(1)) SWIG_fail;
21981 {
21982 arg2 = static_cast<int >(SWIG_As_int(obj1));
21983 if (SWIG_arg_fail(2)) SWIG_fail;
21984 }
21985 {
21986 PyThreadState* __tstate = wxPyBeginAllowThreads();
21987 {
21988 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21989 result = (wxDateTime *) &_result_ref;
21990 }
21991
21992 wxPyEndAllowThreads(__tstate);
21993 if (PyErr_Occurred()) SWIG_fail;
21994 }
21995 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21996 return resultobj;
21997 fail:
21998 return NULL;
21999 }
22000
22001
22002 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
22003 PyObject *resultobj = NULL;
22004 wxDateTime *arg1 = (wxDateTime *) 0 ;
22005 int arg2 ;
22006 wxDateTime result;
22007 PyObject * obj0 = 0 ;
22008 PyObject * obj1 = 0 ;
22009 char *kwnames[] = {
22010 (char *) "self",(char *) "yday", NULL
22011 };
22012
22013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
22014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22015 if (SWIG_arg_fail(1)) SWIG_fail;
22016 {
22017 arg2 = static_cast<int >(SWIG_As_int(obj1));
22018 if (SWIG_arg_fail(2)) SWIG_fail;
22019 }
22020 {
22021 PyThreadState* __tstate = wxPyBeginAllowThreads();
22022 result = (arg1)->GetYearDay(arg2);
22023
22024 wxPyEndAllowThreads(__tstate);
22025 if (PyErr_Occurred()) SWIG_fail;
22026 }
22027 {
22028 wxDateTime * resultptr;
22029 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22030 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22031 }
22032 return resultobj;
22033 fail:
22034 return NULL;
22035 }
22036
22037
22038 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
22039 PyObject *resultobj = NULL;
22040 wxDateTime *arg1 = (wxDateTime *) 0 ;
22041 double result;
22042 PyObject * obj0 = 0 ;
22043 char *kwnames[] = {
22044 (char *) "self", NULL
22045 };
22046
22047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
22048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22049 if (SWIG_arg_fail(1)) SWIG_fail;
22050 {
22051 PyThreadState* __tstate = wxPyBeginAllowThreads();
22052 result = (double)(arg1)->GetJulianDayNumber();
22053
22054 wxPyEndAllowThreads(__tstate);
22055 if (PyErr_Occurred()) SWIG_fail;
22056 }
22057 {
22058 resultobj = SWIG_From_double(static_cast<double >(result));
22059 }
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
22067 PyObject *resultobj = NULL;
22068 wxDateTime *arg1 = (wxDateTime *) 0 ;
22069 double result;
22070 PyObject * obj0 = 0 ;
22071 char *kwnames[] = {
22072 (char *) "self", NULL
22073 };
22074
22075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
22076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22077 if (SWIG_arg_fail(1)) SWIG_fail;
22078 {
22079 PyThreadState* __tstate = wxPyBeginAllowThreads();
22080 result = (double)(arg1)->GetJDN();
22081
22082 wxPyEndAllowThreads(__tstate);
22083 if (PyErr_Occurred()) SWIG_fail;
22084 }
22085 {
22086 resultobj = SWIG_From_double(static_cast<double >(result));
22087 }
22088 return resultobj;
22089 fail:
22090 return NULL;
22091 }
22092
22093
22094 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
22095 PyObject *resultobj = NULL;
22096 wxDateTime *arg1 = (wxDateTime *) 0 ;
22097 double result;
22098 PyObject * obj0 = 0 ;
22099 char *kwnames[] = {
22100 (char *) "self", NULL
22101 };
22102
22103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
22104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22105 if (SWIG_arg_fail(1)) SWIG_fail;
22106 {
22107 PyThreadState* __tstate = wxPyBeginAllowThreads();
22108 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
22109
22110 wxPyEndAllowThreads(__tstate);
22111 if (PyErr_Occurred()) SWIG_fail;
22112 }
22113 {
22114 resultobj = SWIG_From_double(static_cast<double >(result));
22115 }
22116 return resultobj;
22117 fail:
22118 return NULL;
22119 }
22120
22121
22122 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
22123 PyObject *resultobj = NULL;
22124 wxDateTime *arg1 = (wxDateTime *) 0 ;
22125 double result;
22126 PyObject * obj0 = 0 ;
22127 char *kwnames[] = {
22128 (char *) "self", NULL
22129 };
22130
22131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
22132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22133 if (SWIG_arg_fail(1)) SWIG_fail;
22134 {
22135 PyThreadState* __tstate = wxPyBeginAllowThreads();
22136 result = (double)(arg1)->GetMJD();
22137
22138 wxPyEndAllowThreads(__tstate);
22139 if (PyErr_Occurred()) SWIG_fail;
22140 }
22141 {
22142 resultobj = SWIG_From_double(static_cast<double >(result));
22143 }
22144 return resultobj;
22145 fail:
22146 return NULL;
22147 }
22148
22149
22150 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
22151 PyObject *resultobj = NULL;
22152 wxDateTime *arg1 = (wxDateTime *) 0 ;
22153 double result;
22154 PyObject * obj0 = 0 ;
22155 char *kwnames[] = {
22156 (char *) "self", NULL
22157 };
22158
22159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
22160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22161 if (SWIG_arg_fail(1)) SWIG_fail;
22162 {
22163 PyThreadState* __tstate = wxPyBeginAllowThreads();
22164 result = (double)(arg1)->GetRataDie();
22165
22166 wxPyEndAllowThreads(__tstate);
22167 if (PyErr_Occurred()) SWIG_fail;
22168 }
22169 {
22170 resultobj = SWIG_From_double(static_cast<double >(result));
22171 }
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
22179 PyObject *resultobj = NULL;
22180 wxDateTime *arg1 = (wxDateTime *) 0 ;
22181 wxDateTime::TimeZone *arg2 = 0 ;
22182 bool arg3 = (bool) false ;
22183 wxDateTime result;
22184 bool temp2 = false ;
22185 PyObject * obj0 = 0 ;
22186 PyObject * obj1 = 0 ;
22187 PyObject * obj2 = 0 ;
22188 char *kwnames[] = {
22189 (char *) "self",(char *) "tz",(char *) "noDST", NULL
22190 };
22191
22192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
22193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22194 if (SWIG_arg_fail(1)) SWIG_fail;
22195 {
22196 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22197 temp2 = true;
22198 }
22199 if (obj2) {
22200 {
22201 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
22202 if (SWIG_arg_fail(3)) SWIG_fail;
22203 }
22204 }
22205 {
22206 PyThreadState* __tstate = wxPyBeginAllowThreads();
22207 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
22208
22209 wxPyEndAllowThreads(__tstate);
22210 if (PyErr_Occurred()) SWIG_fail;
22211 }
22212 {
22213 wxDateTime * resultptr;
22214 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22215 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22216 }
22217 {
22218 if (temp2) delete arg2;
22219 }
22220 return resultobj;
22221 fail:
22222 {
22223 if (temp2) delete arg2;
22224 }
22225 return NULL;
22226 }
22227
22228
22229 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
22230 PyObject *resultobj = NULL;
22231 wxDateTime *arg1 = (wxDateTime *) 0 ;
22232 wxDateTime::TimeZone *arg2 = 0 ;
22233 bool arg3 = (bool) false ;
22234 wxDateTime *result;
22235 bool temp2 = false ;
22236 PyObject * obj0 = 0 ;
22237 PyObject * obj1 = 0 ;
22238 PyObject * obj2 = 0 ;
22239 char *kwnames[] = {
22240 (char *) "self",(char *) "tz",(char *) "noDST", NULL
22241 };
22242
22243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
22244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22245 if (SWIG_arg_fail(1)) SWIG_fail;
22246 {
22247 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22248 temp2 = true;
22249 }
22250 if (obj2) {
22251 {
22252 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
22253 if (SWIG_arg_fail(3)) SWIG_fail;
22254 }
22255 }
22256 {
22257 PyThreadState* __tstate = wxPyBeginAllowThreads();
22258 {
22259 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
22260 result = (wxDateTime *) &_result_ref;
22261 }
22262
22263 wxPyEndAllowThreads(__tstate);
22264 if (PyErr_Occurred()) SWIG_fail;
22265 }
22266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22267 {
22268 if (temp2) delete arg2;
22269 }
22270 return resultobj;
22271 fail:
22272 {
22273 if (temp2) delete arg2;
22274 }
22275 return NULL;
22276 }
22277
22278
22279 static PyObject *_wrap_DateTime_FromTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
22280 PyObject *resultobj = NULL;
22281 wxDateTime *arg1 = (wxDateTime *) 0 ;
22282 wxDateTime::TimeZone *arg2 = 0 ;
22283 bool arg3 = (bool) false ;
22284 wxDateTime result;
22285 bool temp2 = false ;
22286 PyObject * obj0 = 0 ;
22287 PyObject * obj1 = 0 ;
22288 PyObject * obj2 = 0 ;
22289 char *kwnames[] = {
22290 (char *) "self",(char *) "tz",(char *) "noDST", NULL
22291 };
22292
22293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
22294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22295 if (SWIG_arg_fail(1)) SWIG_fail;
22296 {
22297 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22298 temp2 = true;
22299 }
22300 if (obj2) {
22301 {
22302 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
22303 if (SWIG_arg_fail(3)) SWIG_fail;
22304 }
22305 }
22306 {
22307 PyThreadState* __tstate = wxPyBeginAllowThreads();
22308 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
22309
22310 wxPyEndAllowThreads(__tstate);
22311 if (PyErr_Occurred()) SWIG_fail;
22312 }
22313 {
22314 wxDateTime * resultptr;
22315 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22316 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22317 }
22318 {
22319 if (temp2) delete arg2;
22320 }
22321 return resultobj;
22322 fail:
22323 {
22324 if (temp2) delete arg2;
22325 }
22326 return NULL;
22327 }
22328
22329
22330 static PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
22331 PyObject *resultobj = NULL;
22332 wxDateTime *arg1 = (wxDateTime *) 0 ;
22333 wxDateTime::TimeZone *arg2 = 0 ;
22334 bool arg3 = (bool) false ;
22335 wxDateTime *result;
22336 bool temp2 = false ;
22337 PyObject * obj0 = 0 ;
22338 PyObject * obj1 = 0 ;
22339 PyObject * obj2 = 0 ;
22340 char *kwnames[] = {
22341 (char *) "self",(char *) "tz",(char *) "noDST", NULL
22342 };
22343
22344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
22345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22346 if (SWIG_arg_fail(1)) SWIG_fail;
22347 {
22348 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22349 temp2 = true;
22350 }
22351 if (obj2) {
22352 {
22353 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
22354 if (SWIG_arg_fail(3)) SWIG_fail;
22355 }
22356 }
22357 {
22358 PyThreadState* __tstate = wxPyBeginAllowThreads();
22359 {
22360 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
22361 result = (wxDateTime *) &_result_ref;
22362 }
22363
22364 wxPyEndAllowThreads(__tstate);
22365 if (PyErr_Occurred()) SWIG_fail;
22366 }
22367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22368 {
22369 if (temp2) delete arg2;
22370 }
22371 return resultobj;
22372 fail:
22373 {
22374 if (temp2) delete arg2;
22375 }
22376 return NULL;
22377 }
22378
22379
22380 static PyObject *_wrap_DateTime_ToUTC(PyObject *, PyObject *args, PyObject *kwargs) {
22381 PyObject *resultobj = NULL;
22382 wxDateTime *arg1 = (wxDateTime *) 0 ;
22383 bool arg2 = (bool) false ;
22384 wxDateTime result;
22385 PyObject * obj0 = 0 ;
22386 PyObject * obj1 = 0 ;
22387 char *kwnames[] = {
22388 (char *) "self",(char *) "noDST", NULL
22389 };
22390
22391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) goto fail;
22392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22393 if (SWIG_arg_fail(1)) SWIG_fail;
22394 if (obj1) {
22395 {
22396 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22397 if (SWIG_arg_fail(2)) SWIG_fail;
22398 }
22399 }
22400 {
22401 PyThreadState* __tstate = wxPyBeginAllowThreads();
22402 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
22403
22404 wxPyEndAllowThreads(__tstate);
22405 if (PyErr_Occurred()) SWIG_fail;
22406 }
22407 {
22408 wxDateTime * resultptr;
22409 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22411 }
22412 return resultobj;
22413 fail:
22414 return NULL;
22415 }
22416
22417
22418 static PyObject *_wrap_DateTime_MakeUTC(PyObject *, PyObject *args, PyObject *kwargs) {
22419 PyObject *resultobj = NULL;
22420 wxDateTime *arg1 = (wxDateTime *) 0 ;
22421 bool arg2 = (bool) false ;
22422 wxDateTime *result;
22423 PyObject * obj0 = 0 ;
22424 PyObject * obj1 = 0 ;
22425 char *kwnames[] = {
22426 (char *) "self",(char *) "noDST", NULL
22427 };
22428
22429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) goto fail;
22430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22431 if (SWIG_arg_fail(1)) SWIG_fail;
22432 if (obj1) {
22433 {
22434 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22435 if (SWIG_arg_fail(2)) SWIG_fail;
22436 }
22437 }
22438 {
22439 PyThreadState* __tstate = wxPyBeginAllowThreads();
22440 {
22441 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
22442 result = (wxDateTime *) &_result_ref;
22443 }
22444
22445 wxPyEndAllowThreads(__tstate);
22446 if (PyErr_Occurred()) SWIG_fail;
22447 }
22448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22449 return resultobj;
22450 fail:
22451 return NULL;
22452 }
22453
22454
22455 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
22456 PyObject *resultobj = NULL;
22457 wxDateTime *arg1 = (wxDateTime *) 0 ;
22458 bool arg2 = (bool) false ;
22459 wxDateTime result;
22460 PyObject * obj0 = 0 ;
22461 PyObject * obj1 = 0 ;
22462 char *kwnames[] = {
22463 (char *) "self",(char *) "noDST", NULL
22464 };
22465
22466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
22467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22468 if (SWIG_arg_fail(1)) SWIG_fail;
22469 if (obj1) {
22470 {
22471 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22472 if (SWIG_arg_fail(2)) SWIG_fail;
22473 }
22474 }
22475 {
22476 PyThreadState* __tstate = wxPyBeginAllowThreads();
22477 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
22478
22479 wxPyEndAllowThreads(__tstate);
22480 if (PyErr_Occurred()) SWIG_fail;
22481 }
22482 {
22483 wxDateTime * resultptr;
22484 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22485 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22486 }
22487 return resultobj;
22488 fail:
22489 return NULL;
22490 }
22491
22492
22493 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
22494 PyObject *resultobj = NULL;
22495 wxDateTime *arg1 = (wxDateTime *) 0 ;
22496 bool arg2 = (bool) false ;
22497 wxDateTime *result;
22498 PyObject * obj0 = 0 ;
22499 PyObject * obj1 = 0 ;
22500 char *kwnames[] = {
22501 (char *) "self",(char *) "noDST", NULL
22502 };
22503
22504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
22505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22506 if (SWIG_arg_fail(1)) SWIG_fail;
22507 if (obj1) {
22508 {
22509 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22510 if (SWIG_arg_fail(2)) SWIG_fail;
22511 }
22512 }
22513 {
22514 PyThreadState* __tstate = wxPyBeginAllowThreads();
22515 {
22516 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
22517 result = (wxDateTime *) &_result_ref;
22518 }
22519
22520 wxPyEndAllowThreads(__tstate);
22521 if (PyErr_Occurred()) SWIG_fail;
22522 }
22523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22524 return resultobj;
22525 fail:
22526 return NULL;
22527 }
22528
22529
22530 static PyObject *_wrap_DateTime_FromUTC(PyObject *, PyObject *args, PyObject *kwargs) {
22531 PyObject *resultobj = NULL;
22532 wxDateTime *arg1 = (wxDateTime *) 0 ;
22533 bool arg2 = (bool) false ;
22534 wxDateTime result;
22535 PyObject * obj0 = 0 ;
22536 PyObject * obj1 = 0 ;
22537 char *kwnames[] = {
22538 (char *) "self",(char *) "noDST", NULL
22539 };
22540
22541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) goto fail;
22542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22543 if (SWIG_arg_fail(1)) SWIG_fail;
22544 if (obj1) {
22545 {
22546 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22547 if (SWIG_arg_fail(2)) SWIG_fail;
22548 }
22549 }
22550 {
22551 PyThreadState* __tstate = wxPyBeginAllowThreads();
22552 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
22553
22554 wxPyEndAllowThreads(__tstate);
22555 if (PyErr_Occurred()) SWIG_fail;
22556 }
22557 {
22558 wxDateTime * resultptr;
22559 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22560 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22561 }
22562 return resultobj;
22563 fail:
22564 return NULL;
22565 }
22566
22567
22568 static PyObject *_wrap_DateTime_MakeFromUTC(PyObject *, PyObject *args, PyObject *kwargs) {
22569 PyObject *resultobj = NULL;
22570 wxDateTime *arg1 = (wxDateTime *) 0 ;
22571 bool arg2 = (bool) false ;
22572 wxDateTime *result;
22573 PyObject * obj0 = 0 ;
22574 PyObject * obj1 = 0 ;
22575 char *kwnames[] = {
22576 (char *) "self",(char *) "noDST", NULL
22577 };
22578
22579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) goto fail;
22580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22581 if (SWIG_arg_fail(1)) SWIG_fail;
22582 if (obj1) {
22583 {
22584 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22585 if (SWIG_arg_fail(2)) SWIG_fail;
22586 }
22587 }
22588 {
22589 PyThreadState* __tstate = wxPyBeginAllowThreads();
22590 {
22591 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
22592 result = (wxDateTime *) &_result_ref;
22593 }
22594
22595 wxPyEndAllowThreads(__tstate);
22596 if (PyErr_Occurred()) SWIG_fail;
22597 }
22598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22599 return resultobj;
22600 fail:
22601 return NULL;
22602 }
22603
22604
22605 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
22606 PyObject *resultobj = NULL;
22607 wxDateTime *arg1 = (wxDateTime *) 0 ;
22608 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22609 int result;
22610 PyObject * obj0 = 0 ;
22611 PyObject * obj1 = 0 ;
22612 char *kwnames[] = {
22613 (char *) "self",(char *) "country", NULL
22614 };
22615
22616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
22617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22618 if (SWIG_arg_fail(1)) SWIG_fail;
22619 if (obj1) {
22620 {
22621 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
22622 if (SWIG_arg_fail(2)) SWIG_fail;
22623 }
22624 }
22625 {
22626 PyThreadState* __tstate = wxPyBeginAllowThreads();
22627 result = (int)(arg1)->IsDST(arg2);
22628
22629 wxPyEndAllowThreads(__tstate);
22630 if (PyErr_Occurred()) SWIG_fail;
22631 }
22632 {
22633 resultobj = SWIG_From_int(static_cast<int >(result));
22634 }
22635 return resultobj;
22636 fail:
22637 return NULL;
22638 }
22639
22640
22641 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
22642 PyObject *resultobj = NULL;
22643 wxDateTime *arg1 = (wxDateTime *) 0 ;
22644 bool result;
22645 PyObject * obj0 = 0 ;
22646 char *kwnames[] = {
22647 (char *) "self", NULL
22648 };
22649
22650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
22651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22652 if (SWIG_arg_fail(1)) SWIG_fail;
22653 {
22654 PyThreadState* __tstate = wxPyBeginAllowThreads();
22655 result = (bool)((wxDateTime const *)arg1)->IsValid();
22656
22657 wxPyEndAllowThreads(__tstate);
22658 if (PyErr_Occurred()) SWIG_fail;
22659 }
22660 {
22661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22662 }
22663 return resultobj;
22664 fail:
22665 return NULL;
22666 }
22667
22668
22669 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
22670 PyObject *resultobj = NULL;
22671 wxDateTime *arg1 = (wxDateTime *) 0 ;
22672 time_t result;
22673 PyObject * obj0 = 0 ;
22674 char *kwnames[] = {
22675 (char *) "self", NULL
22676 };
22677
22678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
22679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22680 if (SWIG_arg_fail(1)) SWIG_fail;
22681 {
22682 PyThreadState* __tstate = wxPyBeginAllowThreads();
22683 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
22684
22685 wxPyEndAllowThreads(__tstate);
22686 if (PyErr_Occurred()) SWIG_fail;
22687 }
22688 {
22689 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
22690 }
22691 return resultobj;
22692 fail:
22693 return NULL;
22694 }
22695
22696
22697 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
22698 PyObject *resultobj = NULL;
22699 wxDateTime *arg1 = (wxDateTime *) 0 ;
22700 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22701 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22702 int result;
22703 bool temp2 = false ;
22704 PyObject * obj0 = 0 ;
22705 PyObject * obj1 = 0 ;
22706 char *kwnames[] = {
22707 (char *) "self",(char *) "tz", NULL
22708 };
22709
22710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
22711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22712 if (SWIG_arg_fail(1)) SWIG_fail;
22713 if (obj1) {
22714 {
22715 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22716 temp2 = true;
22717 }
22718 }
22719 {
22720 PyThreadState* __tstate = wxPyBeginAllowThreads();
22721 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
22722
22723 wxPyEndAllowThreads(__tstate);
22724 if (PyErr_Occurred()) SWIG_fail;
22725 }
22726 {
22727 resultobj = SWIG_From_int(static_cast<int >(result));
22728 }
22729 {
22730 if (temp2) delete arg2;
22731 }
22732 return resultobj;
22733 fail:
22734 {
22735 if (temp2) delete arg2;
22736 }
22737 return NULL;
22738 }
22739
22740
22741 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
22742 PyObject *resultobj = NULL;
22743 wxDateTime *arg1 = (wxDateTime *) 0 ;
22744 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22745 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22746 wxDateTime::Month result;
22747 bool temp2 = false ;
22748 PyObject * obj0 = 0 ;
22749 PyObject * obj1 = 0 ;
22750 char *kwnames[] = {
22751 (char *) "self",(char *) "tz", NULL
22752 };
22753
22754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
22755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22756 if (SWIG_arg_fail(1)) SWIG_fail;
22757 if (obj1) {
22758 {
22759 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22760 temp2 = true;
22761 }
22762 }
22763 {
22764 PyThreadState* __tstate = wxPyBeginAllowThreads();
22765 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
22766
22767 wxPyEndAllowThreads(__tstate);
22768 if (PyErr_Occurred()) SWIG_fail;
22769 }
22770 resultobj = SWIG_From_int((result));
22771 {
22772 if (temp2) delete arg2;
22773 }
22774 return resultobj;
22775 fail:
22776 {
22777 if (temp2) delete arg2;
22778 }
22779 return NULL;
22780 }
22781
22782
22783 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
22784 PyObject *resultobj = NULL;
22785 wxDateTime *arg1 = (wxDateTime *) 0 ;
22786 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22787 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22788 int result;
22789 bool temp2 = false ;
22790 PyObject * obj0 = 0 ;
22791 PyObject * obj1 = 0 ;
22792 char *kwnames[] = {
22793 (char *) "self",(char *) "tz", NULL
22794 };
22795
22796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
22797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22798 if (SWIG_arg_fail(1)) SWIG_fail;
22799 if (obj1) {
22800 {
22801 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22802 temp2 = true;
22803 }
22804 }
22805 {
22806 PyThreadState* __tstate = wxPyBeginAllowThreads();
22807 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
22808
22809 wxPyEndAllowThreads(__tstate);
22810 if (PyErr_Occurred()) SWIG_fail;
22811 }
22812 {
22813 resultobj = SWIG_From_int(static_cast<int >(result));
22814 }
22815 {
22816 if (temp2) delete arg2;
22817 }
22818 return resultobj;
22819 fail:
22820 {
22821 if (temp2) delete arg2;
22822 }
22823 return NULL;
22824 }
22825
22826
22827 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
22828 PyObject *resultobj = NULL;
22829 wxDateTime *arg1 = (wxDateTime *) 0 ;
22830 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22831 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22832 wxDateTime::WeekDay result;
22833 bool temp2 = false ;
22834 PyObject * obj0 = 0 ;
22835 PyObject * obj1 = 0 ;
22836 char *kwnames[] = {
22837 (char *) "self",(char *) "tz", NULL
22838 };
22839
22840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
22841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22842 if (SWIG_arg_fail(1)) SWIG_fail;
22843 if (obj1) {
22844 {
22845 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22846 temp2 = true;
22847 }
22848 }
22849 {
22850 PyThreadState* __tstate = wxPyBeginAllowThreads();
22851 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
22852
22853 wxPyEndAllowThreads(__tstate);
22854 if (PyErr_Occurred()) SWIG_fail;
22855 }
22856 resultobj = SWIG_From_int((result));
22857 {
22858 if (temp2) delete arg2;
22859 }
22860 return resultobj;
22861 fail:
22862 {
22863 if (temp2) delete arg2;
22864 }
22865 return NULL;
22866 }
22867
22868
22869 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
22870 PyObject *resultobj = NULL;
22871 wxDateTime *arg1 = (wxDateTime *) 0 ;
22872 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22873 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22874 int result;
22875 bool temp2 = false ;
22876 PyObject * obj0 = 0 ;
22877 PyObject * obj1 = 0 ;
22878 char *kwnames[] = {
22879 (char *) "self",(char *) "tz", NULL
22880 };
22881
22882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
22883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22884 if (SWIG_arg_fail(1)) SWIG_fail;
22885 if (obj1) {
22886 {
22887 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22888 temp2 = true;
22889 }
22890 }
22891 {
22892 PyThreadState* __tstate = wxPyBeginAllowThreads();
22893 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
22894
22895 wxPyEndAllowThreads(__tstate);
22896 if (PyErr_Occurred()) SWIG_fail;
22897 }
22898 {
22899 resultobj = SWIG_From_int(static_cast<int >(result));
22900 }
22901 {
22902 if (temp2) delete arg2;
22903 }
22904 return resultobj;
22905 fail:
22906 {
22907 if (temp2) delete arg2;
22908 }
22909 return NULL;
22910 }
22911
22912
22913 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
22914 PyObject *resultobj = NULL;
22915 wxDateTime *arg1 = (wxDateTime *) 0 ;
22916 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22917 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22918 int result;
22919 bool temp2 = false ;
22920 PyObject * obj0 = 0 ;
22921 PyObject * obj1 = 0 ;
22922 char *kwnames[] = {
22923 (char *) "self",(char *) "tz", NULL
22924 };
22925
22926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
22927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22928 if (SWIG_arg_fail(1)) SWIG_fail;
22929 if (obj1) {
22930 {
22931 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22932 temp2 = true;
22933 }
22934 }
22935 {
22936 PyThreadState* __tstate = wxPyBeginAllowThreads();
22937 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
22938
22939 wxPyEndAllowThreads(__tstate);
22940 if (PyErr_Occurred()) SWIG_fail;
22941 }
22942 {
22943 resultobj = SWIG_From_int(static_cast<int >(result));
22944 }
22945 {
22946 if (temp2) delete arg2;
22947 }
22948 return resultobj;
22949 fail:
22950 {
22951 if (temp2) delete arg2;
22952 }
22953 return NULL;
22954 }
22955
22956
22957 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
22958 PyObject *resultobj = NULL;
22959 wxDateTime *arg1 = (wxDateTime *) 0 ;
22960 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22961 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22962 int result;
22963 bool temp2 = false ;
22964 PyObject * obj0 = 0 ;
22965 PyObject * obj1 = 0 ;
22966 char *kwnames[] = {
22967 (char *) "self",(char *) "tz", NULL
22968 };
22969
22970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
22971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22972 if (SWIG_arg_fail(1)) SWIG_fail;
22973 if (obj1) {
22974 {
22975 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22976 temp2 = true;
22977 }
22978 }
22979 {
22980 PyThreadState* __tstate = wxPyBeginAllowThreads();
22981 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
22982
22983 wxPyEndAllowThreads(__tstate);
22984 if (PyErr_Occurred()) SWIG_fail;
22985 }
22986 {
22987 resultobj = SWIG_From_int(static_cast<int >(result));
22988 }
22989 {
22990 if (temp2) delete arg2;
22991 }
22992 return resultobj;
22993 fail:
22994 {
22995 if (temp2) delete arg2;
22996 }
22997 return NULL;
22998 }
22999
23000
23001 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
23002 PyObject *resultobj = NULL;
23003 wxDateTime *arg1 = (wxDateTime *) 0 ;
23004 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
23005 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
23006 int result;
23007 bool temp2 = false ;
23008 PyObject * obj0 = 0 ;
23009 PyObject * obj1 = 0 ;
23010 char *kwnames[] = {
23011 (char *) "self",(char *) "tz", NULL
23012 };
23013
23014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
23015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23016 if (SWIG_arg_fail(1)) SWIG_fail;
23017 if (obj1) {
23018 {
23019 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
23020 temp2 = true;
23021 }
23022 }
23023 {
23024 PyThreadState* __tstate = wxPyBeginAllowThreads();
23025 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
23026
23027 wxPyEndAllowThreads(__tstate);
23028 if (PyErr_Occurred()) SWIG_fail;
23029 }
23030 {
23031 resultobj = SWIG_From_int(static_cast<int >(result));
23032 }
23033 {
23034 if (temp2) delete arg2;
23035 }
23036 return resultobj;
23037 fail:
23038 {
23039 if (temp2) delete arg2;
23040 }
23041 return NULL;
23042 }
23043
23044
23045 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
23046 PyObject *resultobj = NULL;
23047 wxDateTime *arg1 = (wxDateTime *) 0 ;
23048 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
23049 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
23050 int result;
23051 bool temp2 = false ;
23052 PyObject * obj0 = 0 ;
23053 PyObject * obj1 = 0 ;
23054 char *kwnames[] = {
23055 (char *) "self",(char *) "tz", NULL
23056 };
23057
23058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
23059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23060 if (SWIG_arg_fail(1)) SWIG_fail;
23061 if (obj1) {
23062 {
23063 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
23064 temp2 = true;
23065 }
23066 }
23067 {
23068 PyThreadState* __tstate = wxPyBeginAllowThreads();
23069 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
23070
23071 wxPyEndAllowThreads(__tstate);
23072 if (PyErr_Occurred()) SWIG_fail;
23073 }
23074 {
23075 resultobj = SWIG_From_int(static_cast<int >(result));
23076 }
23077 {
23078 if (temp2) delete arg2;
23079 }
23080 return resultobj;
23081 fail:
23082 {
23083 if (temp2) delete arg2;
23084 }
23085 return NULL;
23086 }
23087
23088
23089 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
23090 PyObject *resultobj = NULL;
23091 wxDateTime *arg1 = (wxDateTime *) 0 ;
23092 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23093 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23094 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23095 int result;
23096 bool temp3 = false ;
23097 PyObject * obj0 = 0 ;
23098 PyObject * obj1 = 0 ;
23099 PyObject * obj2 = 0 ;
23100 char *kwnames[] = {
23101 (char *) "self",(char *) "flags",(char *) "tz", NULL
23102 };
23103
23104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
23105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23106 if (SWIG_arg_fail(1)) SWIG_fail;
23107 if (obj1) {
23108 {
23109 arg2 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj1));
23110 if (SWIG_arg_fail(2)) SWIG_fail;
23111 }
23112 }
23113 if (obj2) {
23114 {
23115 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23116 temp3 = true;
23117 }
23118 }
23119 {
23120 PyThreadState* __tstate = wxPyBeginAllowThreads();
23121 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
23122
23123 wxPyEndAllowThreads(__tstate);
23124 if (PyErr_Occurred()) SWIG_fail;
23125 }
23126 {
23127 resultobj = SWIG_From_int(static_cast<int >(result));
23128 }
23129 {
23130 if (temp3) delete arg3;
23131 }
23132 return resultobj;
23133 fail:
23134 {
23135 if (temp3) delete arg3;
23136 }
23137 return NULL;
23138 }
23139
23140
23141 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
23142 PyObject *resultobj = NULL;
23143 wxDateTime *arg1 = (wxDateTime *) 0 ;
23144 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23145 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23146 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23147 int result;
23148 bool temp3 = false ;
23149 PyObject * obj0 = 0 ;
23150 PyObject * obj1 = 0 ;
23151 PyObject * obj2 = 0 ;
23152 char *kwnames[] = {
23153 (char *) "self",(char *) "flags",(char *) "tz", NULL
23154 };
23155
23156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
23157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23158 if (SWIG_arg_fail(1)) SWIG_fail;
23159 if (obj1) {
23160 {
23161 arg2 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj1));
23162 if (SWIG_arg_fail(2)) SWIG_fail;
23163 }
23164 }
23165 if (obj2) {
23166 {
23167 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23168 temp3 = true;
23169 }
23170 }
23171 {
23172 PyThreadState* __tstate = wxPyBeginAllowThreads();
23173 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
23174
23175 wxPyEndAllowThreads(__tstate);
23176 if (PyErr_Occurred()) SWIG_fail;
23177 }
23178 {
23179 resultobj = SWIG_From_int(static_cast<int >(result));
23180 }
23181 {
23182 if (temp3) delete arg3;
23183 }
23184 return resultobj;
23185 fail:
23186 {
23187 if (temp3) delete arg3;
23188 }
23189 return NULL;
23190 }
23191
23192
23193 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
23194 PyObject *resultobj = NULL;
23195 wxDateTime *arg1 = (wxDateTime *) 0 ;
23196 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23197 bool result;
23198 PyObject * obj0 = 0 ;
23199 PyObject * obj1 = 0 ;
23200 char *kwnames[] = {
23201 (char *) "self",(char *) "country", NULL
23202 };
23203
23204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
23205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23206 if (SWIG_arg_fail(1)) SWIG_fail;
23207 if (obj1) {
23208 {
23209 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
23210 if (SWIG_arg_fail(2)) SWIG_fail;
23211 }
23212 }
23213 {
23214 PyThreadState* __tstate = wxPyBeginAllowThreads();
23215 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
23216
23217 wxPyEndAllowThreads(__tstate);
23218 if (PyErr_Occurred()) SWIG_fail;
23219 }
23220 {
23221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23222 }
23223 return resultobj;
23224 fail:
23225 return NULL;
23226 }
23227
23228
23229 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
23230 PyObject *resultobj = NULL;
23231 wxDateTime *arg1 = (wxDateTime *) 0 ;
23232 wxDateTime *arg2 = 0 ;
23233 bool result;
23234 PyObject * obj0 = 0 ;
23235 PyObject * obj1 = 0 ;
23236 char *kwnames[] = {
23237 (char *) "self",(char *) "datetime", NULL
23238 };
23239
23240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
23241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23242 if (SWIG_arg_fail(1)) SWIG_fail;
23243 {
23244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23245 if (SWIG_arg_fail(2)) SWIG_fail;
23246 if (arg2 == NULL) {
23247 SWIG_null_ref("wxDateTime");
23248 }
23249 if (SWIG_arg_fail(2)) SWIG_fail;
23250 }
23251 {
23252 PyThreadState* __tstate = wxPyBeginAllowThreads();
23253 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
23254
23255 wxPyEndAllowThreads(__tstate);
23256 if (PyErr_Occurred()) SWIG_fail;
23257 }
23258 {
23259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23260 }
23261 return resultobj;
23262 fail:
23263 return NULL;
23264 }
23265
23266
23267 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
23268 PyObject *resultobj = NULL;
23269 wxDateTime *arg1 = (wxDateTime *) 0 ;
23270 wxDateTime *arg2 = 0 ;
23271 bool result;
23272 PyObject * obj0 = 0 ;
23273 PyObject * obj1 = 0 ;
23274 char *kwnames[] = {
23275 (char *) "self",(char *) "datetime", NULL
23276 };
23277
23278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
23279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23280 if (SWIG_arg_fail(1)) SWIG_fail;
23281 {
23282 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23283 if (SWIG_arg_fail(2)) SWIG_fail;
23284 if (arg2 == NULL) {
23285 SWIG_null_ref("wxDateTime");
23286 }
23287 if (SWIG_arg_fail(2)) SWIG_fail;
23288 }
23289 {
23290 PyThreadState* __tstate = wxPyBeginAllowThreads();
23291 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
23292
23293 wxPyEndAllowThreads(__tstate);
23294 if (PyErr_Occurred()) SWIG_fail;
23295 }
23296 {
23297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23298 }
23299 return resultobj;
23300 fail:
23301 return NULL;
23302 }
23303
23304
23305 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
23306 PyObject *resultobj = NULL;
23307 wxDateTime *arg1 = (wxDateTime *) 0 ;
23308 wxDateTime *arg2 = 0 ;
23309 bool result;
23310 PyObject * obj0 = 0 ;
23311 PyObject * obj1 = 0 ;
23312 char *kwnames[] = {
23313 (char *) "self",(char *) "datetime", NULL
23314 };
23315
23316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
23317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23318 if (SWIG_arg_fail(1)) SWIG_fail;
23319 {
23320 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23321 if (SWIG_arg_fail(2)) SWIG_fail;
23322 if (arg2 == NULL) {
23323 SWIG_null_ref("wxDateTime");
23324 }
23325 if (SWIG_arg_fail(2)) SWIG_fail;
23326 }
23327 {
23328 PyThreadState* __tstate = wxPyBeginAllowThreads();
23329 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
23330
23331 wxPyEndAllowThreads(__tstate);
23332 if (PyErr_Occurred()) SWIG_fail;
23333 }
23334 {
23335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23336 }
23337 return resultobj;
23338 fail:
23339 return NULL;
23340 }
23341
23342
23343 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
23344 PyObject *resultobj = NULL;
23345 wxDateTime *arg1 = (wxDateTime *) 0 ;
23346 wxDateTime *arg2 = 0 ;
23347 wxDateTime *arg3 = 0 ;
23348 bool result;
23349 PyObject * obj0 = 0 ;
23350 PyObject * obj1 = 0 ;
23351 PyObject * obj2 = 0 ;
23352 char *kwnames[] = {
23353 (char *) "self",(char *) "t1",(char *) "t2", NULL
23354 };
23355
23356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
23357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23358 if (SWIG_arg_fail(1)) SWIG_fail;
23359 {
23360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23361 if (SWIG_arg_fail(2)) SWIG_fail;
23362 if (arg2 == NULL) {
23363 SWIG_null_ref("wxDateTime");
23364 }
23365 if (SWIG_arg_fail(2)) SWIG_fail;
23366 }
23367 {
23368 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23369 if (SWIG_arg_fail(3)) SWIG_fail;
23370 if (arg3 == NULL) {
23371 SWIG_null_ref("wxDateTime");
23372 }
23373 if (SWIG_arg_fail(3)) SWIG_fail;
23374 }
23375 {
23376 PyThreadState* __tstate = wxPyBeginAllowThreads();
23377 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
23378
23379 wxPyEndAllowThreads(__tstate);
23380 if (PyErr_Occurred()) SWIG_fail;
23381 }
23382 {
23383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23384 }
23385 return resultobj;
23386 fail:
23387 return NULL;
23388 }
23389
23390
23391 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
23392 PyObject *resultobj = NULL;
23393 wxDateTime *arg1 = (wxDateTime *) 0 ;
23394 wxDateTime *arg2 = 0 ;
23395 wxDateTime *arg3 = 0 ;
23396 bool result;
23397 PyObject * obj0 = 0 ;
23398 PyObject * obj1 = 0 ;
23399 PyObject * obj2 = 0 ;
23400 char *kwnames[] = {
23401 (char *) "self",(char *) "t1",(char *) "t2", NULL
23402 };
23403
23404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
23405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23406 if (SWIG_arg_fail(1)) SWIG_fail;
23407 {
23408 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23409 if (SWIG_arg_fail(2)) SWIG_fail;
23410 if (arg2 == NULL) {
23411 SWIG_null_ref("wxDateTime");
23412 }
23413 if (SWIG_arg_fail(2)) SWIG_fail;
23414 }
23415 {
23416 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23417 if (SWIG_arg_fail(3)) SWIG_fail;
23418 if (arg3 == NULL) {
23419 SWIG_null_ref("wxDateTime");
23420 }
23421 if (SWIG_arg_fail(3)) SWIG_fail;
23422 }
23423 {
23424 PyThreadState* __tstate = wxPyBeginAllowThreads();
23425 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
23426
23427 wxPyEndAllowThreads(__tstate);
23428 if (PyErr_Occurred()) SWIG_fail;
23429 }
23430 {
23431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23432 }
23433 return resultobj;
23434 fail:
23435 return NULL;
23436 }
23437
23438
23439 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
23440 PyObject *resultobj = NULL;
23441 wxDateTime *arg1 = (wxDateTime *) 0 ;
23442 wxDateTime *arg2 = 0 ;
23443 bool result;
23444 PyObject * obj0 = 0 ;
23445 PyObject * obj1 = 0 ;
23446 char *kwnames[] = {
23447 (char *) "self",(char *) "dt", NULL
23448 };
23449
23450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
23451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23452 if (SWIG_arg_fail(1)) SWIG_fail;
23453 {
23454 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23455 if (SWIG_arg_fail(2)) SWIG_fail;
23456 if (arg2 == NULL) {
23457 SWIG_null_ref("wxDateTime");
23458 }
23459 if (SWIG_arg_fail(2)) SWIG_fail;
23460 }
23461 {
23462 PyThreadState* __tstate = wxPyBeginAllowThreads();
23463 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
23464
23465 wxPyEndAllowThreads(__tstate);
23466 if (PyErr_Occurred()) SWIG_fail;
23467 }
23468 {
23469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23470 }
23471 return resultobj;
23472 fail:
23473 return NULL;
23474 }
23475
23476
23477 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
23478 PyObject *resultobj = NULL;
23479 wxDateTime *arg1 = (wxDateTime *) 0 ;
23480 wxDateTime *arg2 = 0 ;
23481 bool result;
23482 PyObject * obj0 = 0 ;
23483 PyObject * obj1 = 0 ;
23484 char *kwnames[] = {
23485 (char *) "self",(char *) "dt", NULL
23486 };
23487
23488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
23489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23490 if (SWIG_arg_fail(1)) SWIG_fail;
23491 {
23492 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23493 if (SWIG_arg_fail(2)) SWIG_fail;
23494 if (arg2 == NULL) {
23495 SWIG_null_ref("wxDateTime");
23496 }
23497 if (SWIG_arg_fail(2)) SWIG_fail;
23498 }
23499 {
23500 PyThreadState* __tstate = wxPyBeginAllowThreads();
23501 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
23502
23503 wxPyEndAllowThreads(__tstate);
23504 if (PyErr_Occurred()) SWIG_fail;
23505 }
23506 {
23507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23508 }
23509 return resultobj;
23510 fail:
23511 return NULL;
23512 }
23513
23514
23515 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
23516 PyObject *resultobj = NULL;
23517 wxDateTime *arg1 = (wxDateTime *) 0 ;
23518 wxDateTime *arg2 = 0 ;
23519 wxTimeSpan *arg3 = 0 ;
23520 bool result;
23521 PyObject * obj0 = 0 ;
23522 PyObject * obj1 = 0 ;
23523 PyObject * obj2 = 0 ;
23524 char *kwnames[] = {
23525 (char *) "self",(char *) "dt",(char *) "ts", NULL
23526 };
23527
23528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
23529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23530 if (SWIG_arg_fail(1)) SWIG_fail;
23531 {
23532 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23533 if (SWIG_arg_fail(2)) SWIG_fail;
23534 if (arg2 == NULL) {
23535 SWIG_null_ref("wxDateTime");
23536 }
23537 if (SWIG_arg_fail(2)) SWIG_fail;
23538 }
23539 {
23540 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23541 if (SWIG_arg_fail(3)) SWIG_fail;
23542 if (arg3 == NULL) {
23543 SWIG_null_ref("wxTimeSpan");
23544 }
23545 if (SWIG_arg_fail(3)) SWIG_fail;
23546 }
23547 {
23548 PyThreadState* __tstate = wxPyBeginAllowThreads();
23549 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
23550
23551 wxPyEndAllowThreads(__tstate);
23552 if (PyErr_Occurred()) SWIG_fail;
23553 }
23554 {
23555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23556 }
23557 return resultobj;
23558 fail:
23559 return NULL;
23560 }
23561
23562
23563 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
23564 PyObject *resultobj = NULL;
23565 wxDateTime *arg1 = (wxDateTime *) 0 ;
23566 wxTimeSpan *arg2 = 0 ;
23567 wxDateTime *result;
23568 PyObject * obj0 = 0 ;
23569 PyObject * obj1 = 0 ;
23570 char *kwnames[] = {
23571 (char *) "self",(char *) "diff", NULL
23572 };
23573
23574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
23575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23576 if (SWIG_arg_fail(1)) SWIG_fail;
23577 {
23578 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23579 if (SWIG_arg_fail(2)) SWIG_fail;
23580 if (arg2 == NULL) {
23581 SWIG_null_ref("wxTimeSpan");
23582 }
23583 if (SWIG_arg_fail(2)) SWIG_fail;
23584 }
23585 {
23586 PyThreadState* __tstate = wxPyBeginAllowThreads();
23587 {
23588 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
23589 result = (wxDateTime *) &_result_ref;
23590 }
23591
23592 wxPyEndAllowThreads(__tstate);
23593 if (PyErr_Occurred()) SWIG_fail;
23594 }
23595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23596 return resultobj;
23597 fail:
23598 return NULL;
23599 }
23600
23601
23602 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
23603 PyObject *resultobj = NULL;
23604 wxDateTime *arg1 = (wxDateTime *) 0 ;
23605 wxDateSpan *arg2 = 0 ;
23606 wxDateTime *result;
23607 PyObject * obj0 = 0 ;
23608 PyObject * obj1 = 0 ;
23609 char *kwnames[] = {
23610 (char *) "self",(char *) "diff", NULL
23611 };
23612
23613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
23614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23615 if (SWIG_arg_fail(1)) SWIG_fail;
23616 {
23617 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23618 if (SWIG_arg_fail(2)) SWIG_fail;
23619 if (arg2 == NULL) {
23620 SWIG_null_ref("wxDateSpan");
23621 }
23622 if (SWIG_arg_fail(2)) SWIG_fail;
23623 }
23624 {
23625 PyThreadState* __tstate = wxPyBeginAllowThreads();
23626 {
23627 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
23628 result = (wxDateTime *) &_result_ref;
23629 }
23630
23631 wxPyEndAllowThreads(__tstate);
23632 if (PyErr_Occurred()) SWIG_fail;
23633 }
23634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23635 return resultobj;
23636 fail:
23637 return NULL;
23638 }
23639
23640
23641 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
23642 PyObject *resultobj = NULL;
23643 wxDateTime *arg1 = (wxDateTime *) 0 ;
23644 wxTimeSpan *arg2 = 0 ;
23645 wxDateTime *result;
23646 PyObject * obj0 = 0 ;
23647 PyObject * obj1 = 0 ;
23648 char *kwnames[] = {
23649 (char *) "self",(char *) "diff", NULL
23650 };
23651
23652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
23653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23654 if (SWIG_arg_fail(1)) SWIG_fail;
23655 {
23656 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23657 if (SWIG_arg_fail(2)) SWIG_fail;
23658 if (arg2 == NULL) {
23659 SWIG_null_ref("wxTimeSpan");
23660 }
23661 if (SWIG_arg_fail(2)) SWIG_fail;
23662 }
23663 {
23664 PyThreadState* __tstate = wxPyBeginAllowThreads();
23665 {
23666 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
23667 result = (wxDateTime *) &_result_ref;
23668 }
23669
23670 wxPyEndAllowThreads(__tstate);
23671 if (PyErr_Occurred()) SWIG_fail;
23672 }
23673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23674 return resultobj;
23675 fail:
23676 return NULL;
23677 }
23678
23679
23680 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
23681 PyObject *resultobj = NULL;
23682 wxDateTime *arg1 = (wxDateTime *) 0 ;
23683 wxDateSpan *arg2 = 0 ;
23684 wxDateTime *result;
23685 PyObject * obj0 = 0 ;
23686 PyObject * obj1 = 0 ;
23687 char *kwnames[] = {
23688 (char *) "self",(char *) "diff", NULL
23689 };
23690
23691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
23692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23693 if (SWIG_arg_fail(1)) SWIG_fail;
23694 {
23695 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23696 if (SWIG_arg_fail(2)) SWIG_fail;
23697 if (arg2 == NULL) {
23698 SWIG_null_ref("wxDateSpan");
23699 }
23700 if (SWIG_arg_fail(2)) SWIG_fail;
23701 }
23702 {
23703 PyThreadState* __tstate = wxPyBeginAllowThreads();
23704 {
23705 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
23706 result = (wxDateTime *) &_result_ref;
23707 }
23708
23709 wxPyEndAllowThreads(__tstate);
23710 if (PyErr_Occurred()) SWIG_fail;
23711 }
23712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23713 return resultobj;
23714 fail:
23715 return NULL;
23716 }
23717
23718
23719 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
23720 PyObject *resultobj = NULL;
23721 wxDateTime *arg1 = (wxDateTime *) 0 ;
23722 wxDateTime *arg2 = 0 ;
23723 wxTimeSpan result;
23724 PyObject * obj0 = 0 ;
23725 PyObject * obj1 = 0 ;
23726 char *kwnames[] = {
23727 (char *) "self",(char *) "dt", NULL
23728 };
23729
23730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
23731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23732 if (SWIG_arg_fail(1)) SWIG_fail;
23733 {
23734 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23735 if (SWIG_arg_fail(2)) SWIG_fail;
23736 if (arg2 == NULL) {
23737 SWIG_null_ref("wxDateTime");
23738 }
23739 if (SWIG_arg_fail(2)) SWIG_fail;
23740 }
23741 {
23742 PyThreadState* __tstate = wxPyBeginAllowThreads();
23743 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
23744
23745 wxPyEndAllowThreads(__tstate);
23746 if (PyErr_Occurred()) SWIG_fail;
23747 }
23748 {
23749 wxTimeSpan * resultptr;
23750 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
23751 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23752 }
23753 return resultobj;
23754 fail:
23755 return NULL;
23756 }
23757
23758
23759 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
23760 PyObject *resultobj = NULL;
23761 wxDateTime *arg1 = (wxDateTime *) 0 ;
23762 wxTimeSpan *arg2 = 0 ;
23763 wxDateTime *result;
23764 PyObject * obj0 = 0 ;
23765 PyObject * obj1 = 0 ;
23766
23767 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
23768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23769 if (SWIG_arg_fail(1)) SWIG_fail;
23770 {
23771 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23772 if (SWIG_arg_fail(2)) SWIG_fail;
23773 if (arg2 == NULL) {
23774 SWIG_null_ref("wxTimeSpan");
23775 }
23776 if (SWIG_arg_fail(2)) SWIG_fail;
23777 }
23778 {
23779 PyThreadState* __tstate = wxPyBeginAllowThreads();
23780 {
23781 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
23782 result = (wxDateTime *) &_result_ref;
23783 }
23784
23785 wxPyEndAllowThreads(__tstate);
23786 if (PyErr_Occurred()) SWIG_fail;
23787 }
23788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
23789 return resultobj;
23790 fail:
23791 return NULL;
23792 }
23793
23794
23795 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
23796 PyObject *resultobj = NULL;
23797 wxDateTime *arg1 = (wxDateTime *) 0 ;
23798 wxDateSpan *arg2 = 0 ;
23799 wxDateTime *result;
23800 PyObject * obj0 = 0 ;
23801 PyObject * obj1 = 0 ;
23802
23803 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
23804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23805 if (SWIG_arg_fail(1)) SWIG_fail;
23806 {
23807 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23808 if (SWIG_arg_fail(2)) SWIG_fail;
23809 if (arg2 == NULL) {
23810 SWIG_null_ref("wxDateSpan");
23811 }
23812 if (SWIG_arg_fail(2)) SWIG_fail;
23813 }
23814 {
23815 PyThreadState* __tstate = wxPyBeginAllowThreads();
23816 {
23817 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
23818 result = (wxDateTime *) &_result_ref;
23819 }
23820
23821 wxPyEndAllowThreads(__tstate);
23822 if (PyErr_Occurred()) SWIG_fail;
23823 }
23824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
23825 return resultobj;
23826 fail:
23827 return NULL;
23828 }
23829
23830
23831 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
23832 int argc;
23833 PyObject *argv[3];
23834 int ii;
23835
23836 argc = PyObject_Length(args);
23837 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23838 argv[ii] = PyTuple_GetItem(args,ii);
23839 }
23840 if (argc == 2) {
23841 int _v;
23842 {
23843 void *ptr;
23844 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23845 _v = 0;
23846 PyErr_Clear();
23847 } else {
23848 _v = 1;
23849 }
23850 }
23851 if (_v) {
23852 {
23853 void *ptr = 0;
23854 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23855 _v = 0;
23856 PyErr_Clear();
23857 } else {
23858 _v = (ptr != 0);
23859 }
23860 }
23861 if (_v) {
23862 return _wrap_DateTime___iadd____SWIG_0(self,args);
23863 }
23864 }
23865 }
23866 if (argc == 2) {
23867 int _v;
23868 {
23869 void *ptr;
23870 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23871 _v = 0;
23872 PyErr_Clear();
23873 } else {
23874 _v = 1;
23875 }
23876 }
23877 if (_v) {
23878 {
23879 void *ptr = 0;
23880 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23881 _v = 0;
23882 PyErr_Clear();
23883 } else {
23884 _v = (ptr != 0);
23885 }
23886 }
23887 if (_v) {
23888 return _wrap_DateTime___iadd____SWIG_1(self,args);
23889 }
23890 }
23891 }
23892
23893 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
23894 return NULL;
23895 }
23896
23897
23898 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
23899 PyObject *resultobj = NULL;
23900 wxDateTime *arg1 = (wxDateTime *) 0 ;
23901 wxTimeSpan *arg2 = 0 ;
23902 wxDateTime *result;
23903 PyObject * obj0 = 0 ;
23904 PyObject * obj1 = 0 ;
23905
23906 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
23907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23908 if (SWIG_arg_fail(1)) SWIG_fail;
23909 {
23910 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23911 if (SWIG_arg_fail(2)) SWIG_fail;
23912 if (arg2 == NULL) {
23913 SWIG_null_ref("wxTimeSpan");
23914 }
23915 if (SWIG_arg_fail(2)) SWIG_fail;
23916 }
23917 {
23918 PyThreadState* __tstate = wxPyBeginAllowThreads();
23919 {
23920 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
23921 result = (wxDateTime *) &_result_ref;
23922 }
23923
23924 wxPyEndAllowThreads(__tstate);
23925 if (PyErr_Occurred()) SWIG_fail;
23926 }
23927 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
23928 return resultobj;
23929 fail:
23930 return NULL;
23931 }
23932
23933
23934 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
23935 PyObject *resultobj = NULL;
23936 wxDateTime *arg1 = (wxDateTime *) 0 ;
23937 wxDateSpan *arg2 = 0 ;
23938 wxDateTime *result;
23939 PyObject * obj0 = 0 ;
23940 PyObject * obj1 = 0 ;
23941
23942 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
23943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23944 if (SWIG_arg_fail(1)) SWIG_fail;
23945 {
23946 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23947 if (SWIG_arg_fail(2)) SWIG_fail;
23948 if (arg2 == NULL) {
23949 SWIG_null_ref("wxDateSpan");
23950 }
23951 if (SWIG_arg_fail(2)) SWIG_fail;
23952 }
23953 {
23954 PyThreadState* __tstate = wxPyBeginAllowThreads();
23955 {
23956 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
23957 result = (wxDateTime *) &_result_ref;
23958 }
23959
23960 wxPyEndAllowThreads(__tstate);
23961 if (PyErr_Occurred()) SWIG_fail;
23962 }
23963 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
23964 return resultobj;
23965 fail:
23966 return NULL;
23967 }
23968
23969
23970 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
23971 int argc;
23972 PyObject *argv[3];
23973 int ii;
23974
23975 argc = PyObject_Length(args);
23976 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23977 argv[ii] = PyTuple_GetItem(args,ii);
23978 }
23979 if (argc == 2) {
23980 int _v;
23981 {
23982 void *ptr;
23983 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23984 _v = 0;
23985 PyErr_Clear();
23986 } else {
23987 _v = 1;
23988 }
23989 }
23990 if (_v) {
23991 {
23992 void *ptr = 0;
23993 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23994 _v = 0;
23995 PyErr_Clear();
23996 } else {
23997 _v = (ptr != 0);
23998 }
23999 }
24000 if (_v) {
24001 return _wrap_DateTime___isub____SWIG_0(self,args);
24002 }
24003 }
24004 }
24005 if (argc == 2) {
24006 int _v;
24007 {
24008 void *ptr;
24009 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24010 _v = 0;
24011 PyErr_Clear();
24012 } else {
24013 _v = 1;
24014 }
24015 }
24016 if (_v) {
24017 {
24018 void *ptr = 0;
24019 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
24020 _v = 0;
24021 PyErr_Clear();
24022 } else {
24023 _v = (ptr != 0);
24024 }
24025 }
24026 if (_v) {
24027 return _wrap_DateTime___isub____SWIG_1(self,args);
24028 }
24029 }
24030 }
24031
24032 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
24033 return NULL;
24034 }
24035
24036
24037 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
24038 PyObject *resultobj = NULL;
24039 wxDateTime *arg1 = (wxDateTime *) 0 ;
24040 wxTimeSpan *arg2 = 0 ;
24041 wxDateTime result;
24042 PyObject * obj0 = 0 ;
24043 PyObject * obj1 = 0 ;
24044
24045 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
24046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24047 if (SWIG_arg_fail(1)) SWIG_fail;
24048 {
24049 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24050 if (SWIG_arg_fail(2)) SWIG_fail;
24051 if (arg2 == NULL) {
24052 SWIG_null_ref("wxTimeSpan");
24053 }
24054 if (SWIG_arg_fail(2)) SWIG_fail;
24055 }
24056 {
24057 PyThreadState* __tstate = wxPyBeginAllowThreads();
24058 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
24059
24060 wxPyEndAllowThreads(__tstate);
24061 if (PyErr_Occurred()) SWIG_fail;
24062 }
24063 {
24064 wxDateTime * resultptr;
24065 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
24066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
24067 }
24068 return resultobj;
24069 fail:
24070 return NULL;
24071 }
24072
24073
24074 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
24075 PyObject *resultobj = NULL;
24076 wxDateTime *arg1 = (wxDateTime *) 0 ;
24077 wxDateSpan *arg2 = 0 ;
24078 wxDateTime result;
24079 PyObject * obj0 = 0 ;
24080 PyObject * obj1 = 0 ;
24081
24082 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
24083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24084 if (SWIG_arg_fail(1)) SWIG_fail;
24085 {
24086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
24087 if (SWIG_arg_fail(2)) SWIG_fail;
24088 if (arg2 == NULL) {
24089 SWIG_null_ref("wxDateSpan");
24090 }
24091 if (SWIG_arg_fail(2)) SWIG_fail;
24092 }
24093 {
24094 PyThreadState* __tstate = wxPyBeginAllowThreads();
24095 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
24096
24097 wxPyEndAllowThreads(__tstate);
24098 if (PyErr_Occurred()) SWIG_fail;
24099 }
24100 {
24101 wxDateTime * resultptr;
24102 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
24103 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
24104 }
24105 return resultobj;
24106 fail:
24107 return NULL;
24108 }
24109
24110
24111 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
24112 int argc;
24113 PyObject *argv[3];
24114 int ii;
24115
24116 argc = PyObject_Length(args);
24117 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
24118 argv[ii] = PyTuple_GetItem(args,ii);
24119 }
24120 if (argc == 2) {
24121 int _v;
24122 {
24123 void *ptr;
24124 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24125 _v = 0;
24126 PyErr_Clear();
24127 } else {
24128 _v = 1;
24129 }
24130 }
24131 if (_v) {
24132 {
24133 void *ptr = 0;
24134 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
24135 _v = 0;
24136 PyErr_Clear();
24137 } else {
24138 _v = (ptr != 0);
24139 }
24140 }
24141 if (_v) {
24142 return _wrap_DateTime___add____SWIG_0(self,args);
24143 }
24144 }
24145 }
24146 if (argc == 2) {
24147 int _v;
24148 {
24149 void *ptr;
24150 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24151 _v = 0;
24152 PyErr_Clear();
24153 } else {
24154 _v = 1;
24155 }
24156 }
24157 if (_v) {
24158 {
24159 void *ptr = 0;
24160 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
24161 _v = 0;
24162 PyErr_Clear();
24163 } else {
24164 _v = (ptr != 0);
24165 }
24166 }
24167 if (_v) {
24168 return _wrap_DateTime___add____SWIG_1(self,args);
24169 }
24170 }
24171 }
24172
24173 Py_INCREF(Py_NotImplemented);
24174 return Py_NotImplemented;
24175 }
24176
24177
24178 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
24179 PyObject *resultobj = NULL;
24180 wxDateTime *arg1 = (wxDateTime *) 0 ;
24181 wxDateTime *arg2 = 0 ;
24182 wxTimeSpan result;
24183 PyObject * obj0 = 0 ;
24184 PyObject * obj1 = 0 ;
24185
24186 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
24187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24188 if (SWIG_arg_fail(1)) SWIG_fail;
24189 {
24190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24191 if (SWIG_arg_fail(2)) SWIG_fail;
24192 if (arg2 == NULL) {
24193 SWIG_null_ref("wxDateTime");
24194 }
24195 if (SWIG_arg_fail(2)) SWIG_fail;
24196 }
24197 {
24198 PyThreadState* __tstate = wxPyBeginAllowThreads();
24199 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
24200
24201 wxPyEndAllowThreads(__tstate);
24202 if (PyErr_Occurred()) SWIG_fail;
24203 }
24204 {
24205 wxTimeSpan * resultptr;
24206 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
24207 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24208 }
24209 return resultobj;
24210 fail:
24211 return NULL;
24212 }
24213
24214
24215 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
24216 PyObject *resultobj = NULL;
24217 wxDateTime *arg1 = (wxDateTime *) 0 ;
24218 wxTimeSpan *arg2 = 0 ;
24219 wxDateTime result;
24220 PyObject * obj0 = 0 ;
24221 PyObject * obj1 = 0 ;
24222
24223 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
24224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24225 if (SWIG_arg_fail(1)) SWIG_fail;
24226 {
24227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24228 if (SWIG_arg_fail(2)) SWIG_fail;
24229 if (arg2 == NULL) {
24230 SWIG_null_ref("wxTimeSpan");
24231 }
24232 if (SWIG_arg_fail(2)) SWIG_fail;
24233 }
24234 {
24235 PyThreadState* __tstate = wxPyBeginAllowThreads();
24236 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
24237
24238 wxPyEndAllowThreads(__tstate);
24239 if (PyErr_Occurred()) SWIG_fail;
24240 }
24241 {
24242 wxDateTime * resultptr;
24243 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
24244 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
24245 }
24246 return resultobj;
24247 fail:
24248 return NULL;
24249 }
24250
24251
24252 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
24253 PyObject *resultobj = NULL;
24254 wxDateTime *arg1 = (wxDateTime *) 0 ;
24255 wxDateSpan *arg2 = 0 ;
24256 wxDateTime result;
24257 PyObject * obj0 = 0 ;
24258 PyObject * obj1 = 0 ;
24259
24260 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
24261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24262 if (SWIG_arg_fail(1)) SWIG_fail;
24263 {
24264 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
24265 if (SWIG_arg_fail(2)) SWIG_fail;
24266 if (arg2 == NULL) {
24267 SWIG_null_ref("wxDateSpan");
24268 }
24269 if (SWIG_arg_fail(2)) SWIG_fail;
24270 }
24271 {
24272 PyThreadState* __tstate = wxPyBeginAllowThreads();
24273 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
24274
24275 wxPyEndAllowThreads(__tstate);
24276 if (PyErr_Occurred()) SWIG_fail;
24277 }
24278 {
24279 wxDateTime * resultptr;
24280 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
24281 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
24282 }
24283 return resultobj;
24284 fail:
24285 return NULL;
24286 }
24287
24288
24289 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
24290 int argc;
24291 PyObject *argv[3];
24292 int ii;
24293
24294 argc = PyObject_Length(args);
24295 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
24296 argv[ii] = PyTuple_GetItem(args,ii);
24297 }
24298 if (argc == 2) {
24299 int _v;
24300 {
24301 void *ptr;
24302 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24303 _v = 0;
24304 PyErr_Clear();
24305 } else {
24306 _v = 1;
24307 }
24308 }
24309 if (_v) {
24310 {
24311 void *ptr = 0;
24312 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24313 _v = 0;
24314 PyErr_Clear();
24315 } else {
24316 _v = (ptr != 0);
24317 }
24318 }
24319 if (_v) {
24320 return _wrap_DateTime___sub____SWIG_0(self,args);
24321 }
24322 }
24323 }
24324 if (argc == 2) {
24325 int _v;
24326 {
24327 void *ptr;
24328 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24329 _v = 0;
24330 PyErr_Clear();
24331 } else {
24332 _v = 1;
24333 }
24334 }
24335 if (_v) {
24336 {
24337 void *ptr = 0;
24338 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
24339 _v = 0;
24340 PyErr_Clear();
24341 } else {
24342 _v = (ptr != 0);
24343 }
24344 }
24345 if (_v) {
24346 return _wrap_DateTime___sub____SWIG_1(self,args);
24347 }
24348 }
24349 }
24350 if (argc == 2) {
24351 int _v;
24352 {
24353 void *ptr;
24354 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24355 _v = 0;
24356 PyErr_Clear();
24357 } else {
24358 _v = 1;
24359 }
24360 }
24361 if (_v) {
24362 {
24363 void *ptr = 0;
24364 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
24365 _v = 0;
24366 PyErr_Clear();
24367 } else {
24368 _v = (ptr != 0);
24369 }
24370 }
24371 if (_v) {
24372 return _wrap_DateTime___sub____SWIG_2(self,args);
24373 }
24374 }
24375 }
24376
24377 Py_INCREF(Py_NotImplemented);
24378 return Py_NotImplemented;
24379 }
24380
24381
24382 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24383 PyObject *resultobj = NULL;
24384 wxDateTime *arg1 = (wxDateTime *) 0 ;
24385 wxDateTime *arg2 = (wxDateTime *) 0 ;
24386 bool result;
24387 PyObject * obj0 = 0 ;
24388 PyObject * obj1 = 0 ;
24389 char *kwnames[] = {
24390 (char *) "self",(char *) "other", NULL
24391 };
24392
24393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
24394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24395 if (SWIG_arg_fail(1)) SWIG_fail;
24396 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24397 if (SWIG_arg_fail(2)) SWIG_fail;
24398 {
24399 PyThreadState* __tstate = wxPyBeginAllowThreads();
24400 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
24401
24402 wxPyEndAllowThreads(__tstate);
24403 if (PyErr_Occurred()) SWIG_fail;
24404 }
24405 {
24406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24407 }
24408 return resultobj;
24409 fail:
24410 return NULL;
24411 }
24412
24413
24414 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24415 PyObject *resultobj = NULL;
24416 wxDateTime *arg1 = (wxDateTime *) 0 ;
24417 wxDateTime *arg2 = (wxDateTime *) 0 ;
24418 bool result;
24419 PyObject * obj0 = 0 ;
24420 PyObject * obj1 = 0 ;
24421 char *kwnames[] = {
24422 (char *) "self",(char *) "other", NULL
24423 };
24424
24425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
24426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24427 if (SWIG_arg_fail(1)) SWIG_fail;
24428 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24429 if (SWIG_arg_fail(2)) SWIG_fail;
24430 {
24431 PyThreadState* __tstate = wxPyBeginAllowThreads();
24432 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
24433
24434 wxPyEndAllowThreads(__tstate);
24435 if (PyErr_Occurred()) SWIG_fail;
24436 }
24437 {
24438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24439 }
24440 return resultobj;
24441 fail:
24442 return NULL;
24443 }
24444
24445
24446 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24447 PyObject *resultobj = NULL;
24448 wxDateTime *arg1 = (wxDateTime *) 0 ;
24449 wxDateTime *arg2 = (wxDateTime *) 0 ;
24450 bool result;
24451 PyObject * obj0 = 0 ;
24452 PyObject * obj1 = 0 ;
24453 char *kwnames[] = {
24454 (char *) "self",(char *) "other", NULL
24455 };
24456
24457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
24458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24459 if (SWIG_arg_fail(1)) SWIG_fail;
24460 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24461 if (SWIG_arg_fail(2)) SWIG_fail;
24462 {
24463 PyThreadState* __tstate = wxPyBeginAllowThreads();
24464 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
24465
24466 wxPyEndAllowThreads(__tstate);
24467 if (PyErr_Occurred()) SWIG_fail;
24468 }
24469 {
24470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24471 }
24472 return resultobj;
24473 fail:
24474 return NULL;
24475 }
24476
24477
24478 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24479 PyObject *resultobj = NULL;
24480 wxDateTime *arg1 = (wxDateTime *) 0 ;
24481 wxDateTime *arg2 = (wxDateTime *) 0 ;
24482 bool result;
24483 PyObject * obj0 = 0 ;
24484 PyObject * obj1 = 0 ;
24485 char *kwnames[] = {
24486 (char *) "self",(char *) "other", NULL
24487 };
24488
24489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
24490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24491 if (SWIG_arg_fail(1)) SWIG_fail;
24492 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24493 if (SWIG_arg_fail(2)) SWIG_fail;
24494 {
24495 PyThreadState* __tstate = wxPyBeginAllowThreads();
24496 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
24497
24498 wxPyEndAllowThreads(__tstate);
24499 if (PyErr_Occurred()) SWIG_fail;
24500 }
24501 {
24502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24503 }
24504 return resultobj;
24505 fail:
24506 return NULL;
24507 }
24508
24509
24510 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24511 PyObject *resultobj = NULL;
24512 wxDateTime *arg1 = (wxDateTime *) 0 ;
24513 wxDateTime *arg2 = (wxDateTime *) 0 ;
24514 bool result;
24515 PyObject * obj0 = 0 ;
24516 PyObject * obj1 = 0 ;
24517 char *kwnames[] = {
24518 (char *) "self",(char *) "other", NULL
24519 };
24520
24521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
24522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24523 if (SWIG_arg_fail(1)) SWIG_fail;
24524 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24525 if (SWIG_arg_fail(2)) SWIG_fail;
24526 {
24527 PyThreadState* __tstate = wxPyBeginAllowThreads();
24528 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
24529
24530 wxPyEndAllowThreads(__tstate);
24531 if (PyErr_Occurred()) SWIG_fail;
24532 }
24533 {
24534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24535 }
24536 return resultobj;
24537 fail:
24538 return NULL;
24539 }
24540
24541
24542 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24543 PyObject *resultobj = NULL;
24544 wxDateTime *arg1 = (wxDateTime *) 0 ;
24545 wxDateTime *arg2 = (wxDateTime *) 0 ;
24546 bool result;
24547 PyObject * obj0 = 0 ;
24548 PyObject * obj1 = 0 ;
24549 char *kwnames[] = {
24550 (char *) "self",(char *) "other", NULL
24551 };
24552
24553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
24554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24555 if (SWIG_arg_fail(1)) SWIG_fail;
24556 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24557 if (SWIG_arg_fail(2)) SWIG_fail;
24558 {
24559 PyThreadState* __tstate = wxPyBeginAllowThreads();
24560 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
24561
24562 wxPyEndAllowThreads(__tstate);
24563 if (PyErr_Occurred()) SWIG_fail;
24564 }
24565 {
24566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24567 }
24568 return resultobj;
24569 fail:
24570 return NULL;
24571 }
24572
24573
24574 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
24575 PyObject *resultobj = NULL;
24576 wxDateTime *arg1 = (wxDateTime *) 0 ;
24577 wxString *arg2 = 0 ;
24578 int result;
24579 bool temp2 = false ;
24580 PyObject * obj0 = 0 ;
24581 PyObject * obj1 = 0 ;
24582 char *kwnames[] = {
24583 (char *) "self",(char *) "date", NULL
24584 };
24585
24586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
24587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24588 if (SWIG_arg_fail(1)) SWIG_fail;
24589 {
24590 arg2 = wxString_in_helper(obj1);
24591 if (arg2 == NULL) SWIG_fail;
24592 temp2 = true;
24593 }
24594 {
24595 PyThreadState* __tstate = wxPyBeginAllowThreads();
24596 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
24597
24598 wxPyEndAllowThreads(__tstate);
24599 if (PyErr_Occurred()) SWIG_fail;
24600 }
24601 {
24602 resultobj = SWIG_From_int(static_cast<int >(result));
24603 }
24604 {
24605 if (temp2)
24606 delete arg2;
24607 }
24608 return resultobj;
24609 fail:
24610 {
24611 if (temp2)
24612 delete arg2;
24613 }
24614 return NULL;
24615 }
24616
24617
24618 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
24619 PyObject *resultobj = NULL;
24620 wxDateTime *arg1 = (wxDateTime *) 0 ;
24621 wxString *arg2 = 0 ;
24622 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
24623 wxString *arg3 = (wxString *) &arg3_defvalue ;
24624 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
24625 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
24626 int result;
24627 bool temp2 = false ;
24628 bool temp3 = false ;
24629 PyObject * obj0 = 0 ;
24630 PyObject * obj1 = 0 ;
24631 PyObject * obj2 = 0 ;
24632 PyObject * obj3 = 0 ;
24633 char *kwnames[] = {
24634 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
24635 };
24636
24637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24639 if (SWIG_arg_fail(1)) SWIG_fail;
24640 {
24641 arg2 = wxString_in_helper(obj1);
24642 if (arg2 == NULL) SWIG_fail;
24643 temp2 = true;
24644 }
24645 if (obj2) {
24646 {
24647 arg3 = wxString_in_helper(obj2);
24648 if (arg3 == NULL) SWIG_fail;
24649 temp3 = true;
24650 }
24651 }
24652 if (obj3) {
24653 {
24654 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24655 if (SWIG_arg_fail(4)) SWIG_fail;
24656 if (arg4 == NULL) {
24657 SWIG_null_ref("wxDateTime");
24658 }
24659 if (SWIG_arg_fail(4)) SWIG_fail;
24660 }
24661 }
24662 {
24663 PyThreadState* __tstate = wxPyBeginAllowThreads();
24664 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
24665
24666 wxPyEndAllowThreads(__tstate);
24667 if (PyErr_Occurred()) SWIG_fail;
24668 }
24669 {
24670 resultobj = SWIG_From_int(static_cast<int >(result));
24671 }
24672 {
24673 if (temp2)
24674 delete arg2;
24675 }
24676 {
24677 if (temp3)
24678 delete arg3;
24679 }
24680 return resultobj;
24681 fail:
24682 {
24683 if (temp2)
24684 delete arg2;
24685 }
24686 {
24687 if (temp3)
24688 delete arg3;
24689 }
24690 return NULL;
24691 }
24692
24693
24694 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
24695 PyObject *resultobj = NULL;
24696 wxDateTime *arg1 = (wxDateTime *) 0 ;
24697 wxString *arg2 = 0 ;
24698 int result;
24699 bool temp2 = false ;
24700 PyObject * obj0 = 0 ;
24701 PyObject * obj1 = 0 ;
24702 char *kwnames[] = {
24703 (char *) "self",(char *) "datetime", NULL
24704 };
24705
24706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
24707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24708 if (SWIG_arg_fail(1)) SWIG_fail;
24709 {
24710 arg2 = wxString_in_helper(obj1);
24711 if (arg2 == NULL) SWIG_fail;
24712 temp2 = true;
24713 }
24714 {
24715 PyThreadState* __tstate = wxPyBeginAllowThreads();
24716 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
24717
24718 wxPyEndAllowThreads(__tstate);
24719 if (PyErr_Occurred()) SWIG_fail;
24720 }
24721 {
24722 resultobj = SWIG_From_int(static_cast<int >(result));
24723 }
24724 {
24725 if (temp2)
24726 delete arg2;
24727 }
24728 return resultobj;
24729 fail:
24730 {
24731 if (temp2)
24732 delete arg2;
24733 }
24734 return NULL;
24735 }
24736
24737
24738 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
24739 PyObject *resultobj = NULL;
24740 wxDateTime *arg1 = (wxDateTime *) 0 ;
24741 wxString *arg2 = 0 ;
24742 int result;
24743 bool temp2 = false ;
24744 PyObject * obj0 = 0 ;
24745 PyObject * obj1 = 0 ;
24746 char *kwnames[] = {
24747 (char *) "self",(char *) "date", NULL
24748 };
24749
24750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
24751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24752 if (SWIG_arg_fail(1)) SWIG_fail;
24753 {
24754 arg2 = wxString_in_helper(obj1);
24755 if (arg2 == NULL) SWIG_fail;
24756 temp2 = true;
24757 }
24758 {
24759 PyThreadState* __tstate = wxPyBeginAllowThreads();
24760 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
24761
24762 wxPyEndAllowThreads(__tstate);
24763 if (PyErr_Occurred()) SWIG_fail;
24764 }
24765 {
24766 resultobj = SWIG_From_int(static_cast<int >(result));
24767 }
24768 {
24769 if (temp2)
24770 delete arg2;
24771 }
24772 return resultobj;
24773 fail:
24774 {
24775 if (temp2)
24776 delete arg2;
24777 }
24778 return NULL;
24779 }
24780
24781
24782 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
24783 PyObject *resultobj = NULL;
24784 wxDateTime *arg1 = (wxDateTime *) 0 ;
24785 wxString *arg2 = 0 ;
24786 int result;
24787 bool temp2 = false ;
24788 PyObject * obj0 = 0 ;
24789 PyObject * obj1 = 0 ;
24790 char *kwnames[] = {
24791 (char *) "self",(char *) "time", NULL
24792 };
24793
24794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
24795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24796 if (SWIG_arg_fail(1)) SWIG_fail;
24797 {
24798 arg2 = wxString_in_helper(obj1);
24799 if (arg2 == NULL) SWIG_fail;
24800 temp2 = true;
24801 }
24802 {
24803 PyThreadState* __tstate = wxPyBeginAllowThreads();
24804 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
24805
24806 wxPyEndAllowThreads(__tstate);
24807 if (PyErr_Occurred()) SWIG_fail;
24808 }
24809 {
24810 resultobj = SWIG_From_int(static_cast<int >(result));
24811 }
24812 {
24813 if (temp2)
24814 delete arg2;
24815 }
24816 return resultobj;
24817 fail:
24818 {
24819 if (temp2)
24820 delete arg2;
24821 }
24822 return NULL;
24823 }
24824
24825
24826 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
24827 PyObject *resultobj = NULL;
24828 wxDateTime *arg1 = (wxDateTime *) 0 ;
24829 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
24830 wxString *arg2 = (wxString *) &arg2_defvalue ;
24831 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
24832 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
24833 wxString result;
24834 bool temp2 = false ;
24835 bool temp3 = false ;
24836 PyObject * obj0 = 0 ;
24837 PyObject * obj1 = 0 ;
24838 PyObject * obj2 = 0 ;
24839 char *kwnames[] = {
24840 (char *) "self",(char *) "format",(char *) "tz", NULL
24841 };
24842
24843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
24844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24845 if (SWIG_arg_fail(1)) SWIG_fail;
24846 if (obj1) {
24847 {
24848 arg2 = wxString_in_helper(obj1);
24849 if (arg2 == NULL) SWIG_fail;
24850 temp2 = true;
24851 }
24852 }
24853 if (obj2) {
24854 {
24855 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
24856 temp3 = true;
24857 }
24858 }
24859 {
24860 PyThreadState* __tstate = wxPyBeginAllowThreads();
24861 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
24862
24863 wxPyEndAllowThreads(__tstate);
24864 if (PyErr_Occurred()) SWIG_fail;
24865 }
24866 {
24867 #if wxUSE_UNICODE
24868 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24869 #else
24870 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24871 #endif
24872 }
24873 {
24874 if (temp2)
24875 delete arg2;
24876 }
24877 {
24878 if (temp3) delete arg3;
24879 }
24880 return resultobj;
24881 fail:
24882 {
24883 if (temp2)
24884 delete arg2;
24885 }
24886 {
24887 if (temp3) delete arg3;
24888 }
24889 return NULL;
24890 }
24891
24892
24893 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
24894 PyObject *resultobj = NULL;
24895 wxDateTime *arg1 = (wxDateTime *) 0 ;
24896 wxString result;
24897 PyObject * obj0 = 0 ;
24898 char *kwnames[] = {
24899 (char *) "self", NULL
24900 };
24901
24902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
24903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24904 if (SWIG_arg_fail(1)) SWIG_fail;
24905 {
24906 PyThreadState* __tstate = wxPyBeginAllowThreads();
24907 result = ((wxDateTime const *)arg1)->FormatDate();
24908
24909 wxPyEndAllowThreads(__tstate);
24910 if (PyErr_Occurred()) SWIG_fail;
24911 }
24912 {
24913 #if wxUSE_UNICODE
24914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24915 #else
24916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24917 #endif
24918 }
24919 return resultobj;
24920 fail:
24921 return NULL;
24922 }
24923
24924
24925 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
24926 PyObject *resultobj = NULL;
24927 wxDateTime *arg1 = (wxDateTime *) 0 ;
24928 wxString result;
24929 PyObject * obj0 = 0 ;
24930 char *kwnames[] = {
24931 (char *) "self", NULL
24932 };
24933
24934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
24935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24936 if (SWIG_arg_fail(1)) SWIG_fail;
24937 {
24938 PyThreadState* __tstate = wxPyBeginAllowThreads();
24939 result = ((wxDateTime const *)arg1)->FormatTime();
24940
24941 wxPyEndAllowThreads(__tstate);
24942 if (PyErr_Occurred()) SWIG_fail;
24943 }
24944 {
24945 #if wxUSE_UNICODE
24946 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24947 #else
24948 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24949 #endif
24950 }
24951 return resultobj;
24952 fail:
24953 return NULL;
24954 }
24955
24956
24957 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
24958 PyObject *resultobj = NULL;
24959 wxDateTime *arg1 = (wxDateTime *) 0 ;
24960 wxString result;
24961 PyObject * obj0 = 0 ;
24962 char *kwnames[] = {
24963 (char *) "self", NULL
24964 };
24965
24966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
24967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24968 if (SWIG_arg_fail(1)) SWIG_fail;
24969 {
24970 PyThreadState* __tstate = wxPyBeginAllowThreads();
24971 result = ((wxDateTime const *)arg1)->FormatISODate();
24972
24973 wxPyEndAllowThreads(__tstate);
24974 if (PyErr_Occurred()) SWIG_fail;
24975 }
24976 {
24977 #if wxUSE_UNICODE
24978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24979 #else
24980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24981 #endif
24982 }
24983 return resultobj;
24984 fail:
24985 return NULL;
24986 }
24987
24988
24989 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
24990 PyObject *resultobj = NULL;
24991 wxDateTime *arg1 = (wxDateTime *) 0 ;
24992 wxString result;
24993 PyObject * obj0 = 0 ;
24994 char *kwnames[] = {
24995 (char *) "self", NULL
24996 };
24997
24998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
24999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
25000 if (SWIG_arg_fail(1)) SWIG_fail;
25001 {
25002 PyThreadState* __tstate = wxPyBeginAllowThreads();
25003 result = ((wxDateTime const *)arg1)->FormatISOTime();
25004
25005 wxPyEndAllowThreads(__tstate);
25006 if (PyErr_Occurred()) SWIG_fail;
25007 }
25008 {
25009 #if wxUSE_UNICODE
25010 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25011 #else
25012 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25013 #endif
25014 }
25015 return resultobj;
25016 fail:
25017 return NULL;
25018 }
25019
25020
25021 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
25022 PyObject *obj;
25023 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25024 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
25025 Py_INCREF(obj);
25026 return Py_BuildValue((char *)"");
25027 }
25028 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
25029 PyObject *resultobj = NULL;
25030 long arg1 ;
25031 wxTimeSpan result;
25032 PyObject * obj0 = 0 ;
25033 char *kwnames[] = {
25034 (char *) "sec", NULL
25035 };
25036
25037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
25038 {
25039 arg1 = static_cast<long >(SWIG_As_long(obj0));
25040 if (SWIG_arg_fail(1)) SWIG_fail;
25041 }
25042 {
25043 PyThreadState* __tstate = wxPyBeginAllowThreads();
25044 result = wxTimeSpan::Seconds(arg1);
25045
25046 wxPyEndAllowThreads(__tstate);
25047 if (PyErr_Occurred()) SWIG_fail;
25048 }
25049 {
25050 wxTimeSpan * resultptr;
25051 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25052 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25053 }
25054 return resultobj;
25055 fail:
25056 return NULL;
25057 }
25058
25059
25060 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
25061 PyObject *resultobj = NULL;
25062 wxTimeSpan result;
25063 char *kwnames[] = {
25064 NULL
25065 };
25066
25067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
25068 {
25069 PyThreadState* __tstate = wxPyBeginAllowThreads();
25070 result = wxTimeSpan::Second();
25071
25072 wxPyEndAllowThreads(__tstate);
25073 if (PyErr_Occurred()) SWIG_fail;
25074 }
25075 {
25076 wxTimeSpan * resultptr;
25077 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25078 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25079 }
25080 return resultobj;
25081 fail:
25082 return NULL;
25083 }
25084
25085
25086 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
25087 PyObject *resultobj = NULL;
25088 long arg1 ;
25089 wxTimeSpan result;
25090 PyObject * obj0 = 0 ;
25091 char *kwnames[] = {
25092 (char *) "min", NULL
25093 };
25094
25095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
25096 {
25097 arg1 = static_cast<long >(SWIG_As_long(obj0));
25098 if (SWIG_arg_fail(1)) SWIG_fail;
25099 }
25100 {
25101 PyThreadState* __tstate = wxPyBeginAllowThreads();
25102 result = wxTimeSpan::Minutes(arg1);
25103
25104 wxPyEndAllowThreads(__tstate);
25105 if (PyErr_Occurred()) SWIG_fail;
25106 }
25107 {
25108 wxTimeSpan * resultptr;
25109 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25110 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25111 }
25112 return resultobj;
25113 fail:
25114 return NULL;
25115 }
25116
25117
25118 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
25119 PyObject *resultobj = NULL;
25120 wxTimeSpan result;
25121 char *kwnames[] = {
25122 NULL
25123 };
25124
25125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
25126 {
25127 PyThreadState* __tstate = wxPyBeginAllowThreads();
25128 result = wxTimeSpan::Minute();
25129
25130 wxPyEndAllowThreads(__tstate);
25131 if (PyErr_Occurred()) SWIG_fail;
25132 }
25133 {
25134 wxTimeSpan * resultptr;
25135 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25136 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25137 }
25138 return resultobj;
25139 fail:
25140 return NULL;
25141 }
25142
25143
25144 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
25145 PyObject *resultobj = NULL;
25146 long arg1 ;
25147 wxTimeSpan result;
25148 PyObject * obj0 = 0 ;
25149 char *kwnames[] = {
25150 (char *) "hours", NULL
25151 };
25152
25153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
25154 {
25155 arg1 = static_cast<long >(SWIG_As_long(obj0));
25156 if (SWIG_arg_fail(1)) SWIG_fail;
25157 }
25158 {
25159 PyThreadState* __tstate = wxPyBeginAllowThreads();
25160 result = wxTimeSpan::Hours(arg1);
25161
25162 wxPyEndAllowThreads(__tstate);
25163 if (PyErr_Occurred()) SWIG_fail;
25164 }
25165 {
25166 wxTimeSpan * resultptr;
25167 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25168 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25169 }
25170 return resultobj;
25171 fail:
25172 return NULL;
25173 }
25174
25175
25176 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
25177 PyObject *resultobj = NULL;
25178 wxTimeSpan result;
25179 char *kwnames[] = {
25180 NULL
25181 };
25182
25183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
25184 {
25185 PyThreadState* __tstate = wxPyBeginAllowThreads();
25186 result = wxTimeSpan::Hour();
25187
25188 wxPyEndAllowThreads(__tstate);
25189 if (PyErr_Occurred()) SWIG_fail;
25190 }
25191 {
25192 wxTimeSpan * resultptr;
25193 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25194 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25195 }
25196 return resultobj;
25197 fail:
25198 return NULL;
25199 }
25200
25201
25202 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25203 PyObject *resultobj = NULL;
25204 long arg1 ;
25205 wxTimeSpan result;
25206 PyObject * obj0 = 0 ;
25207 char *kwnames[] = {
25208 (char *) "days", NULL
25209 };
25210
25211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
25212 {
25213 arg1 = static_cast<long >(SWIG_As_long(obj0));
25214 if (SWIG_arg_fail(1)) SWIG_fail;
25215 }
25216 {
25217 PyThreadState* __tstate = wxPyBeginAllowThreads();
25218 result = wxTimeSpan::Days(arg1);
25219
25220 wxPyEndAllowThreads(__tstate);
25221 if (PyErr_Occurred()) SWIG_fail;
25222 }
25223 {
25224 wxTimeSpan * resultptr;
25225 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25226 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25227 }
25228 return resultobj;
25229 fail:
25230 return NULL;
25231 }
25232
25233
25234 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25235 PyObject *resultobj = NULL;
25236 wxTimeSpan result;
25237 char *kwnames[] = {
25238 NULL
25239 };
25240
25241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
25242 {
25243 PyThreadState* __tstate = wxPyBeginAllowThreads();
25244 result = wxTimeSpan::Day();
25245
25246 wxPyEndAllowThreads(__tstate);
25247 if (PyErr_Occurred()) SWIG_fail;
25248 }
25249 {
25250 wxTimeSpan * resultptr;
25251 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25252 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25253 }
25254 return resultobj;
25255 fail:
25256 return NULL;
25257 }
25258
25259
25260 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25261 PyObject *resultobj = NULL;
25262 long arg1 ;
25263 wxTimeSpan result;
25264 PyObject * obj0 = 0 ;
25265 char *kwnames[] = {
25266 (char *) "days", NULL
25267 };
25268
25269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
25270 {
25271 arg1 = static_cast<long >(SWIG_As_long(obj0));
25272 if (SWIG_arg_fail(1)) SWIG_fail;
25273 }
25274 {
25275 PyThreadState* __tstate = wxPyBeginAllowThreads();
25276 result = wxTimeSpan::Weeks(arg1);
25277
25278 wxPyEndAllowThreads(__tstate);
25279 if (PyErr_Occurred()) SWIG_fail;
25280 }
25281 {
25282 wxTimeSpan * resultptr;
25283 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25284 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25285 }
25286 return resultobj;
25287 fail:
25288 return NULL;
25289 }
25290
25291
25292 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25293 PyObject *resultobj = NULL;
25294 wxTimeSpan result;
25295 char *kwnames[] = {
25296 NULL
25297 };
25298
25299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
25300 {
25301 PyThreadState* __tstate = wxPyBeginAllowThreads();
25302 result = wxTimeSpan::Week();
25303
25304 wxPyEndAllowThreads(__tstate);
25305 if (PyErr_Occurred()) SWIG_fail;
25306 }
25307 {
25308 wxTimeSpan * resultptr;
25309 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25310 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25311 }
25312 return resultobj;
25313 fail:
25314 return NULL;
25315 }
25316
25317
25318 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25319 PyObject *resultobj = NULL;
25320 long arg1 = (long) 0 ;
25321 long arg2 = (long) 0 ;
25322 long arg3 = (long) 0 ;
25323 long arg4 = (long) 0 ;
25324 wxTimeSpan *result;
25325 PyObject * obj0 = 0 ;
25326 PyObject * obj1 = 0 ;
25327 PyObject * obj2 = 0 ;
25328 PyObject * obj3 = 0 ;
25329 char *kwnames[] = {
25330 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
25331 };
25332
25333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25334 if (obj0) {
25335 {
25336 arg1 = static_cast<long >(SWIG_As_long(obj0));
25337 if (SWIG_arg_fail(1)) SWIG_fail;
25338 }
25339 }
25340 if (obj1) {
25341 {
25342 arg2 = static_cast<long >(SWIG_As_long(obj1));
25343 if (SWIG_arg_fail(2)) SWIG_fail;
25344 }
25345 }
25346 if (obj2) {
25347 {
25348 arg3 = static_cast<long >(SWIG_As_long(obj2));
25349 if (SWIG_arg_fail(3)) SWIG_fail;
25350 }
25351 }
25352 if (obj3) {
25353 {
25354 arg4 = static_cast<long >(SWIG_As_long(obj3));
25355 if (SWIG_arg_fail(4)) SWIG_fail;
25356 }
25357 }
25358 {
25359 PyThreadState* __tstate = wxPyBeginAllowThreads();
25360 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
25361
25362 wxPyEndAllowThreads(__tstate);
25363 if (PyErr_Occurred()) SWIG_fail;
25364 }
25365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
25366 return resultobj;
25367 fail:
25368 return NULL;
25369 }
25370
25371
25372 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25373 PyObject *resultobj = NULL;
25374 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25375 PyObject * obj0 = 0 ;
25376 char *kwnames[] = {
25377 (char *) "self", NULL
25378 };
25379
25380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
25381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25382 if (SWIG_arg_fail(1)) SWIG_fail;
25383 {
25384 PyThreadState* __tstate = wxPyBeginAllowThreads();
25385 delete arg1;
25386
25387 wxPyEndAllowThreads(__tstate);
25388 if (PyErr_Occurred()) SWIG_fail;
25389 }
25390 Py_INCREF(Py_None); resultobj = Py_None;
25391 return resultobj;
25392 fail:
25393 return NULL;
25394 }
25395
25396
25397 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25398 PyObject *resultobj = NULL;
25399 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25400 wxTimeSpan *arg2 = 0 ;
25401 wxTimeSpan *result;
25402 PyObject * obj0 = 0 ;
25403 PyObject * obj1 = 0 ;
25404 char *kwnames[] = {
25405 (char *) "self",(char *) "diff", NULL
25406 };
25407
25408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25410 if (SWIG_arg_fail(1)) SWIG_fail;
25411 {
25412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25413 if (SWIG_arg_fail(2)) SWIG_fail;
25414 if (arg2 == NULL) {
25415 SWIG_null_ref("wxTimeSpan");
25416 }
25417 if (SWIG_arg_fail(2)) SWIG_fail;
25418 }
25419 {
25420 PyThreadState* __tstate = wxPyBeginAllowThreads();
25421 {
25422 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25423 result = (wxTimeSpan *) &_result_ref;
25424 }
25425
25426 wxPyEndAllowThreads(__tstate);
25427 if (PyErr_Occurred()) SWIG_fail;
25428 }
25429 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25430 return resultobj;
25431 fail:
25432 return NULL;
25433 }
25434
25435
25436 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25437 PyObject *resultobj = NULL;
25438 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25439 wxTimeSpan *arg2 = 0 ;
25440 wxTimeSpan *result;
25441 PyObject * obj0 = 0 ;
25442 PyObject * obj1 = 0 ;
25443 char *kwnames[] = {
25444 (char *) "self",(char *) "diff", NULL
25445 };
25446
25447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25449 if (SWIG_arg_fail(1)) SWIG_fail;
25450 {
25451 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25452 if (SWIG_arg_fail(2)) SWIG_fail;
25453 if (arg2 == NULL) {
25454 SWIG_null_ref("wxTimeSpan");
25455 }
25456 if (SWIG_arg_fail(2)) SWIG_fail;
25457 }
25458 {
25459 PyThreadState* __tstate = wxPyBeginAllowThreads();
25460 {
25461 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
25462 result = (wxTimeSpan *) &_result_ref;
25463 }
25464
25465 wxPyEndAllowThreads(__tstate);
25466 if (PyErr_Occurred()) SWIG_fail;
25467 }
25468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25469 return resultobj;
25470 fail:
25471 return NULL;
25472 }
25473
25474
25475 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25476 PyObject *resultobj = NULL;
25477 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25478 int arg2 ;
25479 wxTimeSpan *result;
25480 PyObject * obj0 = 0 ;
25481 PyObject * obj1 = 0 ;
25482 char *kwnames[] = {
25483 (char *) "self",(char *) "n", NULL
25484 };
25485
25486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25488 if (SWIG_arg_fail(1)) SWIG_fail;
25489 {
25490 arg2 = static_cast<int >(SWIG_As_int(obj1));
25491 if (SWIG_arg_fail(2)) SWIG_fail;
25492 }
25493 {
25494 PyThreadState* __tstate = wxPyBeginAllowThreads();
25495 {
25496 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
25497 result = (wxTimeSpan *) &_result_ref;
25498 }
25499
25500 wxPyEndAllowThreads(__tstate);
25501 if (PyErr_Occurred()) SWIG_fail;
25502 }
25503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25504 return resultobj;
25505 fail:
25506 return NULL;
25507 }
25508
25509
25510 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25511 PyObject *resultobj = NULL;
25512 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25513 wxTimeSpan *result;
25514 PyObject * obj0 = 0 ;
25515 char *kwnames[] = {
25516 (char *) "self", NULL
25517 };
25518
25519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
25520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25521 if (SWIG_arg_fail(1)) SWIG_fail;
25522 {
25523 PyThreadState* __tstate = wxPyBeginAllowThreads();
25524 {
25525 wxTimeSpan &_result_ref = (arg1)->Neg();
25526 result = (wxTimeSpan *) &_result_ref;
25527 }
25528
25529 wxPyEndAllowThreads(__tstate);
25530 if (PyErr_Occurred()) SWIG_fail;
25531 }
25532 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25533 return resultobj;
25534 fail:
25535 return NULL;
25536 }
25537
25538
25539 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
25540 PyObject *resultobj = NULL;
25541 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25542 wxTimeSpan result;
25543 PyObject * obj0 = 0 ;
25544 char *kwnames[] = {
25545 (char *) "self", NULL
25546 };
25547
25548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
25549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25550 if (SWIG_arg_fail(1)) SWIG_fail;
25551 {
25552 PyThreadState* __tstate = wxPyBeginAllowThreads();
25553 result = ((wxTimeSpan const *)arg1)->Abs();
25554
25555 wxPyEndAllowThreads(__tstate);
25556 if (PyErr_Occurred()) SWIG_fail;
25557 }
25558 {
25559 wxTimeSpan * resultptr;
25560 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25561 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25562 }
25563 return resultobj;
25564 fail:
25565 return NULL;
25566 }
25567
25568
25569 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25570 PyObject *resultobj = NULL;
25571 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25572 wxTimeSpan *arg2 = 0 ;
25573 wxTimeSpan *result;
25574 PyObject * obj0 = 0 ;
25575 PyObject * obj1 = 0 ;
25576 char *kwnames[] = {
25577 (char *) "self",(char *) "diff", NULL
25578 };
25579
25580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25582 if (SWIG_arg_fail(1)) SWIG_fail;
25583 {
25584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25585 if (SWIG_arg_fail(2)) SWIG_fail;
25586 if (arg2 == NULL) {
25587 SWIG_null_ref("wxTimeSpan");
25588 }
25589 if (SWIG_arg_fail(2)) SWIG_fail;
25590 }
25591 {
25592 PyThreadState* __tstate = wxPyBeginAllowThreads();
25593 {
25594 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
25595 result = (wxTimeSpan *) &_result_ref;
25596 }
25597
25598 wxPyEndAllowThreads(__tstate);
25599 if (PyErr_Occurred()) SWIG_fail;
25600 }
25601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
25602 return resultobj;
25603 fail:
25604 return NULL;
25605 }
25606
25607
25608 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25609 PyObject *resultobj = NULL;
25610 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25611 wxTimeSpan *arg2 = 0 ;
25612 wxTimeSpan *result;
25613 PyObject * obj0 = 0 ;
25614 PyObject * obj1 = 0 ;
25615 char *kwnames[] = {
25616 (char *) "self",(char *) "diff", NULL
25617 };
25618
25619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25621 if (SWIG_arg_fail(1)) SWIG_fail;
25622 {
25623 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25624 if (SWIG_arg_fail(2)) SWIG_fail;
25625 if (arg2 == NULL) {
25626 SWIG_null_ref("wxTimeSpan");
25627 }
25628 if (SWIG_arg_fail(2)) SWIG_fail;
25629 }
25630 {
25631 PyThreadState* __tstate = wxPyBeginAllowThreads();
25632 {
25633 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
25634 result = (wxTimeSpan *) &_result_ref;
25635 }
25636
25637 wxPyEndAllowThreads(__tstate);
25638 if (PyErr_Occurred()) SWIG_fail;
25639 }
25640 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
25641 return resultobj;
25642 fail:
25643 return NULL;
25644 }
25645
25646
25647 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
25648 PyObject *resultobj = NULL;
25649 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25650 int arg2 ;
25651 wxTimeSpan *result;
25652 PyObject * obj0 = 0 ;
25653 PyObject * obj1 = 0 ;
25654 char *kwnames[] = {
25655 (char *) "self",(char *) "n", NULL
25656 };
25657
25658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
25659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25660 if (SWIG_arg_fail(1)) SWIG_fail;
25661 {
25662 arg2 = static_cast<int >(SWIG_As_int(obj1));
25663 if (SWIG_arg_fail(2)) SWIG_fail;
25664 }
25665 {
25666 PyThreadState* __tstate = wxPyBeginAllowThreads();
25667 {
25668 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
25669 result = (wxTimeSpan *) &_result_ref;
25670 }
25671
25672 wxPyEndAllowThreads(__tstate);
25673 if (PyErr_Occurred()) SWIG_fail;
25674 }
25675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
25676 return resultobj;
25677 fail:
25678 return NULL;
25679 }
25680
25681
25682 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25683 PyObject *resultobj = NULL;
25684 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25685 wxTimeSpan *result;
25686 PyObject * obj0 = 0 ;
25687 char *kwnames[] = {
25688 (char *) "self", NULL
25689 };
25690
25691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
25692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25693 if (SWIG_arg_fail(1)) SWIG_fail;
25694 {
25695 PyThreadState* __tstate = wxPyBeginAllowThreads();
25696 {
25697 wxTimeSpan &_result_ref = (arg1)->operator -();
25698 result = (wxTimeSpan *) &_result_ref;
25699 }
25700
25701 wxPyEndAllowThreads(__tstate);
25702 if (PyErr_Occurred()) SWIG_fail;
25703 }
25704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25705 return resultobj;
25706 fail:
25707 return NULL;
25708 }
25709
25710
25711 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
25712 PyObject *resultobj = NULL;
25713 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25714 wxTimeSpan *arg2 = 0 ;
25715 wxTimeSpan result;
25716 PyObject * obj0 = 0 ;
25717 PyObject * obj1 = 0 ;
25718 char *kwnames[] = {
25719 (char *) "self",(char *) "other", NULL
25720 };
25721
25722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
25723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25724 if (SWIG_arg_fail(1)) SWIG_fail;
25725 {
25726 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25727 if (SWIG_arg_fail(2)) SWIG_fail;
25728 if (arg2 == NULL) {
25729 SWIG_null_ref("wxTimeSpan");
25730 }
25731 if (SWIG_arg_fail(2)) SWIG_fail;
25732 }
25733 {
25734 PyThreadState* __tstate = wxPyBeginAllowThreads();
25735 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
25736
25737 wxPyEndAllowThreads(__tstate);
25738 if (PyErr_Occurred()) SWIG_fail;
25739 }
25740 {
25741 wxTimeSpan * resultptr;
25742 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25743 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25744 }
25745 return resultobj;
25746 fail:
25747 return NULL;
25748 }
25749
25750
25751 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
25752 PyObject *resultobj = NULL;
25753 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25754 wxTimeSpan *arg2 = 0 ;
25755 wxTimeSpan result;
25756 PyObject * obj0 = 0 ;
25757 PyObject * obj1 = 0 ;
25758 char *kwnames[] = {
25759 (char *) "self",(char *) "other", NULL
25760 };
25761
25762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
25763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25764 if (SWIG_arg_fail(1)) SWIG_fail;
25765 {
25766 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25767 if (SWIG_arg_fail(2)) SWIG_fail;
25768 if (arg2 == NULL) {
25769 SWIG_null_ref("wxTimeSpan");
25770 }
25771 if (SWIG_arg_fail(2)) SWIG_fail;
25772 }
25773 {
25774 PyThreadState* __tstate = wxPyBeginAllowThreads();
25775 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
25776
25777 wxPyEndAllowThreads(__tstate);
25778 if (PyErr_Occurred()) SWIG_fail;
25779 }
25780 {
25781 wxTimeSpan * resultptr;
25782 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25783 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25784 }
25785 return resultobj;
25786 fail:
25787 return NULL;
25788 }
25789
25790
25791 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
25792 PyObject *resultobj = NULL;
25793 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25794 int arg2 ;
25795 wxTimeSpan result;
25796 PyObject * obj0 = 0 ;
25797 PyObject * obj1 = 0 ;
25798 char *kwnames[] = {
25799 (char *) "self",(char *) "n", NULL
25800 };
25801
25802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
25803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25804 if (SWIG_arg_fail(1)) SWIG_fail;
25805 {
25806 arg2 = static_cast<int >(SWIG_As_int(obj1));
25807 if (SWIG_arg_fail(2)) SWIG_fail;
25808 }
25809 {
25810 PyThreadState* __tstate = wxPyBeginAllowThreads();
25811 result = wxTimeSpan___mul__(arg1,arg2);
25812
25813 wxPyEndAllowThreads(__tstate);
25814 if (PyErr_Occurred()) SWIG_fail;
25815 }
25816 {
25817 wxTimeSpan * resultptr;
25818 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25819 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25820 }
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
25828 PyObject *resultobj = NULL;
25829 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25830 int arg2 ;
25831 wxTimeSpan result;
25832 PyObject * obj0 = 0 ;
25833 PyObject * obj1 = 0 ;
25834 char *kwnames[] = {
25835 (char *) "self",(char *) "n", NULL
25836 };
25837
25838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
25839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25840 if (SWIG_arg_fail(1)) SWIG_fail;
25841 {
25842 arg2 = static_cast<int >(SWIG_As_int(obj1));
25843 if (SWIG_arg_fail(2)) SWIG_fail;
25844 }
25845 {
25846 PyThreadState* __tstate = wxPyBeginAllowThreads();
25847 result = wxTimeSpan___rmul__(arg1,arg2);
25848
25849 wxPyEndAllowThreads(__tstate);
25850 if (PyErr_Occurred()) SWIG_fail;
25851 }
25852 {
25853 wxTimeSpan * resultptr;
25854 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25855 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25856 }
25857 return resultobj;
25858 fail:
25859 return NULL;
25860 }
25861
25862
25863 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
25864 PyObject *resultobj = NULL;
25865 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25866 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25867 bool result;
25868 PyObject * obj0 = 0 ;
25869 PyObject * obj1 = 0 ;
25870 char *kwnames[] = {
25871 (char *) "self",(char *) "other", NULL
25872 };
25873
25874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
25875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25876 if (SWIG_arg_fail(1)) SWIG_fail;
25877 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25878 if (SWIG_arg_fail(2)) SWIG_fail;
25879 {
25880 PyThreadState* __tstate = wxPyBeginAllowThreads();
25881 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
25882
25883 wxPyEndAllowThreads(__tstate);
25884 if (PyErr_Occurred()) SWIG_fail;
25885 }
25886 {
25887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25888 }
25889 return resultobj;
25890 fail:
25891 return NULL;
25892 }
25893
25894
25895 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
25896 PyObject *resultobj = NULL;
25897 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25898 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25899 bool result;
25900 PyObject * obj0 = 0 ;
25901 PyObject * obj1 = 0 ;
25902 char *kwnames[] = {
25903 (char *) "self",(char *) "other", NULL
25904 };
25905
25906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
25907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25908 if (SWIG_arg_fail(1)) SWIG_fail;
25909 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25910 if (SWIG_arg_fail(2)) SWIG_fail;
25911 {
25912 PyThreadState* __tstate = wxPyBeginAllowThreads();
25913 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
25914
25915 wxPyEndAllowThreads(__tstate);
25916 if (PyErr_Occurred()) SWIG_fail;
25917 }
25918 {
25919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25920 }
25921 return resultobj;
25922 fail:
25923 return NULL;
25924 }
25925
25926
25927 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
25928 PyObject *resultobj = NULL;
25929 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25930 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25931 bool result;
25932 PyObject * obj0 = 0 ;
25933 PyObject * obj1 = 0 ;
25934 char *kwnames[] = {
25935 (char *) "self",(char *) "other", NULL
25936 };
25937
25938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
25939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25940 if (SWIG_arg_fail(1)) SWIG_fail;
25941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25942 if (SWIG_arg_fail(2)) SWIG_fail;
25943 {
25944 PyThreadState* __tstate = wxPyBeginAllowThreads();
25945 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
25946
25947 wxPyEndAllowThreads(__tstate);
25948 if (PyErr_Occurred()) SWIG_fail;
25949 }
25950 {
25951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25952 }
25953 return resultobj;
25954 fail:
25955 return NULL;
25956 }
25957
25958
25959 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
25960 PyObject *resultobj = NULL;
25961 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25962 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25963 bool result;
25964 PyObject * obj0 = 0 ;
25965 PyObject * obj1 = 0 ;
25966 char *kwnames[] = {
25967 (char *) "self",(char *) "other", NULL
25968 };
25969
25970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
25971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25972 if (SWIG_arg_fail(1)) SWIG_fail;
25973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25974 if (SWIG_arg_fail(2)) SWIG_fail;
25975 {
25976 PyThreadState* __tstate = wxPyBeginAllowThreads();
25977 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
25978
25979 wxPyEndAllowThreads(__tstate);
25980 if (PyErr_Occurred()) SWIG_fail;
25981 }
25982 {
25983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25984 }
25985 return resultobj;
25986 fail:
25987 return NULL;
25988 }
25989
25990
25991 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
25992 PyObject *resultobj = NULL;
25993 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25994 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25995 bool result;
25996 PyObject * obj0 = 0 ;
25997 PyObject * obj1 = 0 ;
25998 char *kwnames[] = {
25999 (char *) "self",(char *) "other", NULL
26000 };
26001
26002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26004 if (SWIG_arg_fail(1)) SWIG_fail;
26005 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26006 if (SWIG_arg_fail(2)) SWIG_fail;
26007 {
26008 PyThreadState* __tstate = wxPyBeginAllowThreads();
26009 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
26010
26011 wxPyEndAllowThreads(__tstate);
26012 if (PyErr_Occurred()) SWIG_fail;
26013 }
26014 {
26015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26016 }
26017 return resultobj;
26018 fail:
26019 return NULL;
26020 }
26021
26022
26023 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26024 PyObject *resultobj = NULL;
26025 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26026 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
26027 bool result;
26028 PyObject * obj0 = 0 ;
26029 PyObject * obj1 = 0 ;
26030 char *kwnames[] = {
26031 (char *) "self",(char *) "other", NULL
26032 };
26033
26034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26036 if (SWIG_arg_fail(1)) SWIG_fail;
26037 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26038 if (SWIG_arg_fail(2)) SWIG_fail;
26039 {
26040 PyThreadState* __tstate = wxPyBeginAllowThreads();
26041 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
26042
26043 wxPyEndAllowThreads(__tstate);
26044 if (PyErr_Occurred()) SWIG_fail;
26045 }
26046 {
26047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26048 }
26049 return resultobj;
26050 fail:
26051 return NULL;
26052 }
26053
26054
26055 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
26056 PyObject *resultobj = NULL;
26057 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26058 bool result;
26059 PyObject * obj0 = 0 ;
26060 char *kwnames[] = {
26061 (char *) "self", NULL
26062 };
26063
26064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
26065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26066 if (SWIG_arg_fail(1)) SWIG_fail;
26067 {
26068 PyThreadState* __tstate = wxPyBeginAllowThreads();
26069 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
26070
26071 wxPyEndAllowThreads(__tstate);
26072 if (PyErr_Occurred()) SWIG_fail;
26073 }
26074 {
26075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26076 }
26077 return resultobj;
26078 fail:
26079 return NULL;
26080 }
26081
26082
26083 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
26084 PyObject *resultobj = NULL;
26085 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26086 bool result;
26087 PyObject * obj0 = 0 ;
26088 char *kwnames[] = {
26089 (char *) "self", NULL
26090 };
26091
26092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
26093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26094 if (SWIG_arg_fail(1)) SWIG_fail;
26095 {
26096 PyThreadState* __tstate = wxPyBeginAllowThreads();
26097 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
26098
26099 wxPyEndAllowThreads(__tstate);
26100 if (PyErr_Occurred()) SWIG_fail;
26101 }
26102 {
26103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26104 }
26105 return resultobj;
26106 fail:
26107 return NULL;
26108 }
26109
26110
26111 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
26112 PyObject *resultobj = NULL;
26113 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26114 bool result;
26115 PyObject * obj0 = 0 ;
26116 char *kwnames[] = {
26117 (char *) "self", NULL
26118 };
26119
26120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
26121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26122 if (SWIG_arg_fail(1)) SWIG_fail;
26123 {
26124 PyThreadState* __tstate = wxPyBeginAllowThreads();
26125 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
26126
26127 wxPyEndAllowThreads(__tstate);
26128 if (PyErr_Occurred()) SWIG_fail;
26129 }
26130 {
26131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26132 }
26133 return resultobj;
26134 fail:
26135 return NULL;
26136 }
26137
26138
26139 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
26140 PyObject *resultobj = NULL;
26141 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26142 wxTimeSpan *arg2 = 0 ;
26143 bool result;
26144 PyObject * obj0 = 0 ;
26145 PyObject * obj1 = 0 ;
26146 char *kwnames[] = {
26147 (char *) "self",(char *) "ts", NULL
26148 };
26149
26150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
26151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26152 if (SWIG_arg_fail(1)) SWIG_fail;
26153 {
26154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26155 if (SWIG_arg_fail(2)) SWIG_fail;
26156 if (arg2 == NULL) {
26157 SWIG_null_ref("wxTimeSpan");
26158 }
26159 if (SWIG_arg_fail(2)) SWIG_fail;
26160 }
26161 {
26162 PyThreadState* __tstate = wxPyBeginAllowThreads();
26163 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
26164
26165 wxPyEndAllowThreads(__tstate);
26166 if (PyErr_Occurred()) SWIG_fail;
26167 }
26168 {
26169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26170 }
26171 return resultobj;
26172 fail:
26173 return NULL;
26174 }
26175
26176
26177 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
26178 PyObject *resultobj = NULL;
26179 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26180 wxTimeSpan *arg2 = 0 ;
26181 bool result;
26182 PyObject * obj0 = 0 ;
26183 PyObject * obj1 = 0 ;
26184 char *kwnames[] = {
26185 (char *) "self",(char *) "ts", NULL
26186 };
26187
26188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
26189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26190 if (SWIG_arg_fail(1)) SWIG_fail;
26191 {
26192 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26193 if (SWIG_arg_fail(2)) SWIG_fail;
26194 if (arg2 == NULL) {
26195 SWIG_null_ref("wxTimeSpan");
26196 }
26197 if (SWIG_arg_fail(2)) SWIG_fail;
26198 }
26199 {
26200 PyThreadState* __tstate = wxPyBeginAllowThreads();
26201 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
26202
26203 wxPyEndAllowThreads(__tstate);
26204 if (PyErr_Occurred()) SWIG_fail;
26205 }
26206 {
26207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26208 }
26209 return resultobj;
26210 fail:
26211 return NULL;
26212 }
26213
26214
26215 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
26216 PyObject *resultobj = NULL;
26217 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26218 wxTimeSpan *arg2 = 0 ;
26219 bool result;
26220 PyObject * obj0 = 0 ;
26221 PyObject * obj1 = 0 ;
26222 char *kwnames[] = {
26223 (char *) "self",(char *) "t", NULL
26224 };
26225
26226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
26227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26228 if (SWIG_arg_fail(1)) SWIG_fail;
26229 {
26230 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26231 if (SWIG_arg_fail(2)) SWIG_fail;
26232 if (arg2 == NULL) {
26233 SWIG_null_ref("wxTimeSpan");
26234 }
26235 if (SWIG_arg_fail(2)) SWIG_fail;
26236 }
26237 {
26238 PyThreadState* __tstate = wxPyBeginAllowThreads();
26239 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
26240
26241 wxPyEndAllowThreads(__tstate);
26242 if (PyErr_Occurred()) SWIG_fail;
26243 }
26244 {
26245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26246 }
26247 return resultobj;
26248 fail:
26249 return NULL;
26250 }
26251
26252
26253 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
26254 PyObject *resultobj = NULL;
26255 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26256 int result;
26257 PyObject * obj0 = 0 ;
26258 char *kwnames[] = {
26259 (char *) "self", NULL
26260 };
26261
26262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
26263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26264 if (SWIG_arg_fail(1)) SWIG_fail;
26265 {
26266 PyThreadState* __tstate = wxPyBeginAllowThreads();
26267 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
26268
26269 wxPyEndAllowThreads(__tstate);
26270 if (PyErr_Occurred()) SWIG_fail;
26271 }
26272 {
26273 resultobj = SWIG_From_int(static_cast<int >(result));
26274 }
26275 return resultobj;
26276 fail:
26277 return NULL;
26278 }
26279
26280
26281 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
26282 PyObject *resultobj = NULL;
26283 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26284 int result;
26285 PyObject * obj0 = 0 ;
26286 char *kwnames[] = {
26287 (char *) "self", NULL
26288 };
26289
26290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
26291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26292 if (SWIG_arg_fail(1)) SWIG_fail;
26293 {
26294 PyThreadState* __tstate = wxPyBeginAllowThreads();
26295 result = (int)((wxTimeSpan const *)arg1)->GetDays();
26296
26297 wxPyEndAllowThreads(__tstate);
26298 if (PyErr_Occurred()) SWIG_fail;
26299 }
26300 {
26301 resultobj = SWIG_From_int(static_cast<int >(result));
26302 }
26303 return resultobj;
26304 fail:
26305 return NULL;
26306 }
26307
26308
26309 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
26310 PyObject *resultobj = NULL;
26311 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26312 int result;
26313 PyObject * obj0 = 0 ;
26314 char *kwnames[] = {
26315 (char *) "self", NULL
26316 };
26317
26318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
26319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26320 if (SWIG_arg_fail(1)) SWIG_fail;
26321 {
26322 PyThreadState* __tstate = wxPyBeginAllowThreads();
26323 result = (int)((wxTimeSpan const *)arg1)->GetHours();
26324
26325 wxPyEndAllowThreads(__tstate);
26326 if (PyErr_Occurred()) SWIG_fail;
26327 }
26328 {
26329 resultobj = SWIG_From_int(static_cast<int >(result));
26330 }
26331 return resultobj;
26332 fail:
26333 return NULL;
26334 }
26335
26336
26337 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
26338 PyObject *resultobj = NULL;
26339 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26340 int result;
26341 PyObject * obj0 = 0 ;
26342 char *kwnames[] = {
26343 (char *) "self", NULL
26344 };
26345
26346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
26347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26348 if (SWIG_arg_fail(1)) SWIG_fail;
26349 {
26350 PyThreadState* __tstate = wxPyBeginAllowThreads();
26351 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
26352
26353 wxPyEndAllowThreads(__tstate);
26354 if (PyErr_Occurred()) SWIG_fail;
26355 }
26356 {
26357 resultobj = SWIG_From_int(static_cast<int >(result));
26358 }
26359 return resultobj;
26360 fail:
26361 return NULL;
26362 }
26363
26364
26365 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
26366 PyObject *resultobj = NULL;
26367 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26368 wxLongLong result;
26369 PyObject * obj0 = 0 ;
26370 char *kwnames[] = {
26371 (char *) "self", NULL
26372 };
26373
26374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
26375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26376 if (SWIG_arg_fail(1)) SWIG_fail;
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 result = ((wxTimeSpan const *)arg1)->GetSeconds();
26380
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 {
26385 PyObject *hi, *lo, *shifter, *shifted;
26386 hi = PyLong_FromLong( (&result)->GetHi() );
26387 lo = PyLong_FromLong( (&result)->GetLo() );
26388 shifter = PyLong_FromLong(32);
26389 shifted = PyNumber_Lshift(hi, shifter);
26390 resultobj = PyNumber_Or(shifted, lo);
26391 Py_DECREF(hi);
26392 Py_DECREF(lo);
26393 Py_DECREF(shifter);
26394 Py_DECREF(shifted);
26395 }
26396 return resultobj;
26397 fail:
26398 return NULL;
26399 }
26400
26401
26402 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
26403 PyObject *resultobj = NULL;
26404 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26405 wxLongLong result;
26406 PyObject * obj0 = 0 ;
26407 char *kwnames[] = {
26408 (char *) "self", NULL
26409 };
26410
26411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
26412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26413 if (SWIG_arg_fail(1)) SWIG_fail;
26414 {
26415 PyThreadState* __tstate = wxPyBeginAllowThreads();
26416 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
26417
26418 wxPyEndAllowThreads(__tstate);
26419 if (PyErr_Occurred()) SWIG_fail;
26420 }
26421 {
26422 PyObject *hi, *lo, *shifter, *shifted;
26423 hi = PyLong_FromLong( (&result)->GetHi() );
26424 lo = PyLong_FromLong( (&result)->GetLo() );
26425 shifter = PyLong_FromLong(32);
26426 shifted = PyNumber_Lshift(hi, shifter);
26427 resultobj = PyNumber_Or(shifted, lo);
26428 Py_DECREF(hi);
26429 Py_DECREF(lo);
26430 Py_DECREF(shifter);
26431 Py_DECREF(shifted);
26432 }
26433 return resultobj;
26434 fail:
26435 return NULL;
26436 }
26437
26438
26439 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
26440 PyObject *resultobj = NULL;
26441 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26442 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
26443 wxString *arg2 = (wxString *) &arg2_defvalue ;
26444 wxString result;
26445 bool temp2 = false ;
26446 PyObject * obj0 = 0 ;
26447 PyObject * obj1 = 0 ;
26448 char *kwnames[] = {
26449 (char *) "self",(char *) "format", NULL
26450 };
26451
26452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
26453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26454 if (SWIG_arg_fail(1)) SWIG_fail;
26455 if (obj1) {
26456 {
26457 arg2 = wxString_in_helper(obj1);
26458 if (arg2 == NULL) SWIG_fail;
26459 temp2 = true;
26460 }
26461 }
26462 {
26463 PyThreadState* __tstate = wxPyBeginAllowThreads();
26464 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
26465
26466 wxPyEndAllowThreads(__tstate);
26467 if (PyErr_Occurred()) SWIG_fail;
26468 }
26469 {
26470 #if wxUSE_UNICODE
26471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26472 #else
26473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26474 #endif
26475 }
26476 {
26477 if (temp2)
26478 delete arg2;
26479 }
26480 return resultobj;
26481 fail:
26482 {
26483 if (temp2)
26484 delete arg2;
26485 }
26486 return NULL;
26487 }
26488
26489
26490 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
26491 PyObject *obj;
26492 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26493 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
26494 Py_INCREF(obj);
26495 return Py_BuildValue((char *)"");
26496 }
26497 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
26498 PyObject *resultobj = NULL;
26499 int arg1 = (int) 0 ;
26500 int arg2 = (int) 0 ;
26501 int arg3 = (int) 0 ;
26502 int arg4 = (int) 0 ;
26503 wxDateSpan *result;
26504 PyObject * obj0 = 0 ;
26505 PyObject * obj1 = 0 ;
26506 PyObject * obj2 = 0 ;
26507 PyObject * obj3 = 0 ;
26508 char *kwnames[] = {
26509 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
26510 };
26511
26512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26513 if (obj0) {
26514 {
26515 arg1 = static_cast<int >(SWIG_As_int(obj0));
26516 if (SWIG_arg_fail(1)) SWIG_fail;
26517 }
26518 }
26519 if (obj1) {
26520 {
26521 arg2 = static_cast<int >(SWIG_As_int(obj1));
26522 if (SWIG_arg_fail(2)) SWIG_fail;
26523 }
26524 }
26525 if (obj2) {
26526 {
26527 arg3 = static_cast<int >(SWIG_As_int(obj2));
26528 if (SWIG_arg_fail(3)) SWIG_fail;
26529 }
26530 }
26531 if (obj3) {
26532 {
26533 arg4 = static_cast<int >(SWIG_As_int(obj3));
26534 if (SWIG_arg_fail(4)) SWIG_fail;
26535 }
26536 }
26537 {
26538 PyThreadState* __tstate = wxPyBeginAllowThreads();
26539 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
26540
26541 wxPyEndAllowThreads(__tstate);
26542 if (PyErr_Occurred()) SWIG_fail;
26543 }
26544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26545 return resultobj;
26546 fail:
26547 return NULL;
26548 }
26549
26550
26551 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
26552 PyObject *resultobj = NULL;
26553 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26554 PyObject * obj0 = 0 ;
26555 char *kwnames[] = {
26556 (char *) "self", NULL
26557 };
26558
26559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
26560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26561 if (SWIG_arg_fail(1)) SWIG_fail;
26562 {
26563 PyThreadState* __tstate = wxPyBeginAllowThreads();
26564 delete arg1;
26565
26566 wxPyEndAllowThreads(__tstate);
26567 if (PyErr_Occurred()) SWIG_fail;
26568 }
26569 Py_INCREF(Py_None); resultobj = Py_None;
26570 return resultobj;
26571 fail:
26572 return NULL;
26573 }
26574
26575
26576 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
26577 PyObject *resultobj = NULL;
26578 int arg1 ;
26579 wxDateSpan result;
26580 PyObject * obj0 = 0 ;
26581 char *kwnames[] = {
26582 (char *) "days", NULL
26583 };
26584
26585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
26586 {
26587 arg1 = static_cast<int >(SWIG_As_int(obj0));
26588 if (SWIG_arg_fail(1)) SWIG_fail;
26589 }
26590 {
26591 PyThreadState* __tstate = wxPyBeginAllowThreads();
26592 result = wxDateSpan::Days(arg1);
26593
26594 wxPyEndAllowThreads(__tstate);
26595 if (PyErr_Occurred()) SWIG_fail;
26596 }
26597 {
26598 wxDateSpan * resultptr;
26599 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26600 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26601 }
26602 return resultobj;
26603 fail:
26604 return NULL;
26605 }
26606
26607
26608 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
26609 PyObject *resultobj = NULL;
26610 wxDateSpan result;
26611 char *kwnames[] = {
26612 NULL
26613 };
26614
26615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
26616 {
26617 PyThreadState* __tstate = wxPyBeginAllowThreads();
26618 result = wxDateSpan::Day();
26619
26620 wxPyEndAllowThreads(__tstate);
26621 if (PyErr_Occurred()) SWIG_fail;
26622 }
26623 {
26624 wxDateSpan * resultptr;
26625 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26626 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26627 }
26628 return resultobj;
26629 fail:
26630 return NULL;
26631 }
26632
26633
26634 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
26635 PyObject *resultobj = NULL;
26636 int arg1 ;
26637 wxDateSpan result;
26638 PyObject * obj0 = 0 ;
26639 char *kwnames[] = {
26640 (char *) "weeks", NULL
26641 };
26642
26643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
26644 {
26645 arg1 = static_cast<int >(SWIG_As_int(obj0));
26646 if (SWIG_arg_fail(1)) SWIG_fail;
26647 }
26648 {
26649 PyThreadState* __tstate = wxPyBeginAllowThreads();
26650 result = wxDateSpan::Weeks(arg1);
26651
26652 wxPyEndAllowThreads(__tstate);
26653 if (PyErr_Occurred()) SWIG_fail;
26654 }
26655 {
26656 wxDateSpan * resultptr;
26657 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26658 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26659 }
26660 return resultobj;
26661 fail:
26662 return NULL;
26663 }
26664
26665
26666 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
26667 PyObject *resultobj = NULL;
26668 wxDateSpan result;
26669 char *kwnames[] = {
26670 NULL
26671 };
26672
26673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
26674 {
26675 PyThreadState* __tstate = wxPyBeginAllowThreads();
26676 result = wxDateSpan::Week();
26677
26678 wxPyEndAllowThreads(__tstate);
26679 if (PyErr_Occurred()) SWIG_fail;
26680 }
26681 {
26682 wxDateSpan * resultptr;
26683 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26684 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26685 }
26686 return resultobj;
26687 fail:
26688 return NULL;
26689 }
26690
26691
26692 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
26693 PyObject *resultobj = NULL;
26694 int arg1 ;
26695 wxDateSpan result;
26696 PyObject * obj0 = 0 ;
26697 char *kwnames[] = {
26698 (char *) "mon", NULL
26699 };
26700
26701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
26702 {
26703 arg1 = static_cast<int >(SWIG_As_int(obj0));
26704 if (SWIG_arg_fail(1)) SWIG_fail;
26705 }
26706 {
26707 PyThreadState* __tstate = wxPyBeginAllowThreads();
26708 result = wxDateSpan::Months(arg1);
26709
26710 wxPyEndAllowThreads(__tstate);
26711 if (PyErr_Occurred()) SWIG_fail;
26712 }
26713 {
26714 wxDateSpan * resultptr;
26715 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26716 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26717 }
26718 return resultobj;
26719 fail:
26720 return NULL;
26721 }
26722
26723
26724 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
26725 PyObject *resultobj = NULL;
26726 wxDateSpan result;
26727 char *kwnames[] = {
26728 NULL
26729 };
26730
26731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
26732 {
26733 PyThreadState* __tstate = wxPyBeginAllowThreads();
26734 result = wxDateSpan::Month();
26735
26736 wxPyEndAllowThreads(__tstate);
26737 if (PyErr_Occurred()) SWIG_fail;
26738 }
26739 {
26740 wxDateSpan * resultptr;
26741 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26742 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26743 }
26744 return resultobj;
26745 fail:
26746 return NULL;
26747 }
26748
26749
26750 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
26751 PyObject *resultobj = NULL;
26752 int arg1 ;
26753 wxDateSpan result;
26754 PyObject * obj0 = 0 ;
26755 char *kwnames[] = {
26756 (char *) "years", NULL
26757 };
26758
26759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
26760 {
26761 arg1 = static_cast<int >(SWIG_As_int(obj0));
26762 if (SWIG_arg_fail(1)) SWIG_fail;
26763 }
26764 {
26765 PyThreadState* __tstate = wxPyBeginAllowThreads();
26766 result = wxDateSpan::Years(arg1);
26767
26768 wxPyEndAllowThreads(__tstate);
26769 if (PyErr_Occurred()) SWIG_fail;
26770 }
26771 {
26772 wxDateSpan * resultptr;
26773 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26774 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26775 }
26776 return resultobj;
26777 fail:
26778 return NULL;
26779 }
26780
26781
26782 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
26783 PyObject *resultobj = NULL;
26784 wxDateSpan result;
26785 char *kwnames[] = {
26786 NULL
26787 };
26788
26789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
26790 {
26791 PyThreadState* __tstate = wxPyBeginAllowThreads();
26792 result = wxDateSpan::Year();
26793
26794 wxPyEndAllowThreads(__tstate);
26795 if (PyErr_Occurred()) SWIG_fail;
26796 }
26797 {
26798 wxDateSpan * resultptr;
26799 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26800 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26801 }
26802 return resultobj;
26803 fail:
26804 return NULL;
26805 }
26806
26807
26808 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
26809 PyObject *resultobj = NULL;
26810 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26811 int arg2 ;
26812 wxDateSpan *result;
26813 PyObject * obj0 = 0 ;
26814 PyObject * obj1 = 0 ;
26815 char *kwnames[] = {
26816 (char *) "self",(char *) "n", NULL
26817 };
26818
26819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
26820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26821 if (SWIG_arg_fail(1)) SWIG_fail;
26822 {
26823 arg2 = static_cast<int >(SWIG_As_int(obj1));
26824 if (SWIG_arg_fail(2)) SWIG_fail;
26825 }
26826 {
26827 PyThreadState* __tstate = wxPyBeginAllowThreads();
26828 {
26829 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
26830 result = (wxDateSpan *) &_result_ref;
26831 }
26832
26833 wxPyEndAllowThreads(__tstate);
26834 if (PyErr_Occurred()) SWIG_fail;
26835 }
26836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26837 return resultobj;
26838 fail:
26839 return NULL;
26840 }
26841
26842
26843 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
26844 PyObject *resultobj = NULL;
26845 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26846 int arg2 ;
26847 wxDateSpan *result;
26848 PyObject * obj0 = 0 ;
26849 PyObject * obj1 = 0 ;
26850 char *kwnames[] = {
26851 (char *) "self",(char *) "n", NULL
26852 };
26853
26854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
26855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26856 if (SWIG_arg_fail(1)) SWIG_fail;
26857 {
26858 arg2 = static_cast<int >(SWIG_As_int(obj1));
26859 if (SWIG_arg_fail(2)) SWIG_fail;
26860 }
26861 {
26862 PyThreadState* __tstate = wxPyBeginAllowThreads();
26863 {
26864 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
26865 result = (wxDateSpan *) &_result_ref;
26866 }
26867
26868 wxPyEndAllowThreads(__tstate);
26869 if (PyErr_Occurred()) SWIG_fail;
26870 }
26871 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26872 return resultobj;
26873 fail:
26874 return NULL;
26875 }
26876
26877
26878 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
26879 PyObject *resultobj = NULL;
26880 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26881 int arg2 ;
26882 wxDateSpan *result;
26883 PyObject * obj0 = 0 ;
26884 PyObject * obj1 = 0 ;
26885 char *kwnames[] = {
26886 (char *) "self",(char *) "n", NULL
26887 };
26888
26889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
26890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26891 if (SWIG_arg_fail(1)) SWIG_fail;
26892 {
26893 arg2 = static_cast<int >(SWIG_As_int(obj1));
26894 if (SWIG_arg_fail(2)) SWIG_fail;
26895 }
26896 {
26897 PyThreadState* __tstate = wxPyBeginAllowThreads();
26898 {
26899 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
26900 result = (wxDateSpan *) &_result_ref;
26901 }
26902
26903 wxPyEndAllowThreads(__tstate);
26904 if (PyErr_Occurred()) SWIG_fail;
26905 }
26906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26907 return resultobj;
26908 fail:
26909 return NULL;
26910 }
26911
26912
26913 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
26914 PyObject *resultobj = NULL;
26915 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26916 int arg2 ;
26917 wxDateSpan *result;
26918 PyObject * obj0 = 0 ;
26919 PyObject * obj1 = 0 ;
26920 char *kwnames[] = {
26921 (char *) "self",(char *) "n", NULL
26922 };
26923
26924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
26925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26926 if (SWIG_arg_fail(1)) SWIG_fail;
26927 {
26928 arg2 = static_cast<int >(SWIG_As_int(obj1));
26929 if (SWIG_arg_fail(2)) SWIG_fail;
26930 }
26931 {
26932 PyThreadState* __tstate = wxPyBeginAllowThreads();
26933 {
26934 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
26935 result = (wxDateSpan *) &_result_ref;
26936 }
26937
26938 wxPyEndAllowThreads(__tstate);
26939 if (PyErr_Occurred()) SWIG_fail;
26940 }
26941 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26942 return resultobj;
26943 fail:
26944 return NULL;
26945 }
26946
26947
26948 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
26949 PyObject *resultobj = NULL;
26950 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26951 int result;
26952 PyObject * obj0 = 0 ;
26953 char *kwnames[] = {
26954 (char *) "self", NULL
26955 };
26956
26957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
26958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26959 if (SWIG_arg_fail(1)) SWIG_fail;
26960 {
26961 PyThreadState* __tstate = wxPyBeginAllowThreads();
26962 result = (int)((wxDateSpan const *)arg1)->GetYears();
26963
26964 wxPyEndAllowThreads(__tstate);
26965 if (PyErr_Occurred()) SWIG_fail;
26966 }
26967 {
26968 resultobj = SWIG_From_int(static_cast<int >(result));
26969 }
26970 return resultobj;
26971 fail:
26972 return NULL;
26973 }
26974
26975
26976 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
26977 PyObject *resultobj = NULL;
26978 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26979 int result;
26980 PyObject * obj0 = 0 ;
26981 char *kwnames[] = {
26982 (char *) "self", NULL
26983 };
26984
26985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
26986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26987 if (SWIG_arg_fail(1)) SWIG_fail;
26988 {
26989 PyThreadState* __tstate = wxPyBeginAllowThreads();
26990 result = (int)((wxDateSpan const *)arg1)->GetMonths();
26991
26992 wxPyEndAllowThreads(__tstate);
26993 if (PyErr_Occurred()) SWIG_fail;
26994 }
26995 {
26996 resultobj = SWIG_From_int(static_cast<int >(result));
26997 }
26998 return resultobj;
26999 fail:
27000 return NULL;
27001 }
27002
27003
27004 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
27005 PyObject *resultobj = NULL;
27006 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27007 int result;
27008 PyObject * obj0 = 0 ;
27009 char *kwnames[] = {
27010 (char *) "self", NULL
27011 };
27012
27013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
27014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27015 if (SWIG_arg_fail(1)) SWIG_fail;
27016 {
27017 PyThreadState* __tstate = wxPyBeginAllowThreads();
27018 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
27019
27020 wxPyEndAllowThreads(__tstate);
27021 if (PyErr_Occurred()) SWIG_fail;
27022 }
27023 {
27024 resultobj = SWIG_From_int(static_cast<int >(result));
27025 }
27026 return resultobj;
27027 fail:
27028 return NULL;
27029 }
27030
27031
27032 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
27033 PyObject *resultobj = NULL;
27034 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27035 int result;
27036 PyObject * obj0 = 0 ;
27037 char *kwnames[] = {
27038 (char *) "self", NULL
27039 };
27040
27041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
27042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27043 if (SWIG_arg_fail(1)) SWIG_fail;
27044 {
27045 PyThreadState* __tstate = wxPyBeginAllowThreads();
27046 result = (int)((wxDateSpan const *)arg1)->GetDays();
27047
27048 wxPyEndAllowThreads(__tstate);
27049 if (PyErr_Occurred()) SWIG_fail;
27050 }
27051 {
27052 resultobj = SWIG_From_int(static_cast<int >(result));
27053 }
27054 return resultobj;
27055 fail:
27056 return NULL;
27057 }
27058
27059
27060 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
27061 PyObject *resultobj = NULL;
27062 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27063 int result;
27064 PyObject * obj0 = 0 ;
27065 char *kwnames[] = {
27066 (char *) "self", NULL
27067 };
27068
27069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
27070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27071 if (SWIG_arg_fail(1)) SWIG_fail;
27072 {
27073 PyThreadState* __tstate = wxPyBeginAllowThreads();
27074 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
27075
27076 wxPyEndAllowThreads(__tstate);
27077 if (PyErr_Occurred()) SWIG_fail;
27078 }
27079 {
27080 resultobj = SWIG_From_int(static_cast<int >(result));
27081 }
27082 return resultobj;
27083 fail:
27084 return NULL;
27085 }
27086
27087
27088 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27089 PyObject *resultobj = NULL;
27090 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27091 wxDateSpan *arg2 = 0 ;
27092 wxDateSpan *result;
27093 PyObject * obj0 = 0 ;
27094 PyObject * obj1 = 0 ;
27095 char *kwnames[] = {
27096 (char *) "self",(char *) "other", NULL
27097 };
27098
27099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
27100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27101 if (SWIG_arg_fail(1)) SWIG_fail;
27102 {
27103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27104 if (SWIG_arg_fail(2)) SWIG_fail;
27105 if (arg2 == NULL) {
27106 SWIG_null_ref("wxDateSpan");
27107 }
27108 if (SWIG_arg_fail(2)) SWIG_fail;
27109 }
27110 {
27111 PyThreadState* __tstate = wxPyBeginAllowThreads();
27112 {
27113 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27114 result = (wxDateSpan *) &_result_ref;
27115 }
27116
27117 wxPyEndAllowThreads(__tstate);
27118 if (PyErr_Occurred()) SWIG_fail;
27119 }
27120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27121 return resultobj;
27122 fail:
27123 return NULL;
27124 }
27125
27126
27127 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
27128 PyObject *resultobj = NULL;
27129 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27130 wxDateSpan *arg2 = 0 ;
27131 wxDateSpan *result;
27132 PyObject * obj0 = 0 ;
27133 PyObject * obj1 = 0 ;
27134 char *kwnames[] = {
27135 (char *) "self",(char *) "other", NULL
27136 };
27137
27138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
27139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27140 if (SWIG_arg_fail(1)) SWIG_fail;
27141 {
27142 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27143 if (SWIG_arg_fail(2)) SWIG_fail;
27144 if (arg2 == NULL) {
27145 SWIG_null_ref("wxDateSpan");
27146 }
27147 if (SWIG_arg_fail(2)) SWIG_fail;
27148 }
27149 {
27150 PyThreadState* __tstate = wxPyBeginAllowThreads();
27151 {
27152 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27153 result = (wxDateSpan *) &_result_ref;
27154 }
27155
27156 wxPyEndAllowThreads(__tstate);
27157 if (PyErr_Occurred()) SWIG_fail;
27158 }
27159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27160 return resultobj;
27161 fail:
27162 return NULL;
27163 }
27164
27165
27166 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
27167 PyObject *resultobj = NULL;
27168 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27169 wxDateSpan *result;
27170 PyObject * obj0 = 0 ;
27171 char *kwnames[] = {
27172 (char *) "self", NULL
27173 };
27174
27175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
27176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27177 if (SWIG_arg_fail(1)) SWIG_fail;
27178 {
27179 PyThreadState* __tstate = wxPyBeginAllowThreads();
27180 {
27181 wxDateSpan &_result_ref = (arg1)->Neg();
27182 result = (wxDateSpan *) &_result_ref;
27183 }
27184
27185 wxPyEndAllowThreads(__tstate);
27186 if (PyErr_Occurred()) SWIG_fail;
27187 }
27188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27189 return resultobj;
27190 fail:
27191 return NULL;
27192 }
27193
27194
27195 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
27196 PyObject *resultobj = NULL;
27197 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27198 int arg2 ;
27199 wxDateSpan *result;
27200 PyObject * obj0 = 0 ;
27201 PyObject * obj1 = 0 ;
27202 char *kwnames[] = {
27203 (char *) "self",(char *) "factor", NULL
27204 };
27205
27206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
27207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27208 if (SWIG_arg_fail(1)) SWIG_fail;
27209 {
27210 arg2 = static_cast<int >(SWIG_As_int(obj1));
27211 if (SWIG_arg_fail(2)) SWIG_fail;
27212 }
27213 {
27214 PyThreadState* __tstate = wxPyBeginAllowThreads();
27215 {
27216 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
27217 result = (wxDateSpan *) &_result_ref;
27218 }
27219
27220 wxPyEndAllowThreads(__tstate);
27221 if (PyErr_Occurred()) SWIG_fail;
27222 }
27223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27224 return resultobj;
27225 fail:
27226 return NULL;
27227 }
27228
27229
27230 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
27231 PyObject *resultobj = NULL;
27232 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27233 wxDateSpan *arg2 = 0 ;
27234 wxDateSpan *result;
27235 PyObject * obj0 = 0 ;
27236 PyObject * obj1 = 0 ;
27237 char *kwnames[] = {
27238 (char *) "self",(char *) "other", NULL
27239 };
27240
27241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
27242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27243 if (SWIG_arg_fail(1)) SWIG_fail;
27244 {
27245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27246 if (SWIG_arg_fail(2)) SWIG_fail;
27247 if (arg2 == NULL) {
27248 SWIG_null_ref("wxDateSpan");
27249 }
27250 if (SWIG_arg_fail(2)) SWIG_fail;
27251 }
27252 {
27253 PyThreadState* __tstate = wxPyBeginAllowThreads();
27254 {
27255 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27256 result = (wxDateSpan *) &_result_ref;
27257 }
27258
27259 wxPyEndAllowThreads(__tstate);
27260 if (PyErr_Occurred()) SWIG_fail;
27261 }
27262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
27263 return resultobj;
27264 fail:
27265 return NULL;
27266 }
27267
27268
27269 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
27270 PyObject *resultobj = NULL;
27271 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27272 wxDateSpan *arg2 = 0 ;
27273 wxDateSpan *result;
27274 PyObject * obj0 = 0 ;
27275 PyObject * obj1 = 0 ;
27276 char *kwnames[] = {
27277 (char *) "self",(char *) "other", NULL
27278 };
27279
27280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
27281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27282 if (SWIG_arg_fail(1)) SWIG_fail;
27283 {
27284 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27285 if (SWIG_arg_fail(2)) SWIG_fail;
27286 if (arg2 == NULL) {
27287 SWIG_null_ref("wxDateSpan");
27288 }
27289 if (SWIG_arg_fail(2)) SWIG_fail;
27290 }
27291 {
27292 PyThreadState* __tstate = wxPyBeginAllowThreads();
27293 {
27294 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27295 result = (wxDateSpan *) &_result_ref;
27296 }
27297
27298 wxPyEndAllowThreads(__tstate);
27299 if (PyErr_Occurred()) SWIG_fail;
27300 }
27301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
27302 return resultobj;
27303 fail:
27304 return NULL;
27305 }
27306
27307
27308 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
27309 PyObject *resultobj = NULL;
27310 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27311 wxDateSpan *result;
27312 PyObject * obj0 = 0 ;
27313 char *kwnames[] = {
27314 (char *) "self", NULL
27315 };
27316
27317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
27318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27319 if (SWIG_arg_fail(1)) SWIG_fail;
27320 {
27321 PyThreadState* __tstate = wxPyBeginAllowThreads();
27322 {
27323 wxDateSpan &_result_ref = (arg1)->operator -();
27324 result = (wxDateSpan *) &_result_ref;
27325 }
27326
27327 wxPyEndAllowThreads(__tstate);
27328 if (PyErr_Occurred()) SWIG_fail;
27329 }
27330 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27331 return resultobj;
27332 fail:
27333 return NULL;
27334 }
27335
27336
27337 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
27338 PyObject *resultobj = NULL;
27339 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27340 int arg2 ;
27341 wxDateSpan *result;
27342 PyObject * obj0 = 0 ;
27343 PyObject * obj1 = 0 ;
27344 char *kwnames[] = {
27345 (char *) "self",(char *) "factor", NULL
27346 };
27347
27348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
27349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27350 if (SWIG_arg_fail(1)) SWIG_fail;
27351 {
27352 arg2 = static_cast<int >(SWIG_As_int(obj1));
27353 if (SWIG_arg_fail(2)) SWIG_fail;
27354 }
27355 {
27356 PyThreadState* __tstate = wxPyBeginAllowThreads();
27357 {
27358 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
27359 result = (wxDateSpan *) &_result_ref;
27360 }
27361
27362 wxPyEndAllowThreads(__tstate);
27363 if (PyErr_Occurred()) SWIG_fail;
27364 }
27365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
27366 return resultobj;
27367 fail:
27368 return NULL;
27369 }
27370
27371
27372 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
27373 PyObject *resultobj = NULL;
27374 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27375 wxDateSpan *arg2 = 0 ;
27376 wxDateSpan result;
27377 PyObject * obj0 = 0 ;
27378 PyObject * obj1 = 0 ;
27379 char *kwnames[] = {
27380 (char *) "self",(char *) "other", NULL
27381 };
27382
27383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
27384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27385 if (SWIG_arg_fail(1)) SWIG_fail;
27386 {
27387 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27388 if (SWIG_arg_fail(2)) SWIG_fail;
27389 if (arg2 == NULL) {
27390 SWIG_null_ref("wxDateSpan");
27391 }
27392 if (SWIG_arg_fail(2)) SWIG_fail;
27393 }
27394 {
27395 PyThreadState* __tstate = wxPyBeginAllowThreads();
27396 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
27397
27398 wxPyEndAllowThreads(__tstate);
27399 if (PyErr_Occurred()) SWIG_fail;
27400 }
27401 {
27402 wxDateSpan * resultptr;
27403 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
27404 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
27405 }
27406 return resultobj;
27407 fail:
27408 return NULL;
27409 }
27410
27411
27412 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
27413 PyObject *resultobj = NULL;
27414 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27415 wxDateSpan *arg2 = 0 ;
27416 wxDateSpan result;
27417 PyObject * obj0 = 0 ;
27418 PyObject * obj1 = 0 ;
27419 char *kwnames[] = {
27420 (char *) "self",(char *) "other", NULL
27421 };
27422
27423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
27424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27425 if (SWIG_arg_fail(1)) SWIG_fail;
27426 {
27427 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27428 if (SWIG_arg_fail(2)) SWIG_fail;
27429 if (arg2 == NULL) {
27430 SWIG_null_ref("wxDateSpan");
27431 }
27432 if (SWIG_arg_fail(2)) SWIG_fail;
27433 }
27434 {
27435 PyThreadState* __tstate = wxPyBeginAllowThreads();
27436 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
27437
27438 wxPyEndAllowThreads(__tstate);
27439 if (PyErr_Occurred()) SWIG_fail;
27440 }
27441 {
27442 wxDateSpan * resultptr;
27443 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
27444 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
27445 }
27446 return resultobj;
27447 fail:
27448 return NULL;
27449 }
27450
27451
27452 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
27453 PyObject *resultobj = NULL;
27454 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27455 int arg2 ;
27456 wxDateSpan result;
27457 PyObject * obj0 = 0 ;
27458 PyObject * obj1 = 0 ;
27459 char *kwnames[] = {
27460 (char *) "self",(char *) "n", NULL
27461 };
27462
27463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
27464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27465 if (SWIG_arg_fail(1)) SWIG_fail;
27466 {
27467 arg2 = static_cast<int >(SWIG_As_int(obj1));
27468 if (SWIG_arg_fail(2)) SWIG_fail;
27469 }
27470 {
27471 PyThreadState* __tstate = wxPyBeginAllowThreads();
27472 result = wxDateSpan___mul__(arg1,arg2);
27473
27474 wxPyEndAllowThreads(__tstate);
27475 if (PyErr_Occurred()) SWIG_fail;
27476 }
27477 {
27478 wxDateSpan * resultptr;
27479 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
27480 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
27481 }
27482 return resultobj;
27483 fail:
27484 return NULL;
27485 }
27486
27487
27488 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
27489 PyObject *resultobj = NULL;
27490 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27491 int arg2 ;
27492 wxDateSpan result;
27493 PyObject * obj0 = 0 ;
27494 PyObject * obj1 = 0 ;
27495 char *kwnames[] = {
27496 (char *) "self",(char *) "n", NULL
27497 };
27498
27499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
27500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27501 if (SWIG_arg_fail(1)) SWIG_fail;
27502 {
27503 arg2 = static_cast<int >(SWIG_As_int(obj1));
27504 if (SWIG_arg_fail(2)) SWIG_fail;
27505 }
27506 {
27507 PyThreadState* __tstate = wxPyBeginAllowThreads();
27508 result = wxDateSpan___rmul__(arg1,arg2);
27509
27510 wxPyEndAllowThreads(__tstate);
27511 if (PyErr_Occurred()) SWIG_fail;
27512 }
27513 {
27514 wxDateSpan * resultptr;
27515 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
27516 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
27517 }
27518 return resultobj;
27519 fail:
27520 return NULL;
27521 }
27522
27523
27524 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
27525 PyObject *resultobj = NULL;
27526 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27527 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
27528 bool result;
27529 PyObject * obj0 = 0 ;
27530 PyObject * obj1 = 0 ;
27531 char *kwnames[] = {
27532 (char *) "self",(char *) "other", NULL
27533 };
27534
27535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
27536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27537 if (SWIG_arg_fail(1)) SWIG_fail;
27538 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27539 if (SWIG_arg_fail(2)) SWIG_fail;
27540 {
27541 PyThreadState* __tstate = wxPyBeginAllowThreads();
27542 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
27543
27544 wxPyEndAllowThreads(__tstate);
27545 if (PyErr_Occurred()) SWIG_fail;
27546 }
27547 {
27548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27549 }
27550 return resultobj;
27551 fail:
27552 return NULL;
27553 }
27554
27555
27556 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
27557 PyObject *resultobj = NULL;
27558 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27559 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
27560 bool result;
27561 PyObject * obj0 = 0 ;
27562 PyObject * obj1 = 0 ;
27563 char *kwnames[] = {
27564 (char *) "self",(char *) "other", NULL
27565 };
27566
27567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
27568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27569 if (SWIG_arg_fail(1)) SWIG_fail;
27570 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27571 if (SWIG_arg_fail(2)) SWIG_fail;
27572 {
27573 PyThreadState* __tstate = wxPyBeginAllowThreads();
27574 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
27575
27576 wxPyEndAllowThreads(__tstate);
27577 if (PyErr_Occurred()) SWIG_fail;
27578 }
27579 {
27580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27581 }
27582 return resultobj;
27583 fail:
27584 return NULL;
27585 }
27586
27587
27588 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
27589 PyObject *obj;
27590 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27591 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
27592 Py_INCREF(obj);
27593 return Py_BuildValue((char *)"");
27594 }
27595 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
27596 PyObject *resultobj = NULL;
27597 long result;
27598 char *kwnames[] = {
27599 NULL
27600 };
27601
27602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
27603 {
27604 PyThreadState* __tstate = wxPyBeginAllowThreads();
27605 result = (long)wxGetLocalTime();
27606
27607 wxPyEndAllowThreads(__tstate);
27608 if (PyErr_Occurred()) SWIG_fail;
27609 }
27610 {
27611 resultobj = SWIG_From_long(static_cast<long >(result));
27612 }
27613 return resultobj;
27614 fail:
27615 return NULL;
27616 }
27617
27618
27619 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
27620 PyObject *resultobj = NULL;
27621 long result;
27622 char *kwnames[] = {
27623 NULL
27624 };
27625
27626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
27627 {
27628 PyThreadState* __tstate = wxPyBeginAllowThreads();
27629 result = (long)wxGetUTCTime();
27630
27631 wxPyEndAllowThreads(__tstate);
27632 if (PyErr_Occurred()) SWIG_fail;
27633 }
27634 {
27635 resultobj = SWIG_From_long(static_cast<long >(result));
27636 }
27637 return resultobj;
27638 fail:
27639 return NULL;
27640 }
27641
27642
27643 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
27644 PyObject *resultobj = NULL;
27645 long result;
27646 char *kwnames[] = {
27647 NULL
27648 };
27649
27650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
27651 {
27652 PyThreadState* __tstate = wxPyBeginAllowThreads();
27653 result = (long)wxGetCurrentTime();
27654
27655 wxPyEndAllowThreads(__tstate);
27656 if (PyErr_Occurred()) SWIG_fail;
27657 }
27658 {
27659 resultobj = SWIG_From_long(static_cast<long >(result));
27660 }
27661 return resultobj;
27662 fail:
27663 return NULL;
27664 }
27665
27666
27667 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
27668 PyObject *resultobj = NULL;
27669 wxLongLong result;
27670 char *kwnames[] = {
27671 NULL
27672 };
27673
27674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
27675 {
27676 PyThreadState* __tstate = wxPyBeginAllowThreads();
27677 result = wxGetLocalTimeMillis();
27678
27679 wxPyEndAllowThreads(__tstate);
27680 if (PyErr_Occurred()) SWIG_fail;
27681 }
27682 {
27683 PyObject *hi, *lo, *shifter, *shifted;
27684 hi = PyLong_FromLong( (&result)->GetHi() );
27685 lo = PyLong_FromLong( (&result)->GetLo() );
27686 shifter = PyLong_FromLong(32);
27687 shifted = PyNumber_Lshift(hi, shifter);
27688 resultobj = PyNumber_Or(shifted, lo);
27689 Py_DECREF(hi);
27690 Py_DECREF(lo);
27691 Py_DECREF(shifter);
27692 Py_DECREF(shifted);
27693 }
27694 return resultobj;
27695 fail:
27696 return NULL;
27697 }
27698
27699
27700 static int _wrap_DefaultDateTime_set(PyObject *) {
27701 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
27702 return 1;
27703 }
27704
27705
27706 static PyObject *_wrap_DefaultDateTime_get(void) {
27707 PyObject *pyobj = NULL;
27708
27709 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
27710 return pyobj;
27711 }
27712
27713
27714 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27715 PyObject *resultobj = NULL;
27716 wxDataFormatId arg1 ;
27717 wxDataFormat *result;
27718 PyObject * obj0 = 0 ;
27719 char *kwnames[] = {
27720 (char *) "type", NULL
27721 };
27722
27723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
27724 {
27725 arg1 = static_cast<wxDataFormatId >(SWIG_As_int(obj0));
27726 if (SWIG_arg_fail(1)) SWIG_fail;
27727 }
27728 {
27729 PyThreadState* __tstate = wxPyBeginAllowThreads();
27730 result = (wxDataFormat *)new wxDataFormat(arg1);
27731
27732 wxPyEndAllowThreads(__tstate);
27733 if (PyErr_Occurred()) SWIG_fail;
27734 }
27735 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
27736 return resultobj;
27737 fail:
27738 return NULL;
27739 }
27740
27741
27742 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27743 PyObject *resultobj = NULL;
27744 wxString *arg1 = 0 ;
27745 wxDataFormat *result;
27746 bool temp1 = false ;
27747 PyObject * obj0 = 0 ;
27748 char *kwnames[] = {
27749 (char *) "format", NULL
27750 };
27751
27752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
27753 {
27754 arg1 = wxString_in_helper(obj0);
27755 if (arg1 == NULL) SWIG_fail;
27756 temp1 = true;
27757 }
27758 {
27759 PyThreadState* __tstate = wxPyBeginAllowThreads();
27760 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
27761
27762 wxPyEndAllowThreads(__tstate);
27763 if (PyErr_Occurred()) SWIG_fail;
27764 }
27765 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
27766 {
27767 if (temp1)
27768 delete arg1;
27769 }
27770 return resultobj;
27771 fail:
27772 {
27773 if (temp1)
27774 delete arg1;
27775 }
27776 return NULL;
27777 }
27778
27779
27780 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27781 PyObject *resultobj = NULL;
27782 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27783 PyObject * obj0 = 0 ;
27784 char *kwnames[] = {
27785 (char *) "self", NULL
27786 };
27787
27788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
27789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27790 if (SWIG_arg_fail(1)) SWIG_fail;
27791 {
27792 PyThreadState* __tstate = wxPyBeginAllowThreads();
27793 delete arg1;
27794
27795 wxPyEndAllowThreads(__tstate);
27796 if (PyErr_Occurred()) SWIG_fail;
27797 }
27798 Py_INCREF(Py_None); resultobj = Py_None;
27799 return resultobj;
27800 fail:
27801 return NULL;
27802 }
27803
27804
27805 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
27806 PyObject *resultobj = NULL;
27807 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27808 wxDataFormatId arg2 ;
27809 bool result;
27810 PyObject * obj0 = 0 ;
27811 PyObject * obj1 = 0 ;
27812
27813 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
27814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27815 if (SWIG_arg_fail(1)) SWIG_fail;
27816 {
27817 arg2 = static_cast<wxDataFormatId >(SWIG_As_int(obj1));
27818 if (SWIG_arg_fail(2)) SWIG_fail;
27819 }
27820 {
27821 PyThreadState* __tstate = wxPyBeginAllowThreads();
27822 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
27823
27824 wxPyEndAllowThreads(__tstate);
27825 if (PyErr_Occurred()) SWIG_fail;
27826 }
27827 {
27828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27829 }
27830 return resultobj;
27831 fail:
27832 return NULL;
27833 }
27834
27835
27836 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
27837 PyObject *resultobj = NULL;
27838 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27839 wxDataFormatId arg2 ;
27840 bool result;
27841 PyObject * obj0 = 0 ;
27842 PyObject * obj1 = 0 ;
27843
27844 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
27845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27846 if (SWIG_arg_fail(1)) SWIG_fail;
27847 {
27848 arg2 = static_cast<wxDataFormatId >(SWIG_As_int(obj1));
27849 if (SWIG_arg_fail(2)) SWIG_fail;
27850 }
27851 {
27852 PyThreadState* __tstate = wxPyBeginAllowThreads();
27853 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
27854
27855 wxPyEndAllowThreads(__tstate);
27856 if (PyErr_Occurred()) SWIG_fail;
27857 }
27858 {
27859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27860 }
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
27868 PyObject *resultobj = NULL;
27869 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27870 wxDataFormat *arg2 = 0 ;
27871 bool result;
27872 PyObject * obj0 = 0 ;
27873 PyObject * obj1 = 0 ;
27874
27875 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
27876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27877 if (SWIG_arg_fail(1)) SWIG_fail;
27878 {
27879 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27880 if (SWIG_arg_fail(2)) SWIG_fail;
27881 if (arg2 == NULL) {
27882 SWIG_null_ref("wxDataFormat");
27883 }
27884 if (SWIG_arg_fail(2)) SWIG_fail;
27885 }
27886 {
27887 PyThreadState* __tstate = wxPyBeginAllowThreads();
27888 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
27889
27890 wxPyEndAllowThreads(__tstate);
27891 if (PyErr_Occurred()) SWIG_fail;
27892 }
27893 {
27894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27895 }
27896 return resultobj;
27897 fail:
27898 return NULL;
27899 }
27900
27901
27902 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
27903 int argc;
27904 PyObject *argv[3];
27905 int ii;
27906
27907 argc = PyObject_Length(args);
27908 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
27909 argv[ii] = PyTuple_GetItem(args,ii);
27910 }
27911 if (argc == 2) {
27912 int _v;
27913 {
27914 void *ptr;
27915 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27916 _v = 0;
27917 PyErr_Clear();
27918 } else {
27919 _v = 1;
27920 }
27921 }
27922 if (_v) {
27923 {
27924 void *ptr = 0;
27925 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27926 _v = 0;
27927 PyErr_Clear();
27928 } else {
27929 _v = (ptr != 0);
27930 }
27931 }
27932 if (_v) {
27933 return _wrap_DataFormat___eq____SWIG_1(self,args);
27934 }
27935 }
27936 }
27937 if (argc == 2) {
27938 int _v;
27939 {
27940 void *ptr;
27941 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27942 _v = 0;
27943 PyErr_Clear();
27944 } else {
27945 _v = 1;
27946 }
27947 }
27948 if (_v) {
27949 _v = SWIG_Check_int(argv[1]);
27950 if (_v) {
27951 return _wrap_DataFormat___eq____SWIG_0(self,args);
27952 }
27953 }
27954 }
27955
27956 Py_INCREF(Py_NotImplemented);
27957 return Py_NotImplemented;
27958 }
27959
27960
27961 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
27962 PyObject *resultobj = NULL;
27963 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27964 wxDataFormat *arg2 = 0 ;
27965 bool result;
27966 PyObject * obj0 = 0 ;
27967 PyObject * obj1 = 0 ;
27968
27969 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
27970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27971 if (SWIG_arg_fail(1)) SWIG_fail;
27972 {
27973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27974 if (SWIG_arg_fail(2)) SWIG_fail;
27975 if (arg2 == NULL) {
27976 SWIG_null_ref("wxDataFormat");
27977 }
27978 if (SWIG_arg_fail(2)) SWIG_fail;
27979 }
27980 {
27981 PyThreadState* __tstate = wxPyBeginAllowThreads();
27982 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
27983
27984 wxPyEndAllowThreads(__tstate);
27985 if (PyErr_Occurred()) SWIG_fail;
27986 }
27987 {
27988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27989 }
27990 return resultobj;
27991 fail:
27992 return NULL;
27993 }
27994
27995
27996 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
27997 int argc;
27998 PyObject *argv[3];
27999 int ii;
28000
28001 argc = PyObject_Length(args);
28002 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
28003 argv[ii] = PyTuple_GetItem(args,ii);
28004 }
28005 if (argc == 2) {
28006 int _v;
28007 {
28008 void *ptr;
28009 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28010 _v = 0;
28011 PyErr_Clear();
28012 } else {
28013 _v = 1;
28014 }
28015 }
28016 if (_v) {
28017 {
28018 void *ptr = 0;
28019 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28020 _v = 0;
28021 PyErr_Clear();
28022 } else {
28023 _v = (ptr != 0);
28024 }
28025 }
28026 if (_v) {
28027 return _wrap_DataFormat___ne____SWIG_1(self,args);
28028 }
28029 }
28030 }
28031 if (argc == 2) {
28032 int _v;
28033 {
28034 void *ptr;
28035 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28036 _v = 0;
28037 PyErr_Clear();
28038 } else {
28039 _v = 1;
28040 }
28041 }
28042 if (_v) {
28043 _v = SWIG_Check_int(argv[1]);
28044 if (_v) {
28045 return _wrap_DataFormat___ne____SWIG_0(self,args);
28046 }
28047 }
28048 }
28049
28050 Py_INCREF(Py_NotImplemented);
28051 return Py_NotImplemented;
28052 }
28053
28054
28055 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
28056 PyObject *resultobj = NULL;
28057 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28058 wxDataFormatId arg2 ;
28059 PyObject * obj0 = 0 ;
28060 PyObject * obj1 = 0 ;
28061 char *kwnames[] = {
28062 (char *) "self",(char *) "format", NULL
28063 };
28064
28065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
28066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28067 if (SWIG_arg_fail(1)) SWIG_fail;
28068 {
28069 arg2 = static_cast<wxDataFormatId >(SWIG_As_int(obj1));
28070 if (SWIG_arg_fail(2)) SWIG_fail;
28071 }
28072 {
28073 PyThreadState* __tstate = wxPyBeginAllowThreads();
28074 (arg1)->SetType(arg2);
28075
28076 wxPyEndAllowThreads(__tstate);
28077 if (PyErr_Occurred()) SWIG_fail;
28078 }
28079 Py_INCREF(Py_None); resultobj = Py_None;
28080 return resultobj;
28081 fail:
28082 return NULL;
28083 }
28084
28085
28086 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
28087 PyObject *resultobj = NULL;
28088 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28089 wxDataFormatId result;
28090 PyObject * obj0 = 0 ;
28091 char *kwnames[] = {
28092 (char *) "self", NULL
28093 };
28094
28095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
28096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28097 if (SWIG_arg_fail(1)) SWIG_fail;
28098 {
28099 PyThreadState* __tstate = wxPyBeginAllowThreads();
28100 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
28101
28102 wxPyEndAllowThreads(__tstate);
28103 if (PyErr_Occurred()) SWIG_fail;
28104 }
28105 resultobj = SWIG_From_int((result));
28106 return resultobj;
28107 fail:
28108 return NULL;
28109 }
28110
28111
28112 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
28113 PyObject *resultobj = NULL;
28114 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28115 wxString result;
28116 PyObject * obj0 = 0 ;
28117 char *kwnames[] = {
28118 (char *) "self", NULL
28119 };
28120
28121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
28122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28123 if (SWIG_arg_fail(1)) SWIG_fail;
28124 {
28125 PyThreadState* __tstate = wxPyBeginAllowThreads();
28126 result = ((wxDataFormat const *)arg1)->GetId();
28127
28128 wxPyEndAllowThreads(__tstate);
28129 if (PyErr_Occurred()) SWIG_fail;
28130 }
28131 {
28132 #if wxUSE_UNICODE
28133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28134 #else
28135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28136 #endif
28137 }
28138 return resultobj;
28139 fail:
28140 return NULL;
28141 }
28142
28143
28144 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
28145 PyObject *resultobj = NULL;
28146 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28147 wxString *arg2 = 0 ;
28148 bool temp2 = false ;
28149 PyObject * obj0 = 0 ;
28150 PyObject * obj1 = 0 ;
28151 char *kwnames[] = {
28152 (char *) "self",(char *) "format", NULL
28153 };
28154
28155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
28156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28157 if (SWIG_arg_fail(1)) SWIG_fail;
28158 {
28159 arg2 = wxString_in_helper(obj1);
28160 if (arg2 == NULL) SWIG_fail;
28161 temp2 = true;
28162 }
28163 {
28164 PyThreadState* __tstate = wxPyBeginAllowThreads();
28165 (arg1)->SetId((wxString const &)*arg2);
28166
28167 wxPyEndAllowThreads(__tstate);
28168 if (PyErr_Occurred()) SWIG_fail;
28169 }
28170 Py_INCREF(Py_None); resultobj = Py_None;
28171 {
28172 if (temp2)
28173 delete arg2;
28174 }
28175 return resultobj;
28176 fail:
28177 {
28178 if (temp2)
28179 delete arg2;
28180 }
28181 return NULL;
28182 }
28183
28184
28185 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
28186 PyObject *obj;
28187 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28188 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
28189 Py_INCREF(obj);
28190 return Py_BuildValue((char *)"");
28191 }
28192 static int _wrap_FormatInvalid_set(PyObject *) {
28193 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
28194 return 1;
28195 }
28196
28197
28198 static PyObject *_wrap_FormatInvalid_get(void) {
28199 PyObject *pyobj = NULL;
28200
28201 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
28202 return pyobj;
28203 }
28204
28205
28206 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28207 PyObject *resultobj = NULL;
28208 wxDataObject *arg1 = (wxDataObject *) 0 ;
28209 PyObject * obj0 = 0 ;
28210 char *kwnames[] = {
28211 (char *) "self", NULL
28212 };
28213
28214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
28215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28216 if (SWIG_arg_fail(1)) SWIG_fail;
28217 {
28218 PyThreadState* __tstate = wxPyBeginAllowThreads();
28219 delete arg1;
28220
28221 wxPyEndAllowThreads(__tstate);
28222 if (PyErr_Occurred()) SWIG_fail;
28223 }
28224 Py_INCREF(Py_None); resultobj = Py_None;
28225 return resultobj;
28226 fail:
28227 return NULL;
28228 }
28229
28230
28231 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
28232 PyObject *resultobj = NULL;
28233 wxDataObject *arg1 = (wxDataObject *) 0 ;
28234 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
28235 SwigValueWrapper<wxDataFormat > result;
28236 PyObject * obj0 = 0 ;
28237 PyObject * obj1 = 0 ;
28238 char *kwnames[] = {
28239 (char *) "self",(char *) "dir", NULL
28240 };
28241
28242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
28243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28244 if (SWIG_arg_fail(1)) SWIG_fail;
28245 if (obj1) {
28246 {
28247 arg2 = static_cast<wxDataObject::Direction >(SWIG_As_int(obj1));
28248 if (SWIG_arg_fail(2)) SWIG_fail;
28249 }
28250 }
28251 {
28252 PyThreadState* __tstate = wxPyBeginAllowThreads();
28253 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
28254
28255 wxPyEndAllowThreads(__tstate);
28256 if (PyErr_Occurred()) SWIG_fail;
28257 }
28258 {
28259 wxDataFormat * resultptr;
28260 resultptr = new wxDataFormat(static_cast<wxDataFormat & >(result));
28261 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
28262 }
28263 return resultobj;
28264 fail:
28265 return NULL;
28266 }
28267
28268
28269 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
28270 PyObject *resultobj = NULL;
28271 wxDataObject *arg1 = (wxDataObject *) 0 ;
28272 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
28273 size_t result;
28274 PyObject * obj0 = 0 ;
28275 PyObject * obj1 = 0 ;
28276 char *kwnames[] = {
28277 (char *) "self",(char *) "dir", NULL
28278 };
28279
28280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
28281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28282 if (SWIG_arg_fail(1)) SWIG_fail;
28283 if (obj1) {
28284 {
28285 arg2 = static_cast<wxDataObject::Direction >(SWIG_As_int(obj1));
28286 if (SWIG_arg_fail(2)) SWIG_fail;
28287 }
28288 }
28289 {
28290 PyThreadState* __tstate = wxPyBeginAllowThreads();
28291 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
28292
28293 wxPyEndAllowThreads(__tstate);
28294 if (PyErr_Occurred()) SWIG_fail;
28295 }
28296 {
28297 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
28298 }
28299 return resultobj;
28300 fail:
28301 return NULL;
28302 }
28303
28304
28305 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
28306 PyObject *resultobj = NULL;
28307 wxDataObject *arg1 = (wxDataObject *) 0 ;
28308 wxDataFormat *arg2 = 0 ;
28309 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
28310 bool result;
28311 PyObject * obj0 = 0 ;
28312 PyObject * obj1 = 0 ;
28313 PyObject * obj2 = 0 ;
28314 char *kwnames[] = {
28315 (char *) "self",(char *) "format",(char *) "dir", NULL
28316 };
28317
28318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
28319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28320 if (SWIG_arg_fail(1)) SWIG_fail;
28321 {
28322 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28323 if (SWIG_arg_fail(2)) SWIG_fail;
28324 if (arg2 == NULL) {
28325 SWIG_null_ref("wxDataFormat");
28326 }
28327 if (SWIG_arg_fail(2)) SWIG_fail;
28328 }
28329 if (obj2) {
28330 {
28331 arg3 = static_cast<wxDataObject::Direction >(SWIG_As_int(obj2));
28332 if (SWIG_arg_fail(3)) SWIG_fail;
28333 }
28334 }
28335 {
28336 PyThreadState* __tstate = wxPyBeginAllowThreads();
28337 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
28338
28339 wxPyEndAllowThreads(__tstate);
28340 if (PyErr_Occurred()) SWIG_fail;
28341 }
28342 {
28343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28344 }
28345 return resultobj;
28346 fail:
28347 return NULL;
28348 }
28349
28350
28351 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
28352 PyObject *resultobj = NULL;
28353 wxDataObject *arg1 = (wxDataObject *) 0 ;
28354 wxDataFormat *arg2 = 0 ;
28355 size_t result;
28356 PyObject * obj0 = 0 ;
28357 PyObject * obj1 = 0 ;
28358 char *kwnames[] = {
28359 (char *) "self",(char *) "format", NULL
28360 };
28361
28362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
28363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28364 if (SWIG_arg_fail(1)) SWIG_fail;
28365 {
28366 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28367 if (SWIG_arg_fail(2)) SWIG_fail;
28368 if (arg2 == NULL) {
28369 SWIG_null_ref("wxDataFormat");
28370 }
28371 if (SWIG_arg_fail(2)) SWIG_fail;
28372 }
28373 {
28374 PyThreadState* __tstate = wxPyBeginAllowThreads();
28375 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
28376
28377 wxPyEndAllowThreads(__tstate);
28378 if (PyErr_Occurred()) SWIG_fail;
28379 }
28380 {
28381 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
28382 }
28383 return resultobj;
28384 fail:
28385 return NULL;
28386 }
28387
28388
28389 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
28390 PyObject *resultobj = NULL;
28391 wxDataObject *arg1 = (wxDataObject *) 0 ;
28392 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
28393 PyObject *result;
28394 PyObject * obj0 = 0 ;
28395 PyObject * obj1 = 0 ;
28396 char *kwnames[] = {
28397 (char *) "self",(char *) "dir", NULL
28398 };
28399
28400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
28401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28402 if (SWIG_arg_fail(1)) SWIG_fail;
28403 if (obj1) {
28404 {
28405 arg2 = static_cast<wxDataObject::Direction >(SWIG_As_int(obj1));
28406 if (SWIG_arg_fail(2)) SWIG_fail;
28407 }
28408 }
28409 {
28410 PyThreadState* __tstate = wxPyBeginAllowThreads();
28411 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
28412
28413 wxPyEndAllowThreads(__tstate);
28414 if (PyErr_Occurred()) SWIG_fail;
28415 }
28416 resultobj = result;
28417 return resultobj;
28418 fail:
28419 return NULL;
28420 }
28421
28422
28423 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
28424 PyObject *resultobj = NULL;
28425 wxDataObject *arg1 = (wxDataObject *) 0 ;
28426 wxDataFormat *arg2 = 0 ;
28427 PyObject *result;
28428 PyObject * obj0 = 0 ;
28429 PyObject * obj1 = 0 ;
28430 char *kwnames[] = {
28431 (char *) "self",(char *) "format", NULL
28432 };
28433
28434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
28435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28436 if (SWIG_arg_fail(1)) SWIG_fail;
28437 {
28438 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28439 if (SWIG_arg_fail(2)) SWIG_fail;
28440 if (arg2 == NULL) {
28441 SWIG_null_ref("wxDataFormat");
28442 }
28443 if (SWIG_arg_fail(2)) SWIG_fail;
28444 }
28445 {
28446 PyThreadState* __tstate = wxPyBeginAllowThreads();
28447 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
28448
28449 wxPyEndAllowThreads(__tstate);
28450 if (PyErr_Occurred()) SWIG_fail;
28451 }
28452 resultobj = result;
28453 return resultobj;
28454 fail:
28455 return NULL;
28456 }
28457
28458
28459 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28460 PyObject *resultobj = NULL;
28461 wxDataObject *arg1 = (wxDataObject *) 0 ;
28462 wxDataFormat *arg2 = 0 ;
28463 PyObject *arg3 = (PyObject *) 0 ;
28464 bool result;
28465 PyObject * obj0 = 0 ;
28466 PyObject * obj1 = 0 ;
28467 PyObject * obj2 = 0 ;
28468 char *kwnames[] = {
28469 (char *) "self",(char *) "format",(char *) "data", NULL
28470 };
28471
28472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
28473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28474 if (SWIG_arg_fail(1)) SWIG_fail;
28475 {
28476 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28477 if (SWIG_arg_fail(2)) SWIG_fail;
28478 if (arg2 == NULL) {
28479 SWIG_null_ref("wxDataFormat");
28480 }
28481 if (SWIG_arg_fail(2)) SWIG_fail;
28482 }
28483 arg3 = obj2;
28484 {
28485 PyThreadState* __tstate = wxPyBeginAllowThreads();
28486 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
28487
28488 wxPyEndAllowThreads(__tstate);
28489 if (PyErr_Occurred()) SWIG_fail;
28490 }
28491 {
28492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28493 }
28494 return resultobj;
28495 fail:
28496 return NULL;
28497 }
28498
28499
28500 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
28501 PyObject *obj;
28502 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28503 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
28504 Py_INCREF(obj);
28505 return Py_BuildValue((char *)"");
28506 }
28507 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
28508 PyObject *resultobj = NULL;
28509 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
28510 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
28511 wxDataObjectSimple *result;
28512 PyObject * obj0 = 0 ;
28513 char *kwnames[] = {
28514 (char *) "format", NULL
28515 };
28516
28517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
28518 if (obj0) {
28519 {
28520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28521 if (SWIG_arg_fail(1)) SWIG_fail;
28522 if (arg1 == NULL) {
28523 SWIG_null_ref("wxDataFormat");
28524 }
28525 if (SWIG_arg_fail(1)) SWIG_fail;
28526 }
28527 }
28528 {
28529 PyThreadState* __tstate = wxPyBeginAllowThreads();
28530 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
28531
28532 wxPyEndAllowThreads(__tstate);
28533 if (PyErr_Occurred()) SWIG_fail;
28534 }
28535 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
28536 return resultobj;
28537 fail:
28538 return NULL;
28539 }
28540
28541
28542 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
28543 PyObject *resultobj = NULL;
28544 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28545 wxDataFormat *result;
28546 PyObject * obj0 = 0 ;
28547 char *kwnames[] = {
28548 (char *) "self", NULL
28549 };
28550
28551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
28552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28553 if (SWIG_arg_fail(1)) SWIG_fail;
28554 {
28555 PyThreadState* __tstate = wxPyBeginAllowThreads();
28556 {
28557 wxDataFormat const &_result_ref = (arg1)->GetFormat();
28558 result = (wxDataFormat *) &_result_ref;
28559 }
28560
28561 wxPyEndAllowThreads(__tstate);
28562 if (PyErr_Occurred()) SWIG_fail;
28563 }
28564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
28565 return resultobj;
28566 fail:
28567 return NULL;
28568 }
28569
28570
28571 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
28572 PyObject *resultobj = NULL;
28573 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28574 wxDataFormat *arg2 = 0 ;
28575 PyObject * obj0 = 0 ;
28576 PyObject * obj1 = 0 ;
28577 char *kwnames[] = {
28578 (char *) "self",(char *) "format", NULL
28579 };
28580
28581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
28582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28583 if (SWIG_arg_fail(1)) SWIG_fail;
28584 {
28585 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28586 if (SWIG_arg_fail(2)) SWIG_fail;
28587 if (arg2 == NULL) {
28588 SWIG_null_ref("wxDataFormat");
28589 }
28590 if (SWIG_arg_fail(2)) SWIG_fail;
28591 }
28592 {
28593 PyThreadState* __tstate = wxPyBeginAllowThreads();
28594 (arg1)->SetFormat((wxDataFormat const &)*arg2);
28595
28596 wxPyEndAllowThreads(__tstate);
28597 if (PyErr_Occurred()) SWIG_fail;
28598 }
28599 Py_INCREF(Py_None); resultobj = Py_None;
28600 return resultobj;
28601 fail:
28602 return NULL;
28603 }
28604
28605
28606 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
28607 PyObject *resultobj = NULL;
28608 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28609 size_t result;
28610 PyObject * obj0 = 0 ;
28611 char *kwnames[] = {
28612 (char *) "self", NULL
28613 };
28614
28615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
28616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28617 if (SWIG_arg_fail(1)) SWIG_fail;
28618 {
28619 PyThreadState* __tstate = wxPyBeginAllowThreads();
28620 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
28621
28622 wxPyEndAllowThreads(__tstate);
28623 if (PyErr_Occurred()) SWIG_fail;
28624 }
28625 {
28626 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
28627 }
28628 return resultobj;
28629 fail:
28630 return NULL;
28631 }
28632
28633
28634 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
28635 PyObject *resultobj = NULL;
28636 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28637 PyObject *result;
28638 PyObject * obj0 = 0 ;
28639 char *kwnames[] = {
28640 (char *) "self", NULL
28641 };
28642
28643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
28644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28645 if (SWIG_arg_fail(1)) SWIG_fail;
28646 {
28647 PyThreadState* __tstate = wxPyBeginAllowThreads();
28648 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
28649
28650 wxPyEndAllowThreads(__tstate);
28651 if (PyErr_Occurred()) SWIG_fail;
28652 }
28653 resultobj = result;
28654 return resultobj;
28655 fail:
28656 return NULL;
28657 }
28658
28659
28660 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28661 PyObject *resultobj = NULL;
28662 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28663 PyObject *arg2 = (PyObject *) 0 ;
28664 bool result;
28665 PyObject * obj0 = 0 ;
28666 PyObject * obj1 = 0 ;
28667 char *kwnames[] = {
28668 (char *) "self",(char *) "data", NULL
28669 };
28670
28671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
28672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28673 if (SWIG_arg_fail(1)) SWIG_fail;
28674 arg2 = obj1;
28675 {
28676 PyThreadState* __tstate = wxPyBeginAllowThreads();
28677 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
28678
28679 wxPyEndAllowThreads(__tstate);
28680 if (PyErr_Occurred()) SWIG_fail;
28681 }
28682 {
28683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28684 }
28685 return resultobj;
28686 fail:
28687 return NULL;
28688 }
28689
28690
28691 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
28692 PyObject *obj;
28693 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28694 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
28695 Py_INCREF(obj);
28696 return Py_BuildValue((char *)"");
28697 }
28698 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
28699 PyObject *resultobj = NULL;
28700 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
28701 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
28702 wxPyDataObjectSimple *result;
28703 PyObject * obj0 = 0 ;
28704 char *kwnames[] = {
28705 (char *) "format", NULL
28706 };
28707
28708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
28709 if (obj0) {
28710 {
28711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28712 if (SWIG_arg_fail(1)) SWIG_fail;
28713 if (arg1 == NULL) {
28714 SWIG_null_ref("wxDataFormat");
28715 }
28716 if (SWIG_arg_fail(1)) SWIG_fail;
28717 }
28718 }
28719 {
28720 PyThreadState* __tstate = wxPyBeginAllowThreads();
28721 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
28722
28723 wxPyEndAllowThreads(__tstate);
28724 if (PyErr_Occurred()) SWIG_fail;
28725 }
28726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
28727 return resultobj;
28728 fail:
28729 return NULL;
28730 }
28731
28732
28733 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28734 PyObject *resultobj = NULL;
28735 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
28736 PyObject *arg2 = (PyObject *) 0 ;
28737 PyObject *arg3 = (PyObject *) 0 ;
28738 PyObject * obj0 = 0 ;
28739 PyObject * obj1 = 0 ;
28740 PyObject * obj2 = 0 ;
28741 char *kwnames[] = {
28742 (char *) "self",(char *) "self",(char *) "_class", NULL
28743 };
28744
28745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28747 if (SWIG_arg_fail(1)) SWIG_fail;
28748 arg2 = obj1;
28749 arg3 = obj2;
28750 {
28751 PyThreadState* __tstate = wxPyBeginAllowThreads();
28752 (arg1)->_setCallbackInfo(arg2,arg3);
28753
28754 wxPyEndAllowThreads(__tstate);
28755 if (PyErr_Occurred()) SWIG_fail;
28756 }
28757 Py_INCREF(Py_None); resultobj = Py_None;
28758 return resultobj;
28759 fail:
28760 return NULL;
28761 }
28762
28763
28764 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
28765 PyObject *obj;
28766 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28767 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
28768 Py_INCREF(obj);
28769 return Py_BuildValue((char *)"");
28770 }
28771 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
28772 PyObject *resultobj = NULL;
28773 wxDataObjectComposite *result;
28774 char *kwnames[] = {
28775 NULL
28776 };
28777
28778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
28779 {
28780 PyThreadState* __tstate = wxPyBeginAllowThreads();
28781 result = (wxDataObjectComposite *)new wxDataObjectComposite();
28782
28783 wxPyEndAllowThreads(__tstate);
28784 if (PyErr_Occurred()) SWIG_fail;
28785 }
28786 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
28787 return resultobj;
28788 fail:
28789 return NULL;
28790 }
28791
28792
28793 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
28794 PyObject *resultobj = NULL;
28795 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
28796 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
28797 bool arg3 = (bool) false ;
28798 PyObject * obj0 = 0 ;
28799 PyObject * obj1 = 0 ;
28800 PyObject * obj2 = 0 ;
28801 char *kwnames[] = {
28802 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
28803 };
28804
28805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
28806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
28807 if (SWIG_arg_fail(1)) SWIG_fail;
28808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28809 if (SWIG_arg_fail(2)) SWIG_fail;
28810 if (obj2) {
28811 {
28812 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
28813 if (SWIG_arg_fail(3)) SWIG_fail;
28814 }
28815 }
28816 {
28817 PyThreadState* __tstate = wxPyBeginAllowThreads();
28818 (arg1)->Add(arg2,arg3);
28819
28820 wxPyEndAllowThreads(__tstate);
28821 if (PyErr_Occurred()) SWIG_fail;
28822 }
28823 Py_INCREF(Py_None); resultobj = Py_None;
28824 return resultobj;
28825 fail:
28826 return NULL;
28827 }
28828
28829
28830 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
28831 PyObject *obj;
28832 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28833 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
28834 Py_INCREF(obj);
28835 return Py_BuildValue((char *)"");
28836 }
28837 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28838 PyObject *resultobj = NULL;
28839 wxString const &arg1_defvalue = wxPyEmptyString ;
28840 wxString *arg1 = (wxString *) &arg1_defvalue ;
28841 wxTextDataObject *result;
28842 bool temp1 = false ;
28843 PyObject * obj0 = 0 ;
28844 char *kwnames[] = {
28845 (char *) "text", NULL
28846 };
28847
28848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
28849 if (obj0) {
28850 {
28851 arg1 = wxString_in_helper(obj0);
28852 if (arg1 == NULL) SWIG_fail;
28853 temp1 = true;
28854 }
28855 }
28856 {
28857 PyThreadState* __tstate = wxPyBeginAllowThreads();
28858 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
28859
28860 wxPyEndAllowThreads(__tstate);
28861 if (PyErr_Occurred()) SWIG_fail;
28862 }
28863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
28864 {
28865 if (temp1)
28866 delete arg1;
28867 }
28868 return resultobj;
28869 fail:
28870 {
28871 if (temp1)
28872 delete arg1;
28873 }
28874 return NULL;
28875 }
28876
28877
28878 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
28879 PyObject *resultobj = NULL;
28880 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
28881 size_t result;
28882 PyObject * obj0 = 0 ;
28883 char *kwnames[] = {
28884 (char *) "self", NULL
28885 };
28886
28887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
28888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28889 if (SWIG_arg_fail(1)) SWIG_fail;
28890 {
28891 PyThreadState* __tstate = wxPyBeginAllowThreads();
28892 result = (size_t)(arg1)->GetTextLength();
28893
28894 wxPyEndAllowThreads(__tstate);
28895 if (PyErr_Occurred()) SWIG_fail;
28896 }
28897 {
28898 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
28899 }
28900 return resultobj;
28901 fail:
28902 return NULL;
28903 }
28904
28905
28906 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
28907 PyObject *resultobj = NULL;
28908 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
28909 wxString result;
28910 PyObject * obj0 = 0 ;
28911 char *kwnames[] = {
28912 (char *) "self", NULL
28913 };
28914
28915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
28916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28917 if (SWIG_arg_fail(1)) SWIG_fail;
28918 {
28919 PyThreadState* __tstate = wxPyBeginAllowThreads();
28920 result = (arg1)->GetText();
28921
28922 wxPyEndAllowThreads(__tstate);
28923 if (PyErr_Occurred()) SWIG_fail;
28924 }
28925 {
28926 #if wxUSE_UNICODE
28927 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28928 #else
28929 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28930 #endif
28931 }
28932 return resultobj;
28933 fail:
28934 return NULL;
28935 }
28936
28937
28938 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
28939 PyObject *resultobj = NULL;
28940 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
28941 wxString *arg2 = 0 ;
28942 bool temp2 = false ;
28943 PyObject * obj0 = 0 ;
28944 PyObject * obj1 = 0 ;
28945 char *kwnames[] = {
28946 (char *) "self",(char *) "text", NULL
28947 };
28948
28949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
28950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28951 if (SWIG_arg_fail(1)) SWIG_fail;
28952 {
28953 arg2 = wxString_in_helper(obj1);
28954 if (arg2 == NULL) SWIG_fail;
28955 temp2 = true;
28956 }
28957 {
28958 PyThreadState* __tstate = wxPyBeginAllowThreads();
28959 (arg1)->SetText((wxString const &)*arg2);
28960
28961 wxPyEndAllowThreads(__tstate);
28962 if (PyErr_Occurred()) SWIG_fail;
28963 }
28964 Py_INCREF(Py_None); resultobj = Py_None;
28965 {
28966 if (temp2)
28967 delete arg2;
28968 }
28969 return resultobj;
28970 fail:
28971 {
28972 if (temp2)
28973 delete arg2;
28974 }
28975 return NULL;
28976 }
28977
28978
28979 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
28980 PyObject *obj;
28981 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28982 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
28983 Py_INCREF(obj);
28984 return Py_BuildValue((char *)"");
28985 }
28986 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28987 PyObject *resultobj = NULL;
28988 wxString const &arg1_defvalue = wxPyEmptyString ;
28989 wxString *arg1 = (wxString *) &arg1_defvalue ;
28990 wxPyTextDataObject *result;
28991 bool temp1 = false ;
28992 PyObject * obj0 = 0 ;
28993 char *kwnames[] = {
28994 (char *) "text", NULL
28995 };
28996
28997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
28998 if (obj0) {
28999 {
29000 arg1 = wxString_in_helper(obj0);
29001 if (arg1 == NULL) SWIG_fail;
29002 temp1 = true;
29003 }
29004 }
29005 {
29006 PyThreadState* __tstate = wxPyBeginAllowThreads();
29007 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
29008
29009 wxPyEndAllowThreads(__tstate);
29010 if (PyErr_Occurred()) SWIG_fail;
29011 }
29012 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
29013 {
29014 if (temp1)
29015 delete arg1;
29016 }
29017 return resultobj;
29018 fail:
29019 {
29020 if (temp1)
29021 delete arg1;
29022 }
29023 return NULL;
29024 }
29025
29026
29027 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29028 PyObject *resultobj = NULL;
29029 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
29030 PyObject *arg2 = (PyObject *) 0 ;
29031 PyObject *arg3 = (PyObject *) 0 ;
29032 PyObject * obj0 = 0 ;
29033 PyObject * obj1 = 0 ;
29034 PyObject * obj2 = 0 ;
29035 char *kwnames[] = {
29036 (char *) "self",(char *) "self",(char *) "_class", NULL
29037 };
29038
29039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
29041 if (SWIG_arg_fail(1)) SWIG_fail;
29042 arg2 = obj1;
29043 arg3 = obj2;
29044 {
29045 PyThreadState* __tstate = wxPyBeginAllowThreads();
29046 (arg1)->_setCallbackInfo(arg2,arg3);
29047
29048 wxPyEndAllowThreads(__tstate);
29049 if (PyErr_Occurred()) SWIG_fail;
29050 }
29051 Py_INCREF(Py_None); resultobj = Py_None;
29052 return resultobj;
29053 fail:
29054 return NULL;
29055 }
29056
29057
29058 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
29059 PyObject *obj;
29060 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29061 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
29062 Py_INCREF(obj);
29063 return Py_BuildValue((char *)"");
29064 }
29065 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29066 PyObject *resultobj = NULL;
29067 wxBitmap const &arg1_defvalue = wxNullBitmap ;
29068 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
29069 wxBitmapDataObject *result;
29070 PyObject * obj0 = 0 ;
29071 char *kwnames[] = {
29072 (char *) "bitmap", NULL
29073 };
29074
29075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
29076 if (obj0) {
29077 {
29078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
29079 if (SWIG_arg_fail(1)) SWIG_fail;
29080 if (arg1 == NULL) {
29081 SWIG_null_ref("wxBitmap");
29082 }
29083 if (SWIG_arg_fail(1)) SWIG_fail;
29084 }
29085 }
29086 {
29087 PyThreadState* __tstate = wxPyBeginAllowThreads();
29088 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
29089
29090 wxPyEndAllowThreads(__tstate);
29091 if (PyErr_Occurred()) SWIG_fail;
29092 }
29093 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
29094 return resultobj;
29095 fail:
29096 return NULL;
29097 }
29098
29099
29100 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
29101 PyObject *resultobj = NULL;
29102 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
29103 wxBitmap result;
29104 PyObject * obj0 = 0 ;
29105 char *kwnames[] = {
29106 (char *) "self", NULL
29107 };
29108
29109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
29110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
29111 if (SWIG_arg_fail(1)) SWIG_fail;
29112 {
29113 PyThreadState* __tstate = wxPyBeginAllowThreads();
29114 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
29115
29116 wxPyEndAllowThreads(__tstate);
29117 if (PyErr_Occurred()) SWIG_fail;
29118 }
29119 {
29120 wxBitmap * resultptr;
29121 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
29122 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
29123 }
29124 return resultobj;
29125 fail:
29126 return NULL;
29127 }
29128
29129
29130 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
29131 PyObject *resultobj = NULL;
29132 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
29133 wxBitmap *arg2 = 0 ;
29134 PyObject * obj0 = 0 ;
29135 PyObject * obj1 = 0 ;
29136 char *kwnames[] = {
29137 (char *) "self",(char *) "bitmap", NULL
29138 };
29139
29140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
29141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
29142 if (SWIG_arg_fail(1)) SWIG_fail;
29143 {
29144 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
29145 if (SWIG_arg_fail(2)) SWIG_fail;
29146 if (arg2 == NULL) {
29147 SWIG_null_ref("wxBitmap");
29148 }
29149 if (SWIG_arg_fail(2)) SWIG_fail;
29150 }
29151 {
29152 PyThreadState* __tstate = wxPyBeginAllowThreads();
29153 (arg1)->SetBitmap((wxBitmap const &)*arg2);
29154
29155 wxPyEndAllowThreads(__tstate);
29156 if (PyErr_Occurred()) SWIG_fail;
29157 }
29158 Py_INCREF(Py_None); resultobj = Py_None;
29159 return resultobj;
29160 fail:
29161 return NULL;
29162 }
29163
29164
29165 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
29166 PyObject *obj;
29167 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29168 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
29169 Py_INCREF(obj);
29170 return Py_BuildValue((char *)"");
29171 }
29172 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29173 PyObject *resultobj = NULL;
29174 wxBitmap const &arg1_defvalue = wxNullBitmap ;
29175 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
29176 wxPyBitmapDataObject *result;
29177 PyObject * obj0 = 0 ;
29178 char *kwnames[] = {
29179 (char *) "bitmap", NULL
29180 };
29181
29182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
29183 if (obj0) {
29184 {
29185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
29186 if (SWIG_arg_fail(1)) SWIG_fail;
29187 if (arg1 == NULL) {
29188 SWIG_null_ref("wxBitmap");
29189 }
29190 if (SWIG_arg_fail(1)) SWIG_fail;
29191 }
29192 }
29193 {
29194 PyThreadState* __tstate = wxPyBeginAllowThreads();
29195 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
29196
29197 wxPyEndAllowThreads(__tstate);
29198 if (PyErr_Occurred()) SWIG_fail;
29199 }
29200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
29201 return resultobj;
29202 fail:
29203 return NULL;
29204 }
29205
29206
29207 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29208 PyObject *resultobj = NULL;
29209 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
29210 PyObject *arg2 = (PyObject *) 0 ;
29211 PyObject *arg3 = (PyObject *) 0 ;
29212 PyObject * obj0 = 0 ;
29213 PyObject * obj1 = 0 ;
29214 PyObject * obj2 = 0 ;
29215 char *kwnames[] = {
29216 (char *) "self",(char *) "self",(char *) "_class", NULL
29217 };
29218
29219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
29221 if (SWIG_arg_fail(1)) SWIG_fail;
29222 arg2 = obj1;
29223 arg3 = obj2;
29224 {
29225 PyThreadState* __tstate = wxPyBeginAllowThreads();
29226 (arg1)->_setCallbackInfo(arg2,arg3);
29227
29228 wxPyEndAllowThreads(__tstate);
29229 if (PyErr_Occurred()) SWIG_fail;
29230 }
29231 Py_INCREF(Py_None); resultobj = Py_None;
29232 return resultobj;
29233 fail:
29234 return NULL;
29235 }
29236
29237
29238 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
29239 PyObject *obj;
29240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29241 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
29242 Py_INCREF(obj);
29243 return Py_BuildValue((char *)"");
29244 }
29245 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29246 PyObject *resultobj = NULL;
29247 wxFileDataObject *result;
29248 char *kwnames[] = {
29249 NULL
29250 };
29251
29252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
29253 {
29254 PyThreadState* __tstate = wxPyBeginAllowThreads();
29255 result = (wxFileDataObject *)new wxFileDataObject();
29256
29257 wxPyEndAllowThreads(__tstate);
29258 if (PyErr_Occurred()) SWIG_fail;
29259 }
29260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
29261 return resultobj;
29262 fail:
29263 return NULL;
29264 }
29265
29266
29267 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
29268 PyObject *resultobj = NULL;
29269 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
29270 wxArrayString *result;
29271 PyObject * obj0 = 0 ;
29272 char *kwnames[] = {
29273 (char *) "self", NULL
29274 };
29275
29276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
29277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
29278 if (SWIG_arg_fail(1)) SWIG_fail;
29279 {
29280 PyThreadState* __tstate = wxPyBeginAllowThreads();
29281 {
29282 wxArrayString const &_result_ref = (arg1)->GetFilenames();
29283 result = (wxArrayString *) &_result_ref;
29284 }
29285
29286 wxPyEndAllowThreads(__tstate);
29287 if (PyErr_Occurred()) SWIG_fail;
29288 }
29289 {
29290 resultobj = wxArrayString2PyList_helper(*result);
29291 }
29292 return resultobj;
29293 fail:
29294 return NULL;
29295 }
29296
29297
29298 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
29299 PyObject *resultobj = NULL;
29300 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
29301 wxString *arg2 = 0 ;
29302 bool temp2 = false ;
29303 PyObject * obj0 = 0 ;
29304 PyObject * obj1 = 0 ;
29305 char *kwnames[] = {
29306 (char *) "self",(char *) "filename", NULL
29307 };
29308
29309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
29310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
29311 if (SWIG_arg_fail(1)) SWIG_fail;
29312 {
29313 arg2 = wxString_in_helper(obj1);
29314 if (arg2 == NULL) SWIG_fail;
29315 temp2 = true;
29316 }
29317 {
29318 PyThreadState* __tstate = wxPyBeginAllowThreads();
29319 (arg1)->AddFile((wxString const &)*arg2);
29320
29321 wxPyEndAllowThreads(__tstate);
29322 if (PyErr_Occurred()) SWIG_fail;
29323 }
29324 Py_INCREF(Py_None); resultobj = Py_None;
29325 {
29326 if (temp2)
29327 delete arg2;
29328 }
29329 return resultobj;
29330 fail:
29331 {
29332 if (temp2)
29333 delete arg2;
29334 }
29335 return NULL;
29336 }
29337
29338
29339 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
29340 PyObject *obj;
29341 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29342 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
29343 Py_INCREF(obj);
29344 return Py_BuildValue((char *)"");
29345 }
29346 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
29347 PyObject *resultobj = NULL;
29348 wxDataFormat *arg1 = 0 ;
29349 wxCustomDataObject *result;
29350 PyObject * obj0 = 0 ;
29351
29352 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
29353 {
29354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29355 if (SWIG_arg_fail(1)) SWIG_fail;
29356 if (arg1 == NULL) {
29357 SWIG_null_ref("wxDataFormat");
29358 }
29359 if (SWIG_arg_fail(1)) SWIG_fail;
29360 }
29361 {
29362 PyThreadState* __tstate = wxPyBeginAllowThreads();
29363 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
29364
29365 wxPyEndAllowThreads(__tstate);
29366 if (PyErr_Occurred()) SWIG_fail;
29367 }
29368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
29369 return resultobj;
29370 fail:
29371 return NULL;
29372 }
29373
29374
29375 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
29376 PyObject *resultobj = NULL;
29377 wxString *arg1 = 0 ;
29378 wxCustomDataObject *result;
29379 bool temp1 = false ;
29380 PyObject * obj0 = 0 ;
29381
29382 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
29383 {
29384 arg1 = wxString_in_helper(obj0);
29385 if (arg1 == NULL) SWIG_fail;
29386 temp1 = true;
29387 }
29388 {
29389 PyThreadState* __tstate = wxPyBeginAllowThreads();
29390 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
29391
29392 wxPyEndAllowThreads(__tstate);
29393 if (PyErr_Occurred()) SWIG_fail;
29394 }
29395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
29396 {
29397 if (temp1)
29398 delete arg1;
29399 }
29400 return resultobj;
29401 fail:
29402 {
29403 if (temp1)
29404 delete arg1;
29405 }
29406 return NULL;
29407 }
29408
29409
29410 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
29411 PyObject *resultobj = NULL;
29412 wxCustomDataObject *result;
29413
29414 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
29415 {
29416 PyThreadState* __tstate = wxPyBeginAllowThreads();
29417 result = (wxCustomDataObject *)new wxCustomDataObject();
29418
29419 wxPyEndAllowThreads(__tstate);
29420 if (PyErr_Occurred()) SWIG_fail;
29421 }
29422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
29423 return resultobj;
29424 fail:
29425 return NULL;
29426 }
29427
29428
29429 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
29430 int argc;
29431 PyObject *argv[2];
29432 int ii;
29433
29434 argc = PyObject_Length(args);
29435 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
29436 argv[ii] = PyTuple_GetItem(args,ii);
29437 }
29438 if (argc == 0) {
29439 return _wrap_new_CustomDataObject__SWIG_2(self,args);
29440 }
29441 if (argc == 1) {
29442 int _v;
29443 {
29444 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
29445 }
29446 if (_v) {
29447 return _wrap_new_CustomDataObject__SWIG_1(self,args);
29448 }
29449 }
29450 if (argc == 1) {
29451 int _v;
29452 {
29453 void *ptr = 0;
29454 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
29455 _v = 0;
29456 PyErr_Clear();
29457 } else {
29458 _v = (ptr != 0);
29459 }
29460 }
29461 if (_v) {
29462 return _wrap_new_CustomDataObject__SWIG_0(self,args);
29463 }
29464 }
29465
29466 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
29467 return NULL;
29468 }
29469
29470
29471 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29472 PyObject *resultobj = NULL;
29473 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
29474 PyObject *arg2 = (PyObject *) 0 ;
29475 bool result;
29476 PyObject * obj0 = 0 ;
29477 PyObject * obj1 = 0 ;
29478 char *kwnames[] = {
29479 (char *) "self",(char *) "data", NULL
29480 };
29481
29482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
29483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
29484 if (SWIG_arg_fail(1)) SWIG_fail;
29485 arg2 = obj1;
29486 {
29487 PyThreadState* __tstate = wxPyBeginAllowThreads();
29488 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
29489
29490 wxPyEndAllowThreads(__tstate);
29491 if (PyErr_Occurred()) SWIG_fail;
29492 }
29493 {
29494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29495 }
29496 return resultobj;
29497 fail:
29498 return NULL;
29499 }
29500
29501
29502 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
29503 PyObject *resultobj = NULL;
29504 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
29505 size_t result;
29506 PyObject * obj0 = 0 ;
29507 char *kwnames[] = {
29508 (char *) "self", NULL
29509 };
29510
29511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
29512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
29513 if (SWIG_arg_fail(1)) SWIG_fail;
29514 {
29515 PyThreadState* __tstate = wxPyBeginAllowThreads();
29516 result = (size_t)(arg1)->GetSize();
29517
29518 wxPyEndAllowThreads(__tstate);
29519 if (PyErr_Occurred()) SWIG_fail;
29520 }
29521 {
29522 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
29523 }
29524 return resultobj;
29525 fail:
29526 return NULL;
29527 }
29528
29529
29530 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29531 PyObject *resultobj = NULL;
29532 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
29533 PyObject *result;
29534 PyObject * obj0 = 0 ;
29535 char *kwnames[] = {
29536 (char *) "self", NULL
29537 };
29538
29539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
29540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
29541 if (SWIG_arg_fail(1)) SWIG_fail;
29542 {
29543 PyThreadState* __tstate = wxPyBeginAllowThreads();
29544 result = (PyObject *)wxCustomDataObject_GetData(arg1);
29545
29546 wxPyEndAllowThreads(__tstate);
29547 if (PyErr_Occurred()) SWIG_fail;
29548 }
29549 resultobj = result;
29550 return resultobj;
29551 fail:
29552 return NULL;
29553 }
29554
29555
29556 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
29557 PyObject *obj;
29558 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29559 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
29560 Py_INCREF(obj);
29561 return Py_BuildValue((char *)"");
29562 }
29563 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29564 PyObject *resultobj = NULL;
29565 wxURLDataObject *result;
29566 char *kwnames[] = {
29567 NULL
29568 };
29569
29570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
29571 {
29572 PyThreadState* __tstate = wxPyBeginAllowThreads();
29573 result = (wxURLDataObject *)new wxURLDataObject();
29574
29575 wxPyEndAllowThreads(__tstate);
29576 if (PyErr_Occurred()) SWIG_fail;
29577 }
29578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
29579 return resultobj;
29580 fail:
29581 return NULL;
29582 }
29583
29584
29585 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
29586 PyObject *resultobj = NULL;
29587 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
29588 wxString result;
29589 PyObject * obj0 = 0 ;
29590 char *kwnames[] = {
29591 (char *) "self", NULL
29592 };
29593
29594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
29595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
29596 if (SWIG_arg_fail(1)) SWIG_fail;
29597 {
29598 PyThreadState* __tstate = wxPyBeginAllowThreads();
29599 result = (arg1)->GetURL();
29600
29601 wxPyEndAllowThreads(__tstate);
29602 if (PyErr_Occurred()) SWIG_fail;
29603 }
29604 {
29605 #if wxUSE_UNICODE
29606 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29607 #else
29608 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29609 #endif
29610 }
29611 return resultobj;
29612 fail:
29613 return NULL;
29614 }
29615
29616
29617 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
29618 PyObject *resultobj = NULL;
29619 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
29620 wxString *arg2 = 0 ;
29621 bool temp2 = false ;
29622 PyObject * obj0 = 0 ;
29623 PyObject * obj1 = 0 ;
29624 char *kwnames[] = {
29625 (char *) "self",(char *) "url", NULL
29626 };
29627
29628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
29629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
29630 if (SWIG_arg_fail(1)) SWIG_fail;
29631 {
29632 arg2 = wxString_in_helper(obj1);
29633 if (arg2 == NULL) SWIG_fail;
29634 temp2 = true;
29635 }
29636 {
29637 PyThreadState* __tstate = wxPyBeginAllowThreads();
29638 (arg1)->SetURL((wxString const &)*arg2);
29639
29640 wxPyEndAllowThreads(__tstate);
29641 if (PyErr_Occurred()) SWIG_fail;
29642 }
29643 Py_INCREF(Py_None); resultobj = Py_None;
29644 {
29645 if (temp2)
29646 delete arg2;
29647 }
29648 return resultobj;
29649 fail:
29650 {
29651 if (temp2)
29652 delete arg2;
29653 }
29654 return NULL;
29655 }
29656
29657
29658 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
29659 PyObject *obj;
29660 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29661 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
29662 Py_INCREF(obj);
29663 return Py_BuildValue((char *)"");
29664 }
29665 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29666 PyObject *resultobj = NULL;
29667 wxMetafileDataObject *result;
29668 char *kwnames[] = {
29669 NULL
29670 };
29671
29672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
29673 {
29674 PyThreadState* __tstate = wxPyBeginAllowThreads();
29675 result = (wxMetafileDataObject *)new wxMetafileDataObject();
29676
29677 wxPyEndAllowThreads(__tstate);
29678 if (PyErr_Occurred()) SWIG_fail;
29679 }
29680 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
29681 return resultobj;
29682 fail:
29683 return NULL;
29684 }
29685
29686
29687 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
29688 PyObject *obj;
29689 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29690 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
29691 Py_INCREF(obj);
29692 return Py_BuildValue((char *)"");
29693 }
29694 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
29695 PyObject *resultobj = NULL;
29696 wxDragResult arg1 ;
29697 bool result;
29698 PyObject * obj0 = 0 ;
29699 char *kwnames[] = {
29700 (char *) "res", NULL
29701 };
29702
29703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
29704 {
29705 arg1 = static_cast<wxDragResult >(SWIG_As_int(obj0));
29706 if (SWIG_arg_fail(1)) SWIG_fail;
29707 }
29708 {
29709 PyThreadState* __tstate = wxPyBeginAllowThreads();
29710 result = (bool)wxIsDragResultOk(arg1);
29711
29712 wxPyEndAllowThreads(__tstate);
29713 if (PyErr_Occurred()) SWIG_fail;
29714 }
29715 {
29716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29717 }
29718 return resultobj;
29719 fail:
29720 return NULL;
29721 }
29722
29723
29724 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
29725 PyObject *resultobj = NULL;
29726 wxWindow *arg1 = (wxWindow *) 0 ;
29727 wxIcon const &arg2_defvalue = wxNullIcon ;
29728 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
29729 wxIcon const &arg3_defvalue = wxNullIcon ;
29730 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
29731 wxIcon const &arg4_defvalue = wxNullIcon ;
29732 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
29733 wxPyDropSource *result;
29734 PyObject * obj0 = 0 ;
29735 PyObject * obj1 = 0 ;
29736 PyObject * obj2 = 0 ;
29737 PyObject * obj3 = 0 ;
29738 char *kwnames[] = {
29739 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
29740 };
29741
29742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29744 if (SWIG_arg_fail(1)) SWIG_fail;
29745 if (obj1) {
29746 {
29747 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
29748 if (SWIG_arg_fail(2)) SWIG_fail;
29749 if (arg2 == NULL) {
29750 SWIG_null_ref("wxIcon");
29751 }
29752 if (SWIG_arg_fail(2)) SWIG_fail;
29753 }
29754 }
29755 if (obj2) {
29756 {
29757 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
29758 if (SWIG_arg_fail(3)) SWIG_fail;
29759 if (arg3 == NULL) {
29760 SWIG_null_ref("wxIcon");
29761 }
29762 if (SWIG_arg_fail(3)) SWIG_fail;
29763 }
29764 }
29765 if (obj3) {
29766 {
29767 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
29768 if (SWIG_arg_fail(4)) SWIG_fail;
29769 if (arg4 == NULL) {
29770 SWIG_null_ref("wxIcon");
29771 }
29772 if (SWIG_arg_fail(4)) SWIG_fail;
29773 }
29774 }
29775 {
29776 PyThreadState* __tstate = wxPyBeginAllowThreads();
29777 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
29778
29779 wxPyEndAllowThreads(__tstate);
29780 if (PyErr_Occurred()) SWIG_fail;
29781 }
29782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
29783 return resultobj;
29784 fail:
29785 return NULL;
29786 }
29787
29788
29789 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29790 PyObject *resultobj = NULL;
29791 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29792 PyObject *arg2 = (PyObject *) 0 ;
29793 PyObject *arg3 = (PyObject *) 0 ;
29794 int arg4 ;
29795 PyObject * obj0 = 0 ;
29796 PyObject * obj1 = 0 ;
29797 PyObject * obj2 = 0 ;
29798 PyObject * obj3 = 0 ;
29799 char *kwnames[] = {
29800 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
29801 };
29802
29803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29805 if (SWIG_arg_fail(1)) SWIG_fail;
29806 arg2 = obj1;
29807 arg3 = obj2;
29808 {
29809 arg4 = static_cast<int >(SWIG_As_int(obj3));
29810 if (SWIG_arg_fail(4)) SWIG_fail;
29811 }
29812 {
29813 PyThreadState* __tstate = wxPyBeginAllowThreads();
29814 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
29815
29816 wxPyEndAllowThreads(__tstate);
29817 if (PyErr_Occurred()) SWIG_fail;
29818 }
29819 Py_INCREF(Py_None); resultobj = Py_None;
29820 return resultobj;
29821 fail:
29822 return NULL;
29823 }
29824
29825
29826 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
29827 PyObject *resultobj = NULL;
29828 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29829 PyObject * obj0 = 0 ;
29830 char *kwnames[] = {
29831 (char *) "self", NULL
29832 };
29833
29834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
29835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29836 if (SWIG_arg_fail(1)) SWIG_fail;
29837 {
29838 PyThreadState* __tstate = wxPyBeginAllowThreads();
29839 delete arg1;
29840
29841 wxPyEndAllowThreads(__tstate);
29842 if (PyErr_Occurred()) SWIG_fail;
29843 }
29844 Py_INCREF(Py_None); resultobj = Py_None;
29845 return resultobj;
29846 fail:
29847 return NULL;
29848 }
29849
29850
29851 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29852 PyObject *resultobj = NULL;
29853 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29854 wxDataObject *arg2 = 0 ;
29855 PyObject * obj0 = 0 ;
29856 PyObject * obj1 = 0 ;
29857 char *kwnames[] = {
29858 (char *) "self",(char *) "data", NULL
29859 };
29860
29861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
29862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29863 if (SWIG_arg_fail(1)) SWIG_fail;
29864 {
29865 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29866 if (SWIG_arg_fail(2)) SWIG_fail;
29867 if (arg2 == NULL) {
29868 SWIG_null_ref("wxDataObject");
29869 }
29870 if (SWIG_arg_fail(2)) SWIG_fail;
29871 }
29872 {
29873 PyThreadState* __tstate = wxPyBeginAllowThreads();
29874 (arg1)->SetData(*arg2);
29875
29876 wxPyEndAllowThreads(__tstate);
29877 if (PyErr_Occurred()) SWIG_fail;
29878 }
29879 Py_INCREF(Py_None); resultobj = Py_None;
29880 return resultobj;
29881 fail:
29882 return NULL;
29883 }
29884
29885
29886 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29887 PyObject *resultobj = NULL;
29888 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29889 wxDataObject *result;
29890 PyObject * obj0 = 0 ;
29891 char *kwnames[] = {
29892 (char *) "self", NULL
29893 };
29894
29895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
29896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29897 if (SWIG_arg_fail(1)) SWIG_fail;
29898 {
29899 PyThreadState* __tstate = wxPyBeginAllowThreads();
29900 result = (wxDataObject *)(arg1)->GetDataObject();
29901
29902 wxPyEndAllowThreads(__tstate);
29903 if (PyErr_Occurred()) SWIG_fail;
29904 }
29905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
29906 return resultobj;
29907 fail:
29908 return NULL;
29909 }
29910
29911
29912 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29913 PyObject *resultobj = NULL;
29914 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29915 wxDragResult arg2 ;
29916 wxCursor *arg3 = 0 ;
29917 PyObject * obj0 = 0 ;
29918 PyObject * obj1 = 0 ;
29919 PyObject * obj2 = 0 ;
29920 char *kwnames[] = {
29921 (char *) "self",(char *) "res",(char *) "cursor", NULL
29922 };
29923
29924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
29925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29926 if (SWIG_arg_fail(1)) SWIG_fail;
29927 {
29928 arg2 = static_cast<wxDragResult >(SWIG_As_int(obj1));
29929 if (SWIG_arg_fail(2)) SWIG_fail;
29930 }
29931 {
29932 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29933 if (SWIG_arg_fail(3)) SWIG_fail;
29934 if (arg3 == NULL) {
29935 SWIG_null_ref("wxCursor");
29936 }
29937 if (SWIG_arg_fail(3)) SWIG_fail;
29938 }
29939 {
29940 PyThreadState* __tstate = wxPyBeginAllowThreads();
29941 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
29942
29943 wxPyEndAllowThreads(__tstate);
29944 if (PyErr_Occurred()) SWIG_fail;
29945 }
29946 Py_INCREF(Py_None); resultobj = Py_None;
29947 return resultobj;
29948 fail:
29949 return NULL;
29950 }
29951
29952
29953 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29954 PyObject *resultobj = NULL;
29955 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29956 int arg2 = (int) wxDrag_CopyOnly ;
29957 wxDragResult result;
29958 PyObject * obj0 = 0 ;
29959 PyObject * obj1 = 0 ;
29960 char *kwnames[] = {
29961 (char *) "self",(char *) "flags", NULL
29962 };
29963
29964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
29965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29966 if (SWIG_arg_fail(1)) SWIG_fail;
29967 if (obj1) {
29968 {
29969 arg2 = static_cast<int >(SWIG_As_int(obj1));
29970 if (SWIG_arg_fail(2)) SWIG_fail;
29971 }
29972 }
29973 {
29974 PyThreadState* __tstate = wxPyBeginAllowThreads();
29975 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
29976
29977 wxPyEndAllowThreads(__tstate);
29978 if (PyErr_Occurred()) SWIG_fail;
29979 }
29980 resultobj = SWIG_From_int((result));
29981 return resultobj;
29982 fail:
29983 return NULL;
29984 }
29985
29986
29987 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
29988 PyObject *resultobj = NULL;
29989 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29990 wxDragResult arg2 ;
29991 bool result;
29992 PyObject * obj0 = 0 ;
29993 PyObject * obj1 = 0 ;
29994 char *kwnames[] = {
29995 (char *) "self",(char *) "effect", NULL
29996 };
29997
29998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
29999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
30000 if (SWIG_arg_fail(1)) SWIG_fail;
30001 {
30002 arg2 = static_cast<wxDragResult >(SWIG_As_int(obj1));
30003 if (SWIG_arg_fail(2)) SWIG_fail;
30004 }
30005 {
30006 PyThreadState* __tstate = wxPyBeginAllowThreads();
30007 result = (bool)(arg1)->base_GiveFeedback(arg2);
30008
30009 wxPyEndAllowThreads(__tstate);
30010 if (PyErr_Occurred()) SWIG_fail;
30011 }
30012 {
30013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30014 }
30015 return resultobj;
30016 fail:
30017 return NULL;
30018 }
30019
30020
30021 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
30022 PyObject *obj;
30023 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30024 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
30025 Py_INCREF(obj);
30026 return Py_BuildValue((char *)"");
30027 }
30028 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30029 PyObject *resultobj = NULL;
30030 wxDataObject *arg1 = (wxDataObject *) NULL ;
30031 wxPyDropTarget *result;
30032 PyObject * obj0 = 0 ;
30033 char *kwnames[] = {
30034 (char *) "dataObject", NULL
30035 };
30036
30037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
30038 if (obj0) {
30039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30040 if (SWIG_arg_fail(1)) SWIG_fail;
30041 }
30042 {
30043 PyThreadState* __tstate = wxPyBeginAllowThreads();
30044 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
30045
30046 wxPyEndAllowThreads(__tstate);
30047 if (PyErr_Occurred()) SWIG_fail;
30048 }
30049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
30050 return resultobj;
30051 fail:
30052 return NULL;
30053 }
30054
30055
30056 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
30057 PyObject *resultobj = NULL;
30058 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30059 PyObject *arg2 = (PyObject *) 0 ;
30060 PyObject *arg3 = (PyObject *) 0 ;
30061 PyObject * obj0 = 0 ;
30062 PyObject * obj1 = 0 ;
30063 PyObject * obj2 = 0 ;
30064 char *kwnames[] = {
30065 (char *) "self",(char *) "self",(char *) "_class", NULL
30066 };
30067
30068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
30069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30070 if (SWIG_arg_fail(1)) SWIG_fail;
30071 arg2 = obj1;
30072 arg3 = obj2;
30073 {
30074 PyThreadState* __tstate = wxPyBeginAllowThreads();
30075 (arg1)->_setCallbackInfo(arg2,arg3);
30076
30077 wxPyEndAllowThreads(__tstate);
30078 if (PyErr_Occurred()) SWIG_fail;
30079 }
30080 Py_INCREF(Py_None); resultobj = Py_None;
30081 return resultobj;
30082 fail:
30083 return NULL;
30084 }
30085
30086
30087 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30088 PyObject *resultobj = NULL;
30089 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30090 PyObject * obj0 = 0 ;
30091 char *kwnames[] = {
30092 (char *) "self", NULL
30093 };
30094
30095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
30096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30097 if (SWIG_arg_fail(1)) SWIG_fail;
30098 {
30099 PyThreadState* __tstate = wxPyBeginAllowThreads();
30100 delete arg1;
30101
30102 wxPyEndAllowThreads(__tstate);
30103 if (PyErr_Occurred()) SWIG_fail;
30104 }
30105 Py_INCREF(Py_None); resultobj = Py_None;
30106 return resultobj;
30107 fail:
30108 return NULL;
30109 }
30110
30111
30112 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
30113 PyObject *resultobj = NULL;
30114 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30115 wxDataObject *result;
30116 PyObject * obj0 = 0 ;
30117 char *kwnames[] = {
30118 (char *) "self", NULL
30119 };
30120
30121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
30122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30123 if (SWIG_arg_fail(1)) SWIG_fail;
30124 {
30125 PyThreadState* __tstate = wxPyBeginAllowThreads();
30126 result = (wxDataObject *)(arg1)->GetDataObject();
30127
30128 wxPyEndAllowThreads(__tstate);
30129 if (PyErr_Occurred()) SWIG_fail;
30130 }
30131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
30132 return resultobj;
30133 fail:
30134 return NULL;
30135 }
30136
30137
30138 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
30139 PyObject *resultobj = NULL;
30140 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30141 wxDataObject *arg2 = (wxDataObject *) 0 ;
30142 PyObject * obj0 = 0 ;
30143 PyObject * obj1 = 0 ;
30144 char *kwnames[] = {
30145 (char *) "self",(char *) "dataObject", NULL
30146 };
30147
30148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
30149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30150 if (SWIG_arg_fail(1)) SWIG_fail;
30151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30152 if (SWIG_arg_fail(2)) SWIG_fail;
30153 {
30154 PyThreadState* __tstate = wxPyBeginAllowThreads();
30155 (arg1)->SetDataObject(arg2);
30156
30157 wxPyEndAllowThreads(__tstate);
30158 if (PyErr_Occurred()) SWIG_fail;
30159 }
30160 Py_INCREF(Py_None); resultobj = Py_None;
30161 return resultobj;
30162 fail:
30163 return NULL;
30164 }
30165
30166
30167 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
30168 PyObject *resultobj = NULL;
30169 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30170 int arg2 ;
30171 int arg3 ;
30172 wxDragResult arg4 ;
30173 wxDragResult result;
30174 PyObject * obj0 = 0 ;
30175 PyObject * obj1 = 0 ;
30176 PyObject * obj2 = 0 ;
30177 PyObject * obj3 = 0 ;
30178 char *kwnames[] = {
30179 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30180 };
30181
30182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30184 if (SWIG_arg_fail(1)) SWIG_fail;
30185 {
30186 arg2 = static_cast<int >(SWIG_As_int(obj1));
30187 if (SWIG_arg_fail(2)) SWIG_fail;
30188 }
30189 {
30190 arg3 = static_cast<int >(SWIG_As_int(obj2));
30191 if (SWIG_arg_fail(3)) SWIG_fail;
30192 }
30193 {
30194 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30195 if (SWIG_arg_fail(4)) SWIG_fail;
30196 }
30197 {
30198 PyThreadState* __tstate = wxPyBeginAllowThreads();
30199 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,arg4);
30200
30201 wxPyEndAllowThreads(__tstate);
30202 if (PyErr_Occurred()) SWIG_fail;
30203 }
30204 resultobj = SWIG_From_int((result));
30205 return resultobj;
30206 fail:
30207 return NULL;
30208 }
30209
30210
30211 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
30212 PyObject *resultobj = NULL;
30213 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30214 int arg2 ;
30215 int arg3 ;
30216 wxDragResult arg4 ;
30217 wxDragResult result;
30218 PyObject * obj0 = 0 ;
30219 PyObject * obj1 = 0 ;
30220 PyObject * obj2 = 0 ;
30221 PyObject * obj3 = 0 ;
30222 char *kwnames[] = {
30223 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30224 };
30225
30226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30228 if (SWIG_arg_fail(1)) SWIG_fail;
30229 {
30230 arg2 = static_cast<int >(SWIG_As_int(obj1));
30231 if (SWIG_arg_fail(2)) SWIG_fail;
30232 }
30233 {
30234 arg3 = static_cast<int >(SWIG_As_int(obj2));
30235 if (SWIG_arg_fail(3)) SWIG_fail;
30236 }
30237 {
30238 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30239 if (SWIG_arg_fail(4)) SWIG_fail;
30240 }
30241 {
30242 PyThreadState* __tstate = wxPyBeginAllowThreads();
30243 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,arg4);
30244
30245 wxPyEndAllowThreads(__tstate);
30246 if (PyErr_Occurred()) SWIG_fail;
30247 }
30248 resultobj = SWIG_From_int((result));
30249 return resultobj;
30250 fail:
30251 return NULL;
30252 }
30253
30254
30255 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
30256 PyObject *resultobj = NULL;
30257 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30258 PyObject * obj0 = 0 ;
30259 char *kwnames[] = {
30260 (char *) "self", NULL
30261 };
30262
30263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
30264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30265 if (SWIG_arg_fail(1)) SWIG_fail;
30266 {
30267 PyThreadState* __tstate = wxPyBeginAllowThreads();
30268 (arg1)->base_OnLeave();
30269
30270 wxPyEndAllowThreads(__tstate);
30271 if (PyErr_Occurred()) SWIG_fail;
30272 }
30273 Py_INCREF(Py_None); resultobj = Py_None;
30274 return resultobj;
30275 fail:
30276 return NULL;
30277 }
30278
30279
30280 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
30281 PyObject *resultobj = NULL;
30282 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30283 int arg2 ;
30284 int arg3 ;
30285 bool result;
30286 PyObject * obj0 = 0 ;
30287 PyObject * obj1 = 0 ;
30288 PyObject * obj2 = 0 ;
30289 char *kwnames[] = {
30290 (char *) "self",(char *) "x",(char *) "y", NULL
30291 };
30292
30293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
30294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30295 if (SWIG_arg_fail(1)) SWIG_fail;
30296 {
30297 arg2 = static_cast<int >(SWIG_As_int(obj1));
30298 if (SWIG_arg_fail(2)) SWIG_fail;
30299 }
30300 {
30301 arg3 = static_cast<int >(SWIG_As_int(obj2));
30302 if (SWIG_arg_fail(3)) SWIG_fail;
30303 }
30304 {
30305 PyThreadState* __tstate = wxPyBeginAllowThreads();
30306 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
30307
30308 wxPyEndAllowThreads(__tstate);
30309 if (PyErr_Occurred()) SWIG_fail;
30310 }
30311 {
30312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30313 }
30314 return resultobj;
30315 fail:
30316 return NULL;
30317 }
30318
30319
30320 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30321 PyObject *resultobj = NULL;
30322 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30323 bool result;
30324 PyObject * obj0 = 0 ;
30325 char *kwnames[] = {
30326 (char *) "self", NULL
30327 };
30328
30329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
30330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30331 if (SWIG_arg_fail(1)) SWIG_fail;
30332 {
30333 PyThreadState* __tstate = wxPyBeginAllowThreads();
30334 result = (bool)(arg1)->GetData();
30335
30336 wxPyEndAllowThreads(__tstate);
30337 if (PyErr_Occurred()) SWIG_fail;
30338 }
30339 {
30340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30341 }
30342 return resultobj;
30343 fail:
30344 return NULL;
30345 }
30346
30347
30348 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
30349 PyObject *resultobj = NULL;
30350 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30351 wxDragResult arg2 ;
30352 PyObject * obj0 = 0 ;
30353 PyObject * obj1 = 0 ;
30354 char *kwnames[] = {
30355 (char *) "self",(char *) "action", NULL
30356 };
30357
30358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
30359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30360 if (SWIG_arg_fail(1)) SWIG_fail;
30361 {
30362 arg2 = static_cast<wxDragResult >(SWIG_As_int(obj1));
30363 if (SWIG_arg_fail(2)) SWIG_fail;
30364 }
30365 {
30366 PyThreadState* __tstate = wxPyBeginAllowThreads();
30367 (arg1)->SetDefaultAction(arg2);
30368
30369 wxPyEndAllowThreads(__tstate);
30370 if (PyErr_Occurred()) SWIG_fail;
30371 }
30372 Py_INCREF(Py_None); resultobj = Py_None;
30373 return resultobj;
30374 fail:
30375 return NULL;
30376 }
30377
30378
30379 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
30380 PyObject *resultobj = NULL;
30381 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30382 wxDragResult result;
30383 PyObject * obj0 = 0 ;
30384 char *kwnames[] = {
30385 (char *) "self", NULL
30386 };
30387
30388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
30389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30390 if (SWIG_arg_fail(1)) SWIG_fail;
30391 {
30392 PyThreadState* __tstate = wxPyBeginAllowThreads();
30393 result = (wxDragResult)(arg1)->GetDefaultAction();
30394
30395 wxPyEndAllowThreads(__tstate);
30396 if (PyErr_Occurred()) SWIG_fail;
30397 }
30398 resultobj = SWIG_From_int((result));
30399 return resultobj;
30400 fail:
30401 return NULL;
30402 }
30403
30404
30405 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
30406 PyObject *obj;
30407 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30408 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
30409 Py_INCREF(obj);
30410 return Py_BuildValue((char *)"");
30411 }
30412 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30413 PyObject *resultobj = NULL;
30414 wxPyTextDropTarget *result;
30415 char *kwnames[] = {
30416 NULL
30417 };
30418
30419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
30420 {
30421 PyThreadState* __tstate = wxPyBeginAllowThreads();
30422 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
30423
30424 wxPyEndAllowThreads(__tstate);
30425 if (PyErr_Occurred()) SWIG_fail;
30426 }
30427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
30428 return resultobj;
30429 fail:
30430 return NULL;
30431 }
30432
30433
30434 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
30435 PyObject *resultobj = NULL;
30436 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30437 PyObject *arg2 = (PyObject *) 0 ;
30438 PyObject *arg3 = (PyObject *) 0 ;
30439 PyObject * obj0 = 0 ;
30440 PyObject * obj1 = 0 ;
30441 PyObject * obj2 = 0 ;
30442 char *kwnames[] = {
30443 (char *) "self",(char *) "self",(char *) "_class", NULL
30444 };
30445
30446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
30447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30448 if (SWIG_arg_fail(1)) SWIG_fail;
30449 arg2 = obj1;
30450 arg3 = obj2;
30451 {
30452 PyThreadState* __tstate = wxPyBeginAllowThreads();
30453 (arg1)->_setCallbackInfo(arg2,arg3);
30454
30455 wxPyEndAllowThreads(__tstate);
30456 if (PyErr_Occurred()) SWIG_fail;
30457 }
30458 Py_INCREF(Py_None); resultobj = Py_None;
30459 return resultobj;
30460 fail:
30461 return NULL;
30462 }
30463
30464
30465 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
30466 PyObject *resultobj = NULL;
30467 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30468 int arg2 ;
30469 int arg3 ;
30470 wxDragResult arg4 ;
30471 wxDragResult result;
30472 PyObject * obj0 = 0 ;
30473 PyObject * obj1 = 0 ;
30474 PyObject * obj2 = 0 ;
30475 PyObject * obj3 = 0 ;
30476 char *kwnames[] = {
30477 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30478 };
30479
30480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30482 if (SWIG_arg_fail(1)) SWIG_fail;
30483 {
30484 arg2 = static_cast<int >(SWIG_As_int(obj1));
30485 if (SWIG_arg_fail(2)) SWIG_fail;
30486 }
30487 {
30488 arg3 = static_cast<int >(SWIG_As_int(obj2));
30489 if (SWIG_arg_fail(3)) SWIG_fail;
30490 }
30491 {
30492 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30493 if (SWIG_arg_fail(4)) SWIG_fail;
30494 }
30495 {
30496 PyThreadState* __tstate = wxPyBeginAllowThreads();
30497 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,arg4);
30498
30499 wxPyEndAllowThreads(__tstate);
30500 if (PyErr_Occurred()) SWIG_fail;
30501 }
30502 resultobj = SWIG_From_int((result));
30503 return resultobj;
30504 fail:
30505 return NULL;
30506 }
30507
30508
30509 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
30510 PyObject *resultobj = NULL;
30511 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30512 int arg2 ;
30513 int arg3 ;
30514 wxDragResult arg4 ;
30515 wxDragResult result;
30516 PyObject * obj0 = 0 ;
30517 PyObject * obj1 = 0 ;
30518 PyObject * obj2 = 0 ;
30519 PyObject * obj3 = 0 ;
30520 char *kwnames[] = {
30521 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30522 };
30523
30524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30526 if (SWIG_arg_fail(1)) SWIG_fail;
30527 {
30528 arg2 = static_cast<int >(SWIG_As_int(obj1));
30529 if (SWIG_arg_fail(2)) SWIG_fail;
30530 }
30531 {
30532 arg3 = static_cast<int >(SWIG_As_int(obj2));
30533 if (SWIG_arg_fail(3)) SWIG_fail;
30534 }
30535 {
30536 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30537 if (SWIG_arg_fail(4)) SWIG_fail;
30538 }
30539 {
30540 PyThreadState* __tstate = wxPyBeginAllowThreads();
30541 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,arg4);
30542
30543 wxPyEndAllowThreads(__tstate);
30544 if (PyErr_Occurred()) SWIG_fail;
30545 }
30546 resultobj = SWIG_From_int((result));
30547 return resultobj;
30548 fail:
30549 return NULL;
30550 }
30551
30552
30553 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
30554 PyObject *resultobj = NULL;
30555 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30556 PyObject * obj0 = 0 ;
30557 char *kwnames[] = {
30558 (char *) "self", NULL
30559 };
30560
30561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
30562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30563 if (SWIG_arg_fail(1)) SWIG_fail;
30564 {
30565 PyThreadState* __tstate = wxPyBeginAllowThreads();
30566 (arg1)->base_OnLeave();
30567
30568 wxPyEndAllowThreads(__tstate);
30569 if (PyErr_Occurred()) SWIG_fail;
30570 }
30571 Py_INCREF(Py_None); resultobj = Py_None;
30572 return resultobj;
30573 fail:
30574 return NULL;
30575 }
30576
30577
30578 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
30579 PyObject *resultobj = NULL;
30580 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30581 int arg2 ;
30582 int arg3 ;
30583 bool result;
30584 PyObject * obj0 = 0 ;
30585 PyObject * obj1 = 0 ;
30586 PyObject * obj2 = 0 ;
30587 char *kwnames[] = {
30588 (char *) "self",(char *) "x",(char *) "y", NULL
30589 };
30590
30591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
30592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30593 if (SWIG_arg_fail(1)) SWIG_fail;
30594 {
30595 arg2 = static_cast<int >(SWIG_As_int(obj1));
30596 if (SWIG_arg_fail(2)) SWIG_fail;
30597 }
30598 {
30599 arg3 = static_cast<int >(SWIG_As_int(obj2));
30600 if (SWIG_arg_fail(3)) SWIG_fail;
30601 }
30602 {
30603 PyThreadState* __tstate = wxPyBeginAllowThreads();
30604 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
30605
30606 wxPyEndAllowThreads(__tstate);
30607 if (PyErr_Occurred()) SWIG_fail;
30608 }
30609 {
30610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30611 }
30612 return resultobj;
30613 fail:
30614 return NULL;
30615 }
30616
30617
30618 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
30619 PyObject *resultobj = NULL;
30620 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30621 int arg2 ;
30622 int arg3 ;
30623 wxDragResult arg4 ;
30624 wxDragResult result;
30625 PyObject * obj0 = 0 ;
30626 PyObject * obj1 = 0 ;
30627 PyObject * obj2 = 0 ;
30628 PyObject * obj3 = 0 ;
30629 char *kwnames[] = {
30630 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30631 };
30632
30633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30635 if (SWIG_arg_fail(1)) SWIG_fail;
30636 {
30637 arg2 = static_cast<int >(SWIG_As_int(obj1));
30638 if (SWIG_arg_fail(2)) SWIG_fail;
30639 }
30640 {
30641 arg3 = static_cast<int >(SWIG_As_int(obj2));
30642 if (SWIG_arg_fail(3)) SWIG_fail;
30643 }
30644 {
30645 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30646 if (SWIG_arg_fail(4)) SWIG_fail;
30647 }
30648 {
30649 PyThreadState* __tstate = wxPyBeginAllowThreads();
30650 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,arg4);
30651
30652 wxPyEndAllowThreads(__tstate);
30653 if (PyErr_Occurred()) SWIG_fail;
30654 }
30655 resultobj = SWIG_From_int((result));
30656 return resultobj;
30657 fail:
30658 return NULL;
30659 }
30660
30661
30662 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
30663 PyObject *obj;
30664 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30665 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
30666 Py_INCREF(obj);
30667 return Py_BuildValue((char *)"");
30668 }
30669 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30670 PyObject *resultobj = NULL;
30671 wxPyFileDropTarget *result;
30672 char *kwnames[] = {
30673 NULL
30674 };
30675
30676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
30677 {
30678 PyThreadState* __tstate = wxPyBeginAllowThreads();
30679 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
30680
30681 wxPyEndAllowThreads(__tstate);
30682 if (PyErr_Occurred()) SWIG_fail;
30683 }
30684 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
30685 return resultobj;
30686 fail:
30687 return NULL;
30688 }
30689
30690
30691 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
30692 PyObject *resultobj = NULL;
30693 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30694 PyObject *arg2 = (PyObject *) 0 ;
30695 PyObject *arg3 = (PyObject *) 0 ;
30696 PyObject * obj0 = 0 ;
30697 PyObject * obj1 = 0 ;
30698 PyObject * obj2 = 0 ;
30699 char *kwnames[] = {
30700 (char *) "self",(char *) "self",(char *) "_class", NULL
30701 };
30702
30703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
30704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30705 if (SWIG_arg_fail(1)) SWIG_fail;
30706 arg2 = obj1;
30707 arg3 = obj2;
30708 {
30709 PyThreadState* __tstate = wxPyBeginAllowThreads();
30710 (arg1)->_setCallbackInfo(arg2,arg3);
30711
30712 wxPyEndAllowThreads(__tstate);
30713 if (PyErr_Occurred()) SWIG_fail;
30714 }
30715 Py_INCREF(Py_None); resultobj = Py_None;
30716 return resultobj;
30717 fail:
30718 return NULL;
30719 }
30720
30721
30722 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
30723 PyObject *resultobj = NULL;
30724 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30725 int arg2 ;
30726 int arg3 ;
30727 wxDragResult arg4 ;
30728 wxDragResult result;
30729 PyObject * obj0 = 0 ;
30730 PyObject * obj1 = 0 ;
30731 PyObject * obj2 = 0 ;
30732 PyObject * obj3 = 0 ;
30733 char *kwnames[] = {
30734 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30735 };
30736
30737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30739 if (SWIG_arg_fail(1)) SWIG_fail;
30740 {
30741 arg2 = static_cast<int >(SWIG_As_int(obj1));
30742 if (SWIG_arg_fail(2)) SWIG_fail;
30743 }
30744 {
30745 arg3 = static_cast<int >(SWIG_As_int(obj2));
30746 if (SWIG_arg_fail(3)) SWIG_fail;
30747 }
30748 {
30749 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30750 if (SWIG_arg_fail(4)) SWIG_fail;
30751 }
30752 {
30753 PyThreadState* __tstate = wxPyBeginAllowThreads();
30754 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,arg4);
30755
30756 wxPyEndAllowThreads(__tstate);
30757 if (PyErr_Occurred()) SWIG_fail;
30758 }
30759 resultobj = SWIG_From_int((result));
30760 return resultobj;
30761 fail:
30762 return NULL;
30763 }
30764
30765
30766 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
30767 PyObject *resultobj = NULL;
30768 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30769 int arg2 ;
30770 int arg3 ;
30771 wxDragResult arg4 ;
30772 wxDragResult result;
30773 PyObject * obj0 = 0 ;
30774 PyObject * obj1 = 0 ;
30775 PyObject * obj2 = 0 ;
30776 PyObject * obj3 = 0 ;
30777 char *kwnames[] = {
30778 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30779 };
30780
30781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30783 if (SWIG_arg_fail(1)) SWIG_fail;
30784 {
30785 arg2 = static_cast<int >(SWIG_As_int(obj1));
30786 if (SWIG_arg_fail(2)) SWIG_fail;
30787 }
30788 {
30789 arg3 = static_cast<int >(SWIG_As_int(obj2));
30790 if (SWIG_arg_fail(3)) SWIG_fail;
30791 }
30792 {
30793 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30794 if (SWIG_arg_fail(4)) SWIG_fail;
30795 }
30796 {
30797 PyThreadState* __tstate = wxPyBeginAllowThreads();
30798 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,arg4);
30799
30800 wxPyEndAllowThreads(__tstate);
30801 if (PyErr_Occurred()) SWIG_fail;
30802 }
30803 resultobj = SWIG_From_int((result));
30804 return resultobj;
30805 fail:
30806 return NULL;
30807 }
30808
30809
30810 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
30811 PyObject *resultobj = NULL;
30812 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30813 PyObject * obj0 = 0 ;
30814 char *kwnames[] = {
30815 (char *) "self", NULL
30816 };
30817
30818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
30819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30820 if (SWIG_arg_fail(1)) SWIG_fail;
30821 {
30822 PyThreadState* __tstate = wxPyBeginAllowThreads();
30823 (arg1)->base_OnLeave();
30824
30825 wxPyEndAllowThreads(__tstate);
30826 if (PyErr_Occurred()) SWIG_fail;
30827 }
30828 Py_INCREF(Py_None); resultobj = Py_None;
30829 return resultobj;
30830 fail:
30831 return NULL;
30832 }
30833
30834
30835 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
30836 PyObject *resultobj = NULL;
30837 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30838 int arg2 ;
30839 int arg3 ;
30840 bool result;
30841 PyObject * obj0 = 0 ;
30842 PyObject * obj1 = 0 ;
30843 PyObject * obj2 = 0 ;
30844 char *kwnames[] = {
30845 (char *) "self",(char *) "x",(char *) "y", NULL
30846 };
30847
30848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
30849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30850 if (SWIG_arg_fail(1)) SWIG_fail;
30851 {
30852 arg2 = static_cast<int >(SWIG_As_int(obj1));
30853 if (SWIG_arg_fail(2)) SWIG_fail;
30854 }
30855 {
30856 arg3 = static_cast<int >(SWIG_As_int(obj2));
30857 if (SWIG_arg_fail(3)) SWIG_fail;
30858 }
30859 {
30860 PyThreadState* __tstate = wxPyBeginAllowThreads();
30861 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
30862
30863 wxPyEndAllowThreads(__tstate);
30864 if (PyErr_Occurred()) SWIG_fail;
30865 }
30866 {
30867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30868 }
30869 return resultobj;
30870 fail:
30871 return NULL;
30872 }
30873
30874
30875 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
30876 PyObject *resultobj = NULL;
30877 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30878 int arg2 ;
30879 int arg3 ;
30880 wxDragResult arg4 ;
30881 wxDragResult result;
30882 PyObject * obj0 = 0 ;
30883 PyObject * obj1 = 0 ;
30884 PyObject * obj2 = 0 ;
30885 PyObject * obj3 = 0 ;
30886 char *kwnames[] = {
30887 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30888 };
30889
30890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30892 if (SWIG_arg_fail(1)) SWIG_fail;
30893 {
30894 arg2 = static_cast<int >(SWIG_As_int(obj1));
30895 if (SWIG_arg_fail(2)) SWIG_fail;
30896 }
30897 {
30898 arg3 = static_cast<int >(SWIG_As_int(obj2));
30899 if (SWIG_arg_fail(3)) SWIG_fail;
30900 }
30901 {
30902 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30903 if (SWIG_arg_fail(4)) SWIG_fail;
30904 }
30905 {
30906 PyThreadState* __tstate = wxPyBeginAllowThreads();
30907 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,arg4);
30908
30909 wxPyEndAllowThreads(__tstate);
30910 if (PyErr_Occurred()) SWIG_fail;
30911 }
30912 resultobj = SWIG_From_int((result));
30913 return resultobj;
30914 fail:
30915 return NULL;
30916 }
30917
30918
30919 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
30920 PyObject *obj;
30921 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30922 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
30923 Py_INCREF(obj);
30924 return Py_BuildValue((char *)"");
30925 }
30926 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
30927 PyObject *resultobj = NULL;
30928 wxClipboard *result;
30929 char *kwnames[] = {
30930 NULL
30931 };
30932
30933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
30934 {
30935 PyThreadState* __tstate = wxPyBeginAllowThreads();
30936 result = (wxClipboard *)new wxClipboard();
30937
30938 wxPyEndAllowThreads(__tstate);
30939 if (PyErr_Occurred()) SWIG_fail;
30940 }
30941 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
30942 return resultobj;
30943 fail:
30944 return NULL;
30945 }
30946
30947
30948 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
30949 PyObject *resultobj = NULL;
30950 wxClipboard *arg1 = (wxClipboard *) 0 ;
30951 PyObject * obj0 = 0 ;
30952 char *kwnames[] = {
30953 (char *) "self", NULL
30954 };
30955
30956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
30957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30958 if (SWIG_arg_fail(1)) SWIG_fail;
30959 {
30960 PyThreadState* __tstate = wxPyBeginAllowThreads();
30961 delete arg1;
30962
30963 wxPyEndAllowThreads(__tstate);
30964 if (PyErr_Occurred()) SWIG_fail;
30965 }
30966 Py_INCREF(Py_None); resultobj = Py_None;
30967 return resultobj;
30968 fail:
30969 return NULL;
30970 }
30971
30972
30973 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
30974 PyObject *resultobj = NULL;
30975 wxClipboard *arg1 = (wxClipboard *) 0 ;
30976 bool result;
30977 PyObject * obj0 = 0 ;
30978 char *kwnames[] = {
30979 (char *) "self", NULL
30980 };
30981
30982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
30983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30984 if (SWIG_arg_fail(1)) SWIG_fail;
30985 {
30986 PyThreadState* __tstate = wxPyBeginAllowThreads();
30987 result = (bool)(arg1)->Open();
30988
30989 wxPyEndAllowThreads(__tstate);
30990 if (PyErr_Occurred()) SWIG_fail;
30991 }
30992 {
30993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30994 }
30995 return resultobj;
30996 fail:
30997 return NULL;
30998 }
30999
31000
31001 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
31002 PyObject *resultobj = NULL;
31003 wxClipboard *arg1 = (wxClipboard *) 0 ;
31004 PyObject * obj0 = 0 ;
31005 char *kwnames[] = {
31006 (char *) "self", NULL
31007 };
31008
31009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
31010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31011 if (SWIG_arg_fail(1)) SWIG_fail;
31012 {
31013 PyThreadState* __tstate = wxPyBeginAllowThreads();
31014 (arg1)->Close();
31015
31016 wxPyEndAllowThreads(__tstate);
31017 if (PyErr_Occurred()) SWIG_fail;
31018 }
31019 Py_INCREF(Py_None); resultobj = Py_None;
31020 return resultobj;
31021 fail:
31022 return NULL;
31023 }
31024
31025
31026 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
31027 PyObject *resultobj = NULL;
31028 wxClipboard *arg1 = (wxClipboard *) 0 ;
31029 bool result;
31030 PyObject * obj0 = 0 ;
31031 char *kwnames[] = {
31032 (char *) "self", NULL
31033 };
31034
31035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
31036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31037 if (SWIG_arg_fail(1)) SWIG_fail;
31038 {
31039 PyThreadState* __tstate = wxPyBeginAllowThreads();
31040 result = (bool)((wxClipboard const *)arg1)->IsOpened();
31041
31042 wxPyEndAllowThreads(__tstate);
31043 if (PyErr_Occurred()) SWIG_fail;
31044 }
31045 {
31046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31047 }
31048 return resultobj;
31049 fail:
31050 return NULL;
31051 }
31052
31053
31054 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
31055 PyObject *resultobj = NULL;
31056 wxClipboard *arg1 = (wxClipboard *) 0 ;
31057 wxDataObject *arg2 = (wxDataObject *) 0 ;
31058 bool result;
31059 PyObject * obj0 = 0 ;
31060 PyObject * obj1 = 0 ;
31061 char *kwnames[] = {
31062 (char *) "self",(char *) "data", NULL
31063 };
31064
31065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
31066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31067 if (SWIG_arg_fail(1)) SWIG_fail;
31068 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31069 if (SWIG_arg_fail(2)) SWIG_fail;
31070 {
31071 PyThreadState* __tstate = wxPyBeginAllowThreads();
31072 result = (bool)(arg1)->AddData(arg2);
31073
31074 wxPyEndAllowThreads(__tstate);
31075 if (PyErr_Occurred()) SWIG_fail;
31076 }
31077 {
31078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31079 }
31080 return resultobj;
31081 fail:
31082 return NULL;
31083 }
31084
31085
31086 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
31087 PyObject *resultobj = NULL;
31088 wxClipboard *arg1 = (wxClipboard *) 0 ;
31089 wxDataObject *arg2 = (wxDataObject *) 0 ;
31090 bool result;
31091 PyObject * obj0 = 0 ;
31092 PyObject * obj1 = 0 ;
31093 char *kwnames[] = {
31094 (char *) "self",(char *) "data", NULL
31095 };
31096
31097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
31098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31099 if (SWIG_arg_fail(1)) SWIG_fail;
31100 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31101 if (SWIG_arg_fail(2)) SWIG_fail;
31102 {
31103 PyThreadState* __tstate = wxPyBeginAllowThreads();
31104 result = (bool)(arg1)->SetData(arg2);
31105
31106 wxPyEndAllowThreads(__tstate);
31107 if (PyErr_Occurred()) SWIG_fail;
31108 }
31109 {
31110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31111 }
31112 return resultobj;
31113 fail:
31114 return NULL;
31115 }
31116
31117
31118 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
31119 PyObject *resultobj = NULL;
31120 wxClipboard *arg1 = (wxClipboard *) 0 ;
31121 wxDataFormat *arg2 = 0 ;
31122 bool result;
31123 PyObject * obj0 = 0 ;
31124 PyObject * obj1 = 0 ;
31125 char *kwnames[] = {
31126 (char *) "self",(char *) "format", NULL
31127 };
31128
31129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
31130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31131 if (SWIG_arg_fail(1)) SWIG_fail;
31132 {
31133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
31134 if (SWIG_arg_fail(2)) SWIG_fail;
31135 if (arg2 == NULL) {
31136 SWIG_null_ref("wxDataFormat");
31137 }
31138 if (SWIG_arg_fail(2)) SWIG_fail;
31139 }
31140 {
31141 PyThreadState* __tstate = wxPyBeginAllowThreads();
31142 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
31143
31144 wxPyEndAllowThreads(__tstate);
31145 if (PyErr_Occurred()) SWIG_fail;
31146 }
31147 {
31148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31149 }
31150 return resultobj;
31151 fail:
31152 return NULL;
31153 }
31154
31155
31156 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
31157 PyObject *resultobj = NULL;
31158 wxClipboard *arg1 = (wxClipboard *) 0 ;
31159 wxDataObject *arg2 = 0 ;
31160 bool result;
31161 PyObject * obj0 = 0 ;
31162 PyObject * obj1 = 0 ;
31163 char *kwnames[] = {
31164 (char *) "self",(char *) "data", NULL
31165 };
31166
31167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
31168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31169 if (SWIG_arg_fail(1)) SWIG_fail;
31170 {
31171 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
31172 if (SWIG_arg_fail(2)) SWIG_fail;
31173 if (arg2 == NULL) {
31174 SWIG_null_ref("wxDataObject");
31175 }
31176 if (SWIG_arg_fail(2)) SWIG_fail;
31177 }
31178 {
31179 PyThreadState* __tstate = wxPyBeginAllowThreads();
31180 result = (bool)(arg1)->GetData(*arg2);
31181
31182 wxPyEndAllowThreads(__tstate);
31183 if (PyErr_Occurred()) SWIG_fail;
31184 }
31185 {
31186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31187 }
31188 return resultobj;
31189 fail:
31190 return NULL;
31191 }
31192
31193
31194 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
31195 PyObject *resultobj = NULL;
31196 wxClipboard *arg1 = (wxClipboard *) 0 ;
31197 PyObject * obj0 = 0 ;
31198 char *kwnames[] = {
31199 (char *) "self", NULL
31200 };
31201
31202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
31203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31204 if (SWIG_arg_fail(1)) SWIG_fail;
31205 {
31206 PyThreadState* __tstate = wxPyBeginAllowThreads();
31207 (arg1)->Clear();
31208
31209 wxPyEndAllowThreads(__tstate);
31210 if (PyErr_Occurred()) SWIG_fail;
31211 }
31212 Py_INCREF(Py_None); resultobj = Py_None;
31213 return resultobj;
31214 fail:
31215 return NULL;
31216 }
31217
31218
31219 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
31220 PyObject *resultobj = NULL;
31221 wxClipboard *arg1 = (wxClipboard *) 0 ;
31222 bool result;
31223 PyObject * obj0 = 0 ;
31224 char *kwnames[] = {
31225 (char *) "self", NULL
31226 };
31227
31228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
31229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31230 if (SWIG_arg_fail(1)) SWIG_fail;
31231 {
31232 PyThreadState* __tstate = wxPyBeginAllowThreads();
31233 result = (bool)(arg1)->Flush();
31234
31235 wxPyEndAllowThreads(__tstate);
31236 if (PyErr_Occurred()) SWIG_fail;
31237 }
31238 {
31239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31240 }
31241 return resultobj;
31242 fail:
31243 return NULL;
31244 }
31245
31246
31247 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
31248 PyObject *resultobj = NULL;
31249 wxClipboard *arg1 = (wxClipboard *) 0 ;
31250 bool arg2 = (bool) true ;
31251 PyObject * obj0 = 0 ;
31252 PyObject * obj1 = 0 ;
31253 char *kwnames[] = {
31254 (char *) "self",(char *) "primary", NULL
31255 };
31256
31257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
31258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31259 if (SWIG_arg_fail(1)) SWIG_fail;
31260 if (obj1) {
31261 {
31262 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
31263 if (SWIG_arg_fail(2)) SWIG_fail;
31264 }
31265 }
31266 {
31267 PyThreadState* __tstate = wxPyBeginAllowThreads();
31268 (arg1)->UsePrimarySelection(arg2);
31269
31270 wxPyEndAllowThreads(__tstate);
31271 if (PyErr_Occurred()) SWIG_fail;
31272 }
31273 Py_INCREF(Py_None); resultobj = Py_None;
31274 return resultobj;
31275 fail:
31276 return NULL;
31277 }
31278
31279
31280 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31281 PyObject *resultobj = NULL;
31282 wxClipboard *result;
31283 char *kwnames[] = {
31284 NULL
31285 };
31286
31287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
31288 {
31289 PyThreadState* __tstate = wxPyBeginAllowThreads();
31290 result = (wxClipboard *)wxClipboard::Get();
31291
31292 wxPyEndAllowThreads(__tstate);
31293 if (PyErr_Occurred()) SWIG_fail;
31294 }
31295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
31296 return resultobj;
31297 fail:
31298 return NULL;
31299 }
31300
31301
31302 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
31303 PyObject *obj;
31304 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31305 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
31306 Py_INCREF(obj);
31307 return Py_BuildValue((char *)"");
31308 }
31309 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
31310 PyObject *resultobj = NULL;
31311 wxClipboard *arg1 = (wxClipboard *) NULL ;
31312 wxClipboardLocker *result;
31313 PyObject * obj0 = 0 ;
31314 char *kwnames[] = {
31315 (char *) "clipboard", NULL
31316 };
31317
31318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
31319 if (obj0) {
31320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31321 if (SWIG_arg_fail(1)) SWIG_fail;
31322 }
31323 {
31324 PyThreadState* __tstate = wxPyBeginAllowThreads();
31325 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
31326
31327 wxPyEndAllowThreads(__tstate);
31328 if (PyErr_Occurred()) SWIG_fail;
31329 }
31330 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
31331 return resultobj;
31332 fail:
31333 return NULL;
31334 }
31335
31336
31337 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
31338 PyObject *resultobj = NULL;
31339 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
31340 PyObject * obj0 = 0 ;
31341 char *kwnames[] = {
31342 (char *) "self", NULL
31343 };
31344
31345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
31346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
31347 if (SWIG_arg_fail(1)) SWIG_fail;
31348 {
31349 PyThreadState* __tstate = wxPyBeginAllowThreads();
31350 delete arg1;
31351
31352 wxPyEndAllowThreads(__tstate);
31353 if (PyErr_Occurred()) SWIG_fail;
31354 }
31355 Py_INCREF(Py_None); resultobj = Py_None;
31356 return resultobj;
31357 fail:
31358 return NULL;
31359 }
31360
31361
31362 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
31363 PyObject *resultobj = NULL;
31364 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
31365 bool result;
31366 PyObject * obj0 = 0 ;
31367 char *kwnames[] = {
31368 (char *) "self", NULL
31369 };
31370
31371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
31372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
31373 if (SWIG_arg_fail(1)) SWIG_fail;
31374 {
31375 PyThreadState* __tstate = wxPyBeginAllowThreads();
31376 result = (bool)wxClipboardLocker___nonzero__(arg1);
31377
31378 wxPyEndAllowThreads(__tstate);
31379 if (PyErr_Occurred()) SWIG_fail;
31380 }
31381 {
31382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31383 }
31384 return resultobj;
31385 fail:
31386 return NULL;
31387 }
31388
31389
31390 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
31391 PyObject *obj;
31392 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31393 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
31394 Py_INCREF(obj);
31395 return Py_BuildValue((char *)"");
31396 }
31397 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
31398 PyObject *resultobj = NULL;
31399 int arg1 = (int) 0 ;
31400 int arg2 = (int) 0 ;
31401 int arg3 = (int) 0 ;
31402 int arg4 = (int) 0 ;
31403 wxVideoMode *result;
31404 PyObject * obj0 = 0 ;
31405 PyObject * obj1 = 0 ;
31406 PyObject * obj2 = 0 ;
31407 PyObject * obj3 = 0 ;
31408 char *kwnames[] = {
31409 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
31410 };
31411
31412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31413 if (obj0) {
31414 {
31415 arg1 = static_cast<int >(SWIG_As_int(obj0));
31416 if (SWIG_arg_fail(1)) SWIG_fail;
31417 }
31418 }
31419 if (obj1) {
31420 {
31421 arg2 = static_cast<int >(SWIG_As_int(obj1));
31422 if (SWIG_arg_fail(2)) SWIG_fail;
31423 }
31424 }
31425 if (obj2) {
31426 {
31427 arg3 = static_cast<int >(SWIG_As_int(obj2));
31428 if (SWIG_arg_fail(3)) SWIG_fail;
31429 }
31430 }
31431 if (obj3) {
31432 {
31433 arg4 = static_cast<int >(SWIG_As_int(obj3));
31434 if (SWIG_arg_fail(4)) SWIG_fail;
31435 }
31436 }
31437 {
31438 PyThreadState* __tstate = wxPyBeginAllowThreads();
31439 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
31440
31441 wxPyEndAllowThreads(__tstate);
31442 if (PyErr_Occurred()) SWIG_fail;
31443 }
31444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
31445 return resultobj;
31446 fail:
31447 return NULL;
31448 }
31449
31450
31451 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
31452 PyObject *resultobj = NULL;
31453 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31454 PyObject * obj0 = 0 ;
31455 char *kwnames[] = {
31456 (char *) "self", NULL
31457 };
31458
31459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
31460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31461 if (SWIG_arg_fail(1)) SWIG_fail;
31462 {
31463 PyThreadState* __tstate = wxPyBeginAllowThreads();
31464 delete arg1;
31465
31466 wxPyEndAllowThreads(__tstate);
31467 if (PyErr_Occurred()) SWIG_fail;
31468 }
31469 Py_INCREF(Py_None); resultobj = Py_None;
31470 return resultobj;
31471 fail:
31472 return NULL;
31473 }
31474
31475
31476 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
31477 PyObject *resultobj = NULL;
31478 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31479 wxVideoMode *arg2 = 0 ;
31480 bool result;
31481 PyObject * obj0 = 0 ;
31482 PyObject * obj1 = 0 ;
31483 char *kwnames[] = {
31484 (char *) "self",(char *) "other", NULL
31485 };
31486
31487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
31488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31489 if (SWIG_arg_fail(1)) SWIG_fail;
31490 {
31491 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31492 if (SWIG_arg_fail(2)) SWIG_fail;
31493 if (arg2 == NULL) {
31494 SWIG_null_ref("wxVideoMode");
31495 }
31496 if (SWIG_arg_fail(2)) SWIG_fail;
31497 }
31498 {
31499 PyThreadState* __tstate = wxPyBeginAllowThreads();
31500 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
31501
31502 wxPyEndAllowThreads(__tstate);
31503 if (PyErr_Occurred()) SWIG_fail;
31504 }
31505 {
31506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31507 }
31508 return resultobj;
31509 fail:
31510 return NULL;
31511 }
31512
31513
31514 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
31515 PyObject *resultobj = NULL;
31516 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31517 int result;
31518 PyObject * obj0 = 0 ;
31519 char *kwnames[] = {
31520 (char *) "self", NULL
31521 };
31522
31523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
31524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31525 if (SWIG_arg_fail(1)) SWIG_fail;
31526 {
31527 PyThreadState* __tstate = wxPyBeginAllowThreads();
31528 result = (int)((wxVideoMode const *)arg1)->GetWidth();
31529
31530 wxPyEndAllowThreads(__tstate);
31531 if (PyErr_Occurred()) SWIG_fail;
31532 }
31533 {
31534 resultobj = SWIG_From_int(static_cast<int >(result));
31535 }
31536 return resultobj;
31537 fail:
31538 return NULL;
31539 }
31540
31541
31542 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
31543 PyObject *resultobj = NULL;
31544 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31545 int result;
31546 PyObject * obj0 = 0 ;
31547 char *kwnames[] = {
31548 (char *) "self", NULL
31549 };
31550
31551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
31552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31553 if (SWIG_arg_fail(1)) SWIG_fail;
31554 {
31555 PyThreadState* __tstate = wxPyBeginAllowThreads();
31556 result = (int)((wxVideoMode const *)arg1)->GetHeight();
31557
31558 wxPyEndAllowThreads(__tstate);
31559 if (PyErr_Occurred()) SWIG_fail;
31560 }
31561 {
31562 resultobj = SWIG_From_int(static_cast<int >(result));
31563 }
31564 return resultobj;
31565 fail:
31566 return NULL;
31567 }
31568
31569
31570 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
31571 PyObject *resultobj = NULL;
31572 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31573 int result;
31574 PyObject * obj0 = 0 ;
31575 char *kwnames[] = {
31576 (char *) "self", NULL
31577 };
31578
31579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
31580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31581 if (SWIG_arg_fail(1)) SWIG_fail;
31582 {
31583 PyThreadState* __tstate = wxPyBeginAllowThreads();
31584 result = (int)((wxVideoMode const *)arg1)->GetDepth();
31585
31586 wxPyEndAllowThreads(__tstate);
31587 if (PyErr_Occurred()) SWIG_fail;
31588 }
31589 {
31590 resultobj = SWIG_From_int(static_cast<int >(result));
31591 }
31592 return resultobj;
31593 fail:
31594 return NULL;
31595 }
31596
31597
31598 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
31599 PyObject *resultobj = NULL;
31600 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31601 bool result;
31602 PyObject * obj0 = 0 ;
31603 char *kwnames[] = {
31604 (char *) "self", NULL
31605 };
31606
31607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
31608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31609 if (SWIG_arg_fail(1)) SWIG_fail;
31610 {
31611 PyThreadState* __tstate = wxPyBeginAllowThreads();
31612 result = (bool)((wxVideoMode const *)arg1)->IsOk();
31613
31614 wxPyEndAllowThreads(__tstate);
31615 if (PyErr_Occurred()) SWIG_fail;
31616 }
31617 {
31618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31619 }
31620 return resultobj;
31621 fail:
31622 return NULL;
31623 }
31624
31625
31626 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
31627 PyObject *resultobj = NULL;
31628 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31629 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
31630 bool result;
31631 PyObject * obj0 = 0 ;
31632 PyObject * obj1 = 0 ;
31633 char *kwnames[] = {
31634 (char *) "self",(char *) "other", NULL
31635 };
31636
31637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
31638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31639 if (SWIG_arg_fail(1)) SWIG_fail;
31640 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31641 if (SWIG_arg_fail(2)) SWIG_fail;
31642 {
31643 PyThreadState* __tstate = wxPyBeginAllowThreads();
31644 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
31645
31646 wxPyEndAllowThreads(__tstate);
31647 if (PyErr_Occurred()) SWIG_fail;
31648 }
31649 {
31650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31651 }
31652 return resultobj;
31653 fail:
31654 return NULL;
31655 }
31656
31657
31658 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
31659 PyObject *resultobj = NULL;
31660 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31661 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
31662 bool result;
31663 PyObject * obj0 = 0 ;
31664 PyObject * obj1 = 0 ;
31665 char *kwnames[] = {
31666 (char *) "self",(char *) "other", NULL
31667 };
31668
31669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
31670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31671 if (SWIG_arg_fail(1)) SWIG_fail;
31672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31673 if (SWIG_arg_fail(2)) SWIG_fail;
31674 {
31675 PyThreadState* __tstate = wxPyBeginAllowThreads();
31676 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
31677
31678 wxPyEndAllowThreads(__tstate);
31679 if (PyErr_Occurred()) SWIG_fail;
31680 }
31681 {
31682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31683 }
31684 return resultobj;
31685 fail:
31686 return NULL;
31687 }
31688
31689
31690 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
31691 PyObject *resultobj = NULL;
31692 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31693 int arg2 ;
31694 PyObject * obj0 = 0 ;
31695 PyObject * obj1 = 0 ;
31696 char *kwnames[] = {
31697 (char *) "self",(char *) "w", NULL
31698 };
31699
31700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
31701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31702 if (SWIG_arg_fail(1)) SWIG_fail;
31703 {
31704 arg2 = static_cast<int >(SWIG_As_int(obj1));
31705 if (SWIG_arg_fail(2)) SWIG_fail;
31706 }
31707 if (arg1) (arg1)->w = arg2;
31708
31709 Py_INCREF(Py_None); resultobj = Py_None;
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
31717 PyObject *resultobj = NULL;
31718 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31719 int result;
31720 PyObject * obj0 = 0 ;
31721 char *kwnames[] = {
31722 (char *) "self", NULL
31723 };
31724
31725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
31726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31727 if (SWIG_arg_fail(1)) SWIG_fail;
31728 result = (int) ((arg1)->w);
31729
31730 {
31731 resultobj = SWIG_From_int(static_cast<int >(result));
31732 }
31733 return resultobj;
31734 fail:
31735 return NULL;
31736 }
31737
31738
31739 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
31740 PyObject *resultobj = NULL;
31741 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31742 int arg2 ;
31743 PyObject * obj0 = 0 ;
31744 PyObject * obj1 = 0 ;
31745 char *kwnames[] = {
31746 (char *) "self",(char *) "h", NULL
31747 };
31748
31749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
31750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31751 if (SWIG_arg_fail(1)) SWIG_fail;
31752 {
31753 arg2 = static_cast<int >(SWIG_As_int(obj1));
31754 if (SWIG_arg_fail(2)) SWIG_fail;
31755 }
31756 if (arg1) (arg1)->h = arg2;
31757
31758 Py_INCREF(Py_None); resultobj = Py_None;
31759 return resultobj;
31760 fail:
31761 return NULL;
31762 }
31763
31764
31765 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
31766 PyObject *resultobj = NULL;
31767 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31768 int result;
31769 PyObject * obj0 = 0 ;
31770 char *kwnames[] = {
31771 (char *) "self", NULL
31772 };
31773
31774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
31775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31776 if (SWIG_arg_fail(1)) SWIG_fail;
31777 result = (int) ((arg1)->h);
31778
31779 {
31780 resultobj = SWIG_From_int(static_cast<int >(result));
31781 }
31782 return resultobj;
31783 fail:
31784 return NULL;
31785 }
31786
31787
31788 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
31789 PyObject *resultobj = NULL;
31790 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31791 int arg2 ;
31792 PyObject * obj0 = 0 ;
31793 PyObject * obj1 = 0 ;
31794 char *kwnames[] = {
31795 (char *) "self",(char *) "bpp", NULL
31796 };
31797
31798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
31799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31800 if (SWIG_arg_fail(1)) SWIG_fail;
31801 {
31802 arg2 = static_cast<int >(SWIG_As_int(obj1));
31803 if (SWIG_arg_fail(2)) SWIG_fail;
31804 }
31805 if (arg1) (arg1)->bpp = arg2;
31806
31807 Py_INCREF(Py_None); resultobj = Py_None;
31808 return resultobj;
31809 fail:
31810 return NULL;
31811 }
31812
31813
31814 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
31815 PyObject *resultobj = NULL;
31816 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31817 int result;
31818 PyObject * obj0 = 0 ;
31819 char *kwnames[] = {
31820 (char *) "self", NULL
31821 };
31822
31823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
31824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31825 if (SWIG_arg_fail(1)) SWIG_fail;
31826 result = (int) ((arg1)->bpp);
31827
31828 {
31829 resultobj = SWIG_From_int(static_cast<int >(result));
31830 }
31831 return resultobj;
31832 fail:
31833 return NULL;
31834 }
31835
31836
31837 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
31838 PyObject *resultobj = NULL;
31839 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31840 int arg2 ;
31841 PyObject * obj0 = 0 ;
31842 PyObject * obj1 = 0 ;
31843 char *kwnames[] = {
31844 (char *) "self",(char *) "refresh", NULL
31845 };
31846
31847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
31848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31849 if (SWIG_arg_fail(1)) SWIG_fail;
31850 {
31851 arg2 = static_cast<int >(SWIG_As_int(obj1));
31852 if (SWIG_arg_fail(2)) SWIG_fail;
31853 }
31854 if (arg1) (arg1)->refresh = arg2;
31855
31856 Py_INCREF(Py_None); resultobj = Py_None;
31857 return resultobj;
31858 fail:
31859 return NULL;
31860 }
31861
31862
31863 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
31864 PyObject *resultobj = NULL;
31865 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31866 int result;
31867 PyObject * obj0 = 0 ;
31868 char *kwnames[] = {
31869 (char *) "self", NULL
31870 };
31871
31872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
31873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31874 if (SWIG_arg_fail(1)) SWIG_fail;
31875 result = (int) ((arg1)->refresh);
31876
31877 {
31878 resultobj = SWIG_From_int(static_cast<int >(result));
31879 }
31880 return resultobj;
31881 fail:
31882 return NULL;
31883 }
31884
31885
31886 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
31887 PyObject *obj;
31888 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31889 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
31890 Py_INCREF(obj);
31891 return Py_BuildValue((char *)"");
31892 }
31893 static int _wrap_DefaultVideoMode_set(PyObject *) {
31894 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
31895 return 1;
31896 }
31897
31898
31899 static PyObject *_wrap_DefaultVideoMode_get(void) {
31900 PyObject *pyobj = NULL;
31901
31902 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
31903 return pyobj;
31904 }
31905
31906
31907 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
31908 PyObject *resultobj = NULL;
31909 size_t arg1 = (size_t) 0 ;
31910 wxDisplay *result;
31911 PyObject * obj0 = 0 ;
31912 char *kwnames[] = {
31913 (char *) "index", NULL
31914 };
31915
31916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
31917 if (obj0) {
31918 {
31919 arg1 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj0));
31920 if (SWIG_arg_fail(1)) SWIG_fail;
31921 }
31922 }
31923 {
31924 PyThreadState* __tstate = wxPyBeginAllowThreads();
31925 result = (wxDisplay *)new wxDisplay(arg1);
31926
31927 wxPyEndAllowThreads(__tstate);
31928 if (PyErr_Occurred()) SWIG_fail;
31929 }
31930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
31931 return resultobj;
31932 fail:
31933 return NULL;
31934 }
31935
31936
31937 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
31938 PyObject *resultobj = NULL;
31939 wxDisplay *arg1 = (wxDisplay *) 0 ;
31940 PyObject * obj0 = 0 ;
31941 char *kwnames[] = {
31942 (char *) "self", NULL
31943 };
31944
31945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
31946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31947 if (SWIG_arg_fail(1)) SWIG_fail;
31948 {
31949 PyThreadState* __tstate = wxPyBeginAllowThreads();
31950 delete arg1;
31951
31952 wxPyEndAllowThreads(__tstate);
31953 if (PyErr_Occurred()) SWIG_fail;
31954 }
31955 Py_INCREF(Py_None); resultobj = Py_None;
31956 return resultobj;
31957 fail:
31958 return NULL;
31959 }
31960
31961
31962 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
31963 PyObject *resultobj = NULL;
31964 size_t result;
31965 char *kwnames[] = {
31966 NULL
31967 };
31968
31969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
31970 {
31971 PyThreadState* __tstate = wxPyBeginAllowThreads();
31972 result = (size_t)wxDisplay::GetCount();
31973
31974 wxPyEndAllowThreads(__tstate);
31975 if (PyErr_Occurred()) SWIG_fail;
31976 }
31977 {
31978 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
31979 }
31980 return resultobj;
31981 fail:
31982 return NULL;
31983 }
31984
31985
31986 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
31987 PyObject *resultobj = NULL;
31988 wxPoint *arg1 = 0 ;
31989 int result;
31990 wxPoint temp1 ;
31991 PyObject * obj0 = 0 ;
31992 char *kwnames[] = {
31993 (char *) "pt", NULL
31994 };
31995
31996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
31997 {
31998 arg1 = &temp1;
31999 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
32000 }
32001 {
32002 PyThreadState* __tstate = wxPyBeginAllowThreads();
32003 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
32004
32005 wxPyEndAllowThreads(__tstate);
32006 if (PyErr_Occurred()) SWIG_fail;
32007 }
32008 {
32009 resultobj = SWIG_From_int(static_cast<int >(result));
32010 }
32011 return resultobj;
32012 fail:
32013 return NULL;
32014 }
32015
32016
32017 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32018 PyObject *resultobj = NULL;
32019 wxWindow *arg1 = (wxWindow *) 0 ;
32020 int result;
32021 PyObject * obj0 = 0 ;
32022 char *kwnames[] = {
32023 (char *) "window", NULL
32024 };
32025
32026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
32027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32028 if (SWIG_arg_fail(1)) SWIG_fail;
32029 {
32030 PyThreadState* __tstate = wxPyBeginAllowThreads();
32031 result = (int)wxDisplay_GetFromWindow(arg1);
32032
32033 wxPyEndAllowThreads(__tstate);
32034 if (PyErr_Occurred()) SWIG_fail;
32035 }
32036 {
32037 resultobj = SWIG_From_int(static_cast<int >(result));
32038 }
32039 return resultobj;
32040 fail:
32041 return NULL;
32042 }
32043
32044
32045 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
32046 PyObject *resultobj = NULL;
32047 wxDisplay *arg1 = (wxDisplay *) 0 ;
32048 bool result;
32049 PyObject * obj0 = 0 ;
32050 char *kwnames[] = {
32051 (char *) "self", NULL
32052 };
32053
32054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
32055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32056 if (SWIG_arg_fail(1)) SWIG_fail;
32057 {
32058 PyThreadState* __tstate = wxPyBeginAllowThreads();
32059 result = (bool)((wxDisplay const *)arg1)->IsOk();
32060
32061 wxPyEndAllowThreads(__tstate);
32062 if (PyErr_Occurred()) SWIG_fail;
32063 }
32064 {
32065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32066 }
32067 return resultobj;
32068 fail:
32069 return NULL;
32070 }
32071
32072
32073 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
32074 PyObject *resultobj = NULL;
32075 wxDisplay *arg1 = (wxDisplay *) 0 ;
32076 wxRect result;
32077 PyObject * obj0 = 0 ;
32078 char *kwnames[] = {
32079 (char *) "self", NULL
32080 };
32081
32082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
32083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32084 if (SWIG_arg_fail(1)) SWIG_fail;
32085 {
32086 PyThreadState* __tstate = wxPyBeginAllowThreads();
32087 result = ((wxDisplay const *)arg1)->GetGeometry();
32088
32089 wxPyEndAllowThreads(__tstate);
32090 if (PyErr_Occurred()) SWIG_fail;
32091 }
32092 {
32093 wxRect * resultptr;
32094 resultptr = new wxRect(static_cast<wxRect & >(result));
32095 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
32096 }
32097 return resultobj;
32098 fail:
32099 return NULL;
32100 }
32101
32102
32103 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
32104 PyObject *resultobj = NULL;
32105 wxDisplay *arg1 = (wxDisplay *) 0 ;
32106 wxString result;
32107 PyObject * obj0 = 0 ;
32108 char *kwnames[] = {
32109 (char *) "self", NULL
32110 };
32111
32112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
32113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32114 if (SWIG_arg_fail(1)) SWIG_fail;
32115 {
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 result = ((wxDisplay const *)arg1)->GetName();
32118
32119 wxPyEndAllowThreads(__tstate);
32120 if (PyErr_Occurred()) SWIG_fail;
32121 }
32122 {
32123 #if wxUSE_UNICODE
32124 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32125 #else
32126 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32127 #endif
32128 }
32129 return resultobj;
32130 fail:
32131 return NULL;
32132 }
32133
32134
32135 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
32136 PyObject *resultobj = NULL;
32137 wxDisplay *arg1 = (wxDisplay *) 0 ;
32138 bool result;
32139 PyObject * obj0 = 0 ;
32140 char *kwnames[] = {
32141 (char *) "self", NULL
32142 };
32143
32144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
32145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32146 if (SWIG_arg_fail(1)) SWIG_fail;
32147 {
32148 PyThreadState* __tstate = wxPyBeginAllowThreads();
32149 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
32150
32151 wxPyEndAllowThreads(__tstate);
32152 if (PyErr_Occurred()) SWIG_fail;
32153 }
32154 {
32155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32156 }
32157 return resultobj;
32158 fail:
32159 return NULL;
32160 }
32161
32162
32163 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
32164 PyObject *resultobj = NULL;
32165 wxDisplay *arg1 = (wxDisplay *) 0 ;
32166 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
32167 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
32168 PyObject *result;
32169 PyObject * obj0 = 0 ;
32170 PyObject * obj1 = 0 ;
32171 char *kwnames[] = {
32172 (char *) "self",(char *) "mode", NULL
32173 };
32174
32175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
32176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32177 if (SWIG_arg_fail(1)) SWIG_fail;
32178 if (obj1) {
32179 {
32180 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
32181 if (SWIG_arg_fail(2)) SWIG_fail;
32182 if (arg2 == NULL) {
32183 SWIG_null_ref("wxVideoMode");
32184 }
32185 if (SWIG_arg_fail(2)) SWIG_fail;
32186 }
32187 }
32188 {
32189 PyThreadState* __tstate = wxPyBeginAllowThreads();
32190 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
32191
32192 wxPyEndAllowThreads(__tstate);
32193 if (PyErr_Occurred()) SWIG_fail;
32194 }
32195 resultobj = result;
32196 return resultobj;
32197 fail:
32198 return NULL;
32199 }
32200
32201
32202 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
32203 PyObject *resultobj = NULL;
32204 wxDisplay *arg1 = (wxDisplay *) 0 ;
32205 wxVideoMode result;
32206 PyObject * obj0 = 0 ;
32207 char *kwnames[] = {
32208 (char *) "self", NULL
32209 };
32210
32211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
32212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32213 if (SWIG_arg_fail(1)) SWIG_fail;
32214 {
32215 PyThreadState* __tstate = wxPyBeginAllowThreads();
32216 result = ((wxDisplay const *)arg1)->GetCurrentMode();
32217
32218 wxPyEndAllowThreads(__tstate);
32219 if (PyErr_Occurred()) SWIG_fail;
32220 }
32221 {
32222 wxVideoMode * resultptr;
32223 resultptr = new wxVideoMode(static_cast<wxVideoMode & >(result));
32224 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
32225 }
32226 return resultobj;
32227 fail:
32228 return NULL;
32229 }
32230
32231
32232 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
32233 PyObject *resultobj = NULL;
32234 wxDisplay *arg1 = (wxDisplay *) 0 ;
32235 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
32236 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
32237 bool result;
32238 PyObject * obj0 = 0 ;
32239 PyObject * obj1 = 0 ;
32240 char *kwnames[] = {
32241 (char *) "self",(char *) "mode", NULL
32242 };
32243
32244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
32245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32246 if (SWIG_arg_fail(1)) SWIG_fail;
32247 if (obj1) {
32248 {
32249 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
32250 if (SWIG_arg_fail(2)) SWIG_fail;
32251 if (arg2 == NULL) {
32252 SWIG_null_ref("wxVideoMode");
32253 }
32254 if (SWIG_arg_fail(2)) SWIG_fail;
32255 }
32256 }
32257 {
32258 PyThreadState* __tstate = wxPyBeginAllowThreads();
32259 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
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_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
32274 PyObject *resultobj = NULL;
32275 wxDisplay *arg1 = (wxDisplay *) 0 ;
32276 PyObject * obj0 = 0 ;
32277 char *kwnames[] = {
32278 (char *) "self", NULL
32279 };
32280
32281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
32282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32283 if (SWIG_arg_fail(1)) SWIG_fail;
32284 {
32285 PyThreadState* __tstate = wxPyBeginAllowThreads();
32286 (arg1)->ResetMode();
32287
32288 wxPyEndAllowThreads(__tstate);
32289 if (PyErr_Occurred()) SWIG_fail;
32290 }
32291 Py_INCREF(Py_None); resultobj = Py_None;
32292 return resultobj;
32293 fail:
32294 return NULL;
32295 }
32296
32297
32298 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
32299 PyObject *obj;
32300 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32301 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
32302 Py_INCREF(obj);
32303 return Py_BuildValue((char *)"");
32304 }
32305 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
32306 PyObject *resultobj = NULL;
32307 wxStandardPaths *result;
32308 char *kwnames[] = {
32309 NULL
32310 };
32311
32312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
32313 {
32314 PyThreadState* __tstate = wxPyBeginAllowThreads();
32315 result = (wxStandardPaths *)wxStandardPaths_Get();
32316
32317 wxPyEndAllowThreads(__tstate);
32318 if (PyErr_Occurred()) SWIG_fail;
32319 }
32320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
32321 return resultobj;
32322 fail:
32323 return NULL;
32324 }
32325
32326
32327 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
32328 PyObject *resultobj = NULL;
32329 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32330 wxString result;
32331 PyObject * obj0 = 0 ;
32332 char *kwnames[] = {
32333 (char *) "self", NULL
32334 };
32335
32336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
32337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32338 if (SWIG_arg_fail(1)) SWIG_fail;
32339 {
32340 PyThreadState* __tstate = wxPyBeginAllowThreads();
32341 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
32342
32343 wxPyEndAllowThreads(__tstate);
32344 if (PyErr_Occurred()) SWIG_fail;
32345 }
32346 {
32347 #if wxUSE_UNICODE
32348 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32349 #else
32350 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32351 #endif
32352 }
32353 return resultobj;
32354 fail:
32355 return NULL;
32356 }
32357
32358
32359 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
32360 PyObject *resultobj = NULL;
32361 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32362 wxString result;
32363 PyObject * obj0 = 0 ;
32364 char *kwnames[] = {
32365 (char *) "self", NULL
32366 };
32367
32368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
32369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32370 if (SWIG_arg_fail(1)) SWIG_fail;
32371 {
32372 PyThreadState* __tstate = wxPyBeginAllowThreads();
32373 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
32374
32375 wxPyEndAllowThreads(__tstate);
32376 if (PyErr_Occurred()) SWIG_fail;
32377 }
32378 {
32379 #if wxUSE_UNICODE
32380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32381 #else
32382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32383 #endif
32384 }
32385 return resultobj;
32386 fail:
32387 return NULL;
32388 }
32389
32390
32391 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
32392 PyObject *resultobj = NULL;
32393 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32394 wxString result;
32395 PyObject * obj0 = 0 ;
32396 char *kwnames[] = {
32397 (char *) "self", NULL
32398 };
32399
32400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
32401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32402 if (SWIG_arg_fail(1)) SWIG_fail;
32403 {
32404 PyThreadState* __tstate = wxPyBeginAllowThreads();
32405 result = ((wxStandardPaths const *)arg1)->GetDataDir();
32406
32407 wxPyEndAllowThreads(__tstate);
32408 if (PyErr_Occurred()) SWIG_fail;
32409 }
32410 {
32411 #if wxUSE_UNICODE
32412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32413 #else
32414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32415 #endif
32416 }
32417 return resultobj;
32418 fail:
32419 return NULL;
32420 }
32421
32422
32423 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
32424 PyObject *resultobj = NULL;
32425 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32426 wxString result;
32427 PyObject * obj0 = 0 ;
32428 char *kwnames[] = {
32429 (char *) "self", NULL
32430 };
32431
32432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
32433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32434 if (SWIG_arg_fail(1)) SWIG_fail;
32435 {
32436 PyThreadState* __tstate = wxPyBeginAllowThreads();
32437 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
32438
32439 wxPyEndAllowThreads(__tstate);
32440 if (PyErr_Occurred()) SWIG_fail;
32441 }
32442 {
32443 #if wxUSE_UNICODE
32444 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32445 #else
32446 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32447 #endif
32448 }
32449 return resultobj;
32450 fail:
32451 return NULL;
32452 }
32453
32454
32455 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
32456 PyObject *resultobj = NULL;
32457 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32458 wxString result;
32459 PyObject * obj0 = 0 ;
32460 char *kwnames[] = {
32461 (char *) "self", NULL
32462 };
32463
32464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
32465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32466 if (SWIG_arg_fail(1)) SWIG_fail;
32467 {
32468 PyThreadState* __tstate = wxPyBeginAllowThreads();
32469 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
32470
32471 wxPyEndAllowThreads(__tstate);
32472 if (PyErr_Occurred()) SWIG_fail;
32473 }
32474 {
32475 #if wxUSE_UNICODE
32476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32477 #else
32478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32479 #endif
32480 }
32481 return resultobj;
32482 fail:
32483 return NULL;
32484 }
32485
32486
32487 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
32488 PyObject *resultobj = NULL;
32489 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32490 wxString result;
32491 PyObject * obj0 = 0 ;
32492 char *kwnames[] = {
32493 (char *) "self", NULL
32494 };
32495
32496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
32497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32498 if (SWIG_arg_fail(1)) SWIG_fail;
32499 {
32500 PyThreadState* __tstate = wxPyBeginAllowThreads();
32501 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
32502
32503 wxPyEndAllowThreads(__tstate);
32504 if (PyErr_Occurred()) SWIG_fail;
32505 }
32506 {
32507 #if wxUSE_UNICODE
32508 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32509 #else
32510 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32511 #endif
32512 }
32513 return resultobj;
32514 fail:
32515 return NULL;
32516 }
32517
32518
32519 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
32520 PyObject *resultobj = NULL;
32521 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32522 wxString result;
32523 PyObject * obj0 = 0 ;
32524 char *kwnames[] = {
32525 (char *) "self", NULL
32526 };
32527
32528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
32529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32530 if (SWIG_arg_fail(1)) SWIG_fail;
32531 {
32532 PyThreadState* __tstate = wxPyBeginAllowThreads();
32533 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
32534
32535 wxPyEndAllowThreads(__tstate);
32536 if (PyErr_Occurred()) SWIG_fail;
32537 }
32538 {
32539 #if wxUSE_UNICODE
32540 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32541 #else
32542 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32543 #endif
32544 }
32545 return resultobj;
32546 fail:
32547 return NULL;
32548 }
32549
32550
32551 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
32552 PyObject *resultobj = NULL;
32553 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32554 wxString *arg2 = 0 ;
32555 bool temp2 = false ;
32556 PyObject * obj0 = 0 ;
32557 PyObject * obj1 = 0 ;
32558 char *kwnames[] = {
32559 (char *) "self",(char *) "prefix", NULL
32560 };
32561
32562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
32563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32564 if (SWIG_arg_fail(1)) SWIG_fail;
32565 {
32566 arg2 = wxString_in_helper(obj1);
32567 if (arg2 == NULL) SWIG_fail;
32568 temp2 = true;
32569 }
32570 {
32571 PyThreadState* __tstate = wxPyBeginAllowThreads();
32572 (arg1)->SetInstallPrefix((wxString const &)*arg2);
32573
32574 wxPyEndAllowThreads(__tstate);
32575 if (PyErr_Occurred()) SWIG_fail;
32576 }
32577 Py_INCREF(Py_None); resultobj = Py_None;
32578 {
32579 if (temp2)
32580 delete arg2;
32581 }
32582 return resultobj;
32583 fail:
32584 {
32585 if (temp2)
32586 delete arg2;
32587 }
32588 return NULL;
32589 }
32590
32591
32592 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
32593 PyObject *resultobj = NULL;
32594 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32595 wxString result;
32596 PyObject * obj0 = 0 ;
32597 char *kwnames[] = {
32598 (char *) "self", NULL
32599 };
32600
32601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
32602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32603 if (SWIG_arg_fail(1)) SWIG_fail;
32604 {
32605 PyThreadState* __tstate = wxPyBeginAllowThreads();
32606 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
32607
32608 wxPyEndAllowThreads(__tstate);
32609 if (PyErr_Occurred()) SWIG_fail;
32610 }
32611 {
32612 #if wxUSE_UNICODE
32613 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32614 #else
32615 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32616 #endif
32617 }
32618 return resultobj;
32619 fail:
32620 return NULL;
32621 }
32622
32623
32624 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
32625 PyObject *obj;
32626 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32627 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
32628 Py_INCREF(obj);
32629 return Py_BuildValue((char *)"");
32630 }
32631 static PyMethodDef SwigMethods[] = {
32632 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
32633 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
32634 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
32635 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
32636 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
32637 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
32638 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
32639 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
32640 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
32641 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
32642 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
32643 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
32644 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
32645 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
32646 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
32647 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
32648 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
32649 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
32650 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
32651 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
32652 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
32653 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
32654 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32655 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
32656 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
32657 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
32658 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
32659 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
32660 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
32661 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
32662 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
32663 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
32664 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
32665 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
32666 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
32667 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
32668 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
32669 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
32670 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
32671 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
32672 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
32673 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
32674 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
32675 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
32676 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
32677 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
32678 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
32679 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
32680 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
32681 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
32682 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
32683 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
32684 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
32685 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
32686 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
32687 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
32688 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32689 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32690 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
32691 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
32692 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
32693 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
32694 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
32695 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
32696 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32697 { (char *)"GetXDisplay", (PyCFunction) _wrap_GetXDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
32698 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32699 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
32700 { (char *)"FindWindowAtPointer", (PyCFunction) _wrap_FindWindowAtPointer, METH_VARARGS | METH_KEYWORDS, NULL},
32701 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32702 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32703 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32704 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
32705 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
32706 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
32707 { (char *)"new_MouseState", (PyCFunction) _wrap_new_MouseState, METH_VARARGS | METH_KEYWORDS, NULL},
32708 { (char *)"delete_MouseState", (PyCFunction) _wrap_delete_MouseState, METH_VARARGS | METH_KEYWORDS, NULL},
32709 { (char *)"MouseState_GetX", (PyCFunction) _wrap_MouseState_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
32710 { (char *)"MouseState_GetY", (PyCFunction) _wrap_MouseState_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
32711 { (char *)"MouseState_LeftDown", (PyCFunction) _wrap_MouseState_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
32712 { (char *)"MouseState_MiddleDown", (PyCFunction) _wrap_MouseState_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
32713 { (char *)"MouseState_RightDown", (PyCFunction) _wrap_MouseState_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
32714 { (char *)"MouseState_ControlDown", (PyCFunction) _wrap_MouseState_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
32715 { (char *)"MouseState_ShiftDown", (PyCFunction) _wrap_MouseState_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
32716 { (char *)"MouseState_AltDown", (PyCFunction) _wrap_MouseState_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
32717 { (char *)"MouseState_MetaDown", (PyCFunction) _wrap_MouseState_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
32718 { (char *)"MouseState_CmdDown", (PyCFunction) _wrap_MouseState_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
32719 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
32720 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
32721 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
32722 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
32723 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
32724 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
32725 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
32726 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
32727 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
32728 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
32729 { (char *)"GetMouseState", (PyCFunction) _wrap_GetMouseState, METH_VARARGS | METH_KEYWORDS, NULL},
32730 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
32731 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32732 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32733 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32734 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32735 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
32736 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
32737 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
32738 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
32739 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
32740 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32741 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
32742 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
32743 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
32744 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
32745 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
32746 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32747 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
32748 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32749 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
32750 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32751 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
32752 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32753 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
32754 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
32755 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
32756 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32757 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
32758 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
32759 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
32760 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
32761 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
32762 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32763 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32764 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
32765 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
32766 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
32767 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
32768 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32769 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32770 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
32771 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
32772 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
32773 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
32774 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
32775 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
32776 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
32777 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
32778 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
32779 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
32780 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
32781 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
32782 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
32783 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
32784 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
32785 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
32786 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
32787 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
32788 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
32789 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32790 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
32791 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
32792 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
32793 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
32794 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
32795 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
32796 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
32797 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
32798 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32799 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
32800 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
32801 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
32802 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
32803 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32804 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32805 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
32806 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
32807 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32808 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
32809 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
32810 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32811 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
32812 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
32813 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
32814 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
32815 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
32816 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
32817 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
32818 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32819 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
32820 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
32821 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
32822 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
32823 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
32824 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
32825 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
32826 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
32827 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
32828 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
32829 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
32830 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
32831 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32832 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
32833 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32834 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32835 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
32836 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
32837 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
32838 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
32839 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
32840 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32841 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32842 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32843 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
32844 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
32845 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
32846 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
32847 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32848 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
32849 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
32850 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
32851 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
32852 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
32853 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
32854 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
32855 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
32856 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
32857 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
32858 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
32859 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
32860 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32861 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
32862 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
32863 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
32864 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
32865 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
32866 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
32867 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
32868 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
32869 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
32870 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
32871 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
32872 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
32873 { (char *)"new_LogBuffer", (PyCFunction) _wrap_new_LogBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
32874 { (char *)"LogBuffer_GetBuffer", (PyCFunction) _wrap_LogBuffer_GetBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
32875 { (char *)"LogBuffer_Flush", (PyCFunction) _wrap_LogBuffer_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32876 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
32877 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
32878 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
32879 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
32880 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
32881 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
32882 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
32883 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32884 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
32885 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
32886 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
32887 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
32888 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
32889 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
32890 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
32891 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
32892 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
32893 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
32894 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
32895 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
32896 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32897 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
32898 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
32899 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
32900 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32901 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
32902 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32903 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
32904 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
32905 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
32906 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
32907 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
32908 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
32909 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
32910 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
32911 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32912 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
32913 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
32914 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
32915 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
32916 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
32917 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
32918 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
32919 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
32920 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
32921 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
32922 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
32923 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
32924 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
32925 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
32926 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
32927 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32928 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32929 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
32930 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32931 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32932 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32933 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32934 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32935 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
32936 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
32937 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32938 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
32939 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
32940 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
32941 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
32942 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
32943 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
32944 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
32945 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
32946 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
32947 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
32948 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
32949 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
32950 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
32951 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
32952 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
32953 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
32954 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
32955 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
32956 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
32957 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
32958 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
32959 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
32960 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
32961 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
32962 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
32963 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
32964 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
32965 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
32966 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
32967 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
32968 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
32969 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
32970 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
32971 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32972 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32973 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
32974 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
32975 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
32976 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
32977 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
32978 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
32979 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32980 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32981 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
32982 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
32983 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
32984 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
32985 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
32986 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
32987 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
32988 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
32989 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
32990 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
32991 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
32992 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
32993 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32994 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
32995 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
32996 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
32997 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
32998 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32999 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
33000 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33001 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
33002 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
33003 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
33004 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
33005 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33006 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33007 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
33008 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
33009 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
33010 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
33011 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
33012 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
33013 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
33014 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
33015 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
33016 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
33017 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
33018 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
33019 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
33020 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33021 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
33022 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33023 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33024 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
33025 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33026 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
33027 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
33028 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33029 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
33030 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
33031 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
33032 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
33033 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
33034 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
33035 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
33036 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
33037 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
33038 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
33039 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
33040 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
33041 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
33042 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
33043 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
33044 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33045 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33046 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33047 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33048 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33049 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
33050 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
33051 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
33052 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
33053 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
33054 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
33055 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
33056 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
33057 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
33058 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
33059 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
33060 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
33061 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33062 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33063 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33064 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33065 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
33066 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
33067 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33068 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33069 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
33070 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
33071 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
33072 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
33073 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
33074 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
33075 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
33076 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
33077 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
33078 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
33079 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
33080 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33081 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33082 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33083 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33084 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
33085 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
33086 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
33087 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
33088 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
33089 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
33090 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
33091 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
33092 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
33093 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
33094 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
33095 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
33096 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
33097 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
33098 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
33099 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
33100 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
33101 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
33102 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
33103 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
33104 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
33105 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
33106 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
33107 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
33108 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
33109 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
33110 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
33111 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
33112 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
33113 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33114 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
33115 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
33116 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
33117 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33118 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
33119 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
33120 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
33121 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
33122 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
33123 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
33124 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
33125 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
33126 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
33127 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
33128 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
33129 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
33130 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
33131 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
33132 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
33133 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
33134 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
33135 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
33136 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
33137 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
33138 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
33139 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
33140 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33141 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
33142 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
33143 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
33144 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
33145 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
33146 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
33147 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
33148 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33149 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33150 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33151 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33152 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33153 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33154 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33155 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
33156 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
33157 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
33158 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
33159 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
33160 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
33161 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
33162 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
33163 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
33164 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
33165 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
33166 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
33167 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
33168 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
33169 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
33170 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
33171 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
33172 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
33173 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
33174 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
33175 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
33176 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
33177 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
33178 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
33179 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
33180 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
33181 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33182 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
33183 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33184 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
33185 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
33186 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
33187 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
33188 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
33189 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
33190 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33191 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
33192 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
33193 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
33194 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
33195 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
33196 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
33197 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
33198 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
33199 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
33200 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
33201 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
33202 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
33203 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
33204 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
33205 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
33206 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
33207 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
33208 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
33209 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
33210 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
33211 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
33212 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
33213 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
33214 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33215 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
33216 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33217 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
33218 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
33219 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
33220 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
33221 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
33222 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
33223 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
33224 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
33225 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
33226 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
33227 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
33228 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
33229 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
33230 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
33231 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
33232 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
33233 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
33234 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
33235 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
33236 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
33237 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
33238 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
33239 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
33240 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
33241 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
33242 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
33243 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
33244 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
33245 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
33246 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
33247 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
33248 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
33249 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
33250 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
33251 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
33252 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
33253 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
33254 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
33255 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
33256 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33257 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
33258 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
33259 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
33260 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
33261 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
33262 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
33263 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
33264 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
33265 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
33266 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
33267 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
33268 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
33269 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
33270 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
33271 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
33272 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
33273 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
33274 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
33275 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
33276 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
33277 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
33278 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
33279 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
33280 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
33281 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
33282 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
33283 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
33284 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
33285 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
33286 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
33287 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
33288 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
33289 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
33290 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
33291 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
33292 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
33293 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
33294 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
33295 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
33296 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
33297 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
33298 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
33299 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
33300 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
33301 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
33302 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
33303 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33304 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
33305 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
33306 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
33307 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
33308 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
33309 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33310 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33311 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33312 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
33313 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
33314 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
33315 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
33316 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
33317 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
33318 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
33319 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33320 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33321 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
33322 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
33323 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
33324 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
33325 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
33326 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33327 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
33328 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
33329 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33330 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33331 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
33332 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
33333 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33334 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
33335 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
33336 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33337 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
33338 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
33339 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
33340 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
33341 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33342 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
33343 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
33344 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
33345 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
33346 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33347 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33348 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
33349 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33350 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
33351 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
33352 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
33353 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33354 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33355 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
33356 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33357 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
33358 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
33359 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
33360 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
33361 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33362 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
33363 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
33364 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
33365 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33366 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
33367 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
33368 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
33369 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33370 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
33371 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
33372 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
33373 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33374 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
33375 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33376 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33377 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
33378 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
33379 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
33380 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
33381 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33382 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33383 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33384 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33385 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33386 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
33387 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
33388 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
33389 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
33390 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
33391 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
33392 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
33393 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
33394 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33395 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33396 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
33397 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
33398 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
33399 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
33400 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
33401 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
33402 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33403 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33404 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
33405 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
33406 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
33407 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
33408 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
33409 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
33410 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
33411 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
33412 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
33413 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
33414 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
33415 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
33416 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33417 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
33418 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
33419 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
33420 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
33421 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
33422 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
33423 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
33424 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
33425 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
33426 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
33427 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
33428 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
33429 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
33430 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
33431 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
33432 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
33433 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
33434 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
33435 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
33436 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33437 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
33438 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
33439 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
33440 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
33441 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
33442 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
33443 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
33444 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
33445 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
33446 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
33447 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
33448 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
33449 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
33450 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
33451 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
33452 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
33453 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
33454 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
33455 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
33456 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
33457 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
33458 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
33459 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
33460 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
33461 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
33462 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
33463 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
33464 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
33465 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
33466 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
33467 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
33468 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
33469 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
33470 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
33471 { NULL, NULL, 0, NULL }
33472 };
33473
33474
33475 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
33476
33477 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
33478 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
33479 }
33480 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
33481 return (void *)((wxEvent *) ((wxMenuEvent *) x));
33482 }
33483 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
33484 return (void *)((wxEvent *) ((wxCloseEvent *) x));
33485 }
33486 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
33487 return (void *)((wxEvent *) ((wxMouseEvent *) x));
33488 }
33489 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
33490 return (void *)((wxEvent *) ((wxEraseEvent *) x));
33491 }
33492 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
33493 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
33494 }
33495 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
33496 return (void *)((wxEvent *) ((wxTimerEvent *) x));
33497 }
33498 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
33499 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
33500 }
33501 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
33502 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
33503 }
33504 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
33505 return (void *)((wxEvent *) ((wxPyEvent *) x));
33506 }
33507 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
33508 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
33509 }
33510 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
33511 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
33512 }
33513 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
33514 return (void *)((wxEvent *) ((wxIdleEvent *) x));
33515 }
33516 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
33517 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
33518 }
33519 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
33520 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
33521 }
33522 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
33523 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
33524 }
33525 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
33526 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
33527 }
33528 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
33529 return (void *)((wxEvent *) ((wxActivateEvent *) x));
33530 }
33531 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
33532 return (void *)((wxEvent *) ((wxSizeEvent *) x));
33533 }
33534 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
33535 return (void *)((wxEvent *) ((wxMoveEvent *) x));
33536 }
33537 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
33538 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
33539 }
33540 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
33541 return (void *)((wxEvent *) ((wxPaintEvent *) x));
33542 }
33543 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
33544 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
33545 }
33546 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
33547 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
33548 }
33549 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
33550 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
33551 }
33552 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
33553 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
33554 }
33555 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
33556 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
33557 }
33558 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
33559 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
33560 }
33561 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
33562 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
33563 }
33564 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
33565 return (void *)((wxEvent *) ((wxFocusEvent *) x));
33566 }
33567 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
33568 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
33569 }
33570 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
33571 return (void *)((wxEvent *) ((wxProcessEvent *) x));
33572 }
33573 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
33574 return (void *)((wxEvent *) ((wxShowEvent *) x));
33575 }
33576 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
33577 return (void *)((wxEvent *) ((wxCommandEvent *) x));
33578 }
33579 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
33580 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
33581 }
33582 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
33583 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
33584 }
33585 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
33586 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
33587 }
33588 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
33589 return (void *)((wxEvent *) ((wxKeyEvent *) x));
33590 }
33591 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
33592 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
33593 }
33594 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
33595 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
33596 }
33597 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
33598 return (void *)((wxConfigBase *) ((wxConfig *) x));
33599 }
33600 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
33601 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
33602 }
33603 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
33604 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
33605 }
33606 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
33607 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
33608 }
33609 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
33610 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
33611 }
33612 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
33613 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
33614 }
33615 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
33616 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
33617 }
33618 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
33619 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
33620 }
33621 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
33622 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
33623 }
33624 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
33625 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
33626 }
33627 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
33628 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
33629 }
33630 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
33631 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
33632 }
33633 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
33634 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
33635 }
33636 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
33637 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
33638 }
33639 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
33640 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
33641 }
33642 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
33643 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
33644 }
33645 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
33646 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
33647 }
33648 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
33649 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
33650 }
33651 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
33652 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
33653 }
33654 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
33655 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
33656 }
33657 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
33658 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
33659 }
33660 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
33661 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
33662 }
33663 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
33664 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
33665 }
33666 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
33667 return (void *)((wxEvtHandler *) ((wxWindow *) x));
33668 }
33669 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
33670 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
33671 }
33672 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
33673 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
33674 }
33675 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
33676 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
33677 }
33678 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
33679 return (void *)((wxEvtHandler *) ((wxValidator *) x));
33680 }
33681 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
33682 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
33683 }
33684 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
33685 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
33686 }
33687 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
33688 return (void *)((wxEvtHandler *) ((wxMenu *) x));
33689 }
33690 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
33691 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
33692 }
33693 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
33694 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
33695 }
33696 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
33697 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
33698 }
33699 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
33700 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
33701 }
33702 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
33703 return (void *)((wxObject *) ((wxSizerItem *) x));
33704 }
33705 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
33706 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
33707 }
33708 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
33709 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
33710 }
33711 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
33712 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
33713 }
33714 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
33715 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
33716 }
33717 static void *_p_wxSizerTo_p_wxObject(void *x) {
33718 return (void *)((wxObject *) ((wxSizer *) x));
33719 }
33720 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
33721 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
33722 }
33723 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
33724 return (void *)((wxObject *) ((wxFileHistory *) x));
33725 }
33726 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
33727 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
33728 }
33729 static void *_p_wxEventTo_p_wxObject(void *x) {
33730 return (void *)((wxObject *) ((wxEvent *) x));
33731 }
33732 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
33733 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
33734 }
33735 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
33736 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
33737 }
33738 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
33739 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
33740 }
33741 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
33742 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
33743 }
33744 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
33745 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
33746 }
33747 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
33748 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
33749 }
33750 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
33751 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
33752 }
33753 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
33754 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
33755 }
33756 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
33757 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
33758 }
33759 static void *_p_wxControlTo_p_wxObject(void *x) {
33760 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
33761 }
33762 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
33763 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
33764 }
33765 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
33766 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
33767 }
33768 static void *_p_wxFSFileTo_p_wxObject(void *x) {
33769 return (void *)((wxObject *) ((wxFSFile *) x));
33770 }
33771 static void *_p_wxClipboardTo_p_wxObject(void *x) {
33772 return (void *)((wxObject *) ((wxClipboard *) x));
33773 }
33774 static void *_p_wxPySizerTo_p_wxObject(void *x) {
33775 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
33776 }
33777 static void *_p_wxPyEventTo_p_wxObject(void *x) {
33778 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
33779 }
33780 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
33781 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
33782 }
33783 static void *_p_wxShowEventTo_p_wxObject(void *x) {
33784 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
33785 }
33786 static void *_p_wxToolTipTo_p_wxObject(void *x) {
33787 return (void *)((wxObject *) ((wxToolTip *) x));
33788 }
33789 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
33790 return (void *)((wxObject *) ((wxMenuItem *) x));
33791 }
33792 static void *_p_wxDateEventTo_p_wxObject(void *x) {
33793 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
33794 }
33795 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
33796 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
33797 }
33798 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
33799 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
33800 }
33801 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
33802 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
33803 }
33804 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
33805 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
33806 }
33807 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
33808 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
33809 }
33810 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
33811 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
33812 }
33813 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
33814 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
33815 }
33816 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
33817 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
33818 }
33819 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
33820 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
33821 }
33822 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
33823 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
33824 }
33825 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
33826 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
33827 }
33828 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
33829 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
33830 }
33831 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
33832 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
33833 }
33834 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
33835 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
33836 }
33837 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
33838 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
33839 }
33840 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
33841 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
33842 }
33843 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
33844 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
33845 }
33846 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
33847 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
33848 }
33849 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
33850 return (void *)((wxObject *) ((wxImageHandler *) x));
33851 }
33852 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
33853 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
33854 }
33855 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
33856 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
33857 }
33858 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
33859 return (void *)((wxObject *) ((wxEvtHandler *) x));
33860 }
33861 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
33862 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
33863 }
33864 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
33865 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
33866 }
33867 static void *_p_wxImageTo_p_wxObject(void *x) {
33868 return (void *)((wxObject *) ((wxImage *) x));
33869 }
33870 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
33871 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
33872 }
33873 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
33874 return (void *)((wxObject *) ((wxSystemOptions *) x));
33875 }
33876 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
33877 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
33878 }
33879 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
33880 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
33881 }
33882 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
33883 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
33884 }
33885 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
33886 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
33887 }
33888 static void *_p_wxWindowTo_p_wxObject(void *x) {
33889 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
33890 }
33891 static void *_p_wxMenuTo_p_wxObject(void *x) {
33892 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
33893 }
33894 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
33895 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
33896 }
33897 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
33898 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
33899 }
33900 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
33901 return (void *)((wxObject *) ((wxFileSystem *) x));
33902 }
33903 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
33904 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
33905 }
33906 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
33907 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
33908 }
33909 static void *_p_wxPyAppTo_p_wxObject(void *x) {
33910 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
33911 }
33912 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
33913 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
33914 }
33915 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
33916 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
33917 }
33918 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
33919 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
33920 }
33921 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
33922 return (void *)((wxObject *) ((wxBusyInfo *) x));
33923 }
33924 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
33925 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
33926 }
33927 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
33928 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
33929 }
33930 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
33931 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
33932 }
33933 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
33934 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
33935 }
33936 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
33937 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
33938 }
33939 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
33940 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
33941 }
33942 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
33943 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
33944 }
33945 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
33946 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
33947 }
33948 static void *_p_wxValidatorTo_p_wxObject(void *x) {
33949 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
33950 }
33951 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
33952 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
33953 }
33954 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
33955 return (void *)((wxLog *) ((wxLogBuffer *) x));
33956 }
33957 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
33958 return (void *)((wxLog *) ((wxLogStderr *) x));
33959 }
33960 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
33961 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
33962 }
33963 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
33964 return (void *)((wxLog *) ((wxLogWindow *) x));
33965 }
33966 static void *_p_wxLogChainTo_p_wxLog(void *x) {
33967 return (void *)((wxLog *) ((wxLogChain *) x));
33968 }
33969 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
33970 return (void *)((wxLog *) ((wxLogGui *) x));
33971 }
33972 static void *_p_wxPyLogTo_p_wxLog(void *x) {
33973 return (void *)((wxLog *) ((wxPyLog *) x));
33974 }
33975 static void *_p_wxControlTo_p_wxWindow(void *x) {
33976 return (void *)((wxWindow *) ((wxControl *) x));
33977 }
33978 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
33979 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
33980 }
33981 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
33982 return (void *)((wxWindow *) ((wxMenuBar *) x));
33983 }
33984 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
33985 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
33986 }
33987 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
33988 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
33989 }
33990 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
33991 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, 0};
33992 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
33993 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, 0};
33994 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, 0};
33995 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, 0};
33996 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, 0};
33997 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, 0};
33998 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, 0};
33999 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, 0};
34000 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, 0};
34001 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, 0};
34002 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, 0};
34003 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, 0};
34004 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, 0};
34005 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, 0};
34006 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, 0};
34007 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, 0};
34008 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, 0};
34009 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, 0};
34010 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, 0};
34011 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, 0};
34012 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, 0};
34013 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, 0};
34014 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, 0};
34015 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, 0};
34016 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, 0};
34017 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, 0};
34018 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, 0};
34019 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, 0};
34020 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, 0};
34021 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0};
34022 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, 0};
34023 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0};
34024 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0};
34025 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0};
34026 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0};
34027 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0};
34028 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0};
34029 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0};
34030 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0};
34031 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0};
34032 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0};
34033 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0};
34034 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0};
34035 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0};
34036 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0};
34037 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0};
34038 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0};
34039 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0};
34040 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0};
34041 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0};
34042 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0};
34043 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0};
34044 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0};
34045 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0};
34046 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0};
34047 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0};
34048 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0};
34049 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0};
34050 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0};
34051 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0};
34052 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0};
34053 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0};
34054 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0};
34055 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0};
34056 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0};
34057 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0};
34058 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0};
34059 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, 0};
34060 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0};
34061 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0};
34062 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0};
34063 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0};
34064 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0};
34065 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0};
34066 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, 0};
34067 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, 0};
34068 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, 0};
34069 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, 0};
34070 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, 0};
34071 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, 0};
34072 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, 0};
34073 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, 0};
34074 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, 0};
34075 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, 0};
34076 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, 0};
34077 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, 0};
34078 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, 0};
34079 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, 0};
34080 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, 0};
34081 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, 0};
34082 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, 0};
34083 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, 0};
34084 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, 0};
34085 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, 0};
34086 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, 0};
34087 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, 0};
34088 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, 0};
34089 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, 0};
34090 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, 0};
34091 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, 0};
34092 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0};
34093 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0};
34094 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0};
34095 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0};
34096 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0};
34097 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0};
34098 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0};
34099 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0};
34100 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0};
34101 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0};
34102 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0};
34103 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0};
34104 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0};
34105 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0};
34106 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0};
34107 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0};
34108 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0};
34109 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0};
34110 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0};
34111 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0};
34112 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0};
34113 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0};
34114 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0};
34115 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0};
34116 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0};
34117 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0};
34118 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0};
34119 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0};
34120 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0};
34121 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0};
34122 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, 0};
34123 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, 0};
34124 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, 0};
34125 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, 0};
34126 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, 0};
34127 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, 0};
34128 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, 0};
34129 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, 0};
34130 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, 0};
34131 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, 0};
34132 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, 0};
34133 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, 0};
34134 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, 0};
34135 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, 0};
34136 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, 0};
34137 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, 0};
34138 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, 0};
34139 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, 0};
34140 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, 0};
34141 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, 0};
34142 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, 0};
34143 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, 0};
34144 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, 0};
34145 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, 0};
34146 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, 0};
34147 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, 0};
34148 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, 0};
34149 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, 0};
34150 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, 0};
34151 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, 0};
34152 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, 0};
34153 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, 0};
34154 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, 0};
34155 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, 0};
34156 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, 0};
34157 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, 0};
34158 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, 0};
34159 static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
34160 static swig_type_info _swigt__std__ptrdiff_t = {"_std__ptrdiff_t", "std::ptrdiff_t", 0, 0, 0};
34161 static swig_type_info _swigt__unsigned_int = {"_unsigned_int", "unsigned int|std::size_t", 0, 0, 0};
34162
34163 static swig_type_info *swig_type_initial[] = {
34164 &_swigt__p_char,
34165 &_swigt__p_form_ops_t,
34166 &_swigt__p_int,
34167 &_swigt__p_unsigned_char,
34168 &_swigt__p_unsigned_int,
34169 &_swigt__p_unsigned_long,
34170 &_swigt__p_void,
34171 &_swigt__p_wxANIHandler,
34172 &_swigt__p_wxAcceleratorTable,
34173 &_swigt__p_wxActivateEvent,
34174 &_swigt__p_wxArrayString,
34175 &_swigt__p_wxBMPHandler,
34176 &_swigt__p_wxBitmap,
34177 &_swigt__p_wxBitmapDataObject,
34178 &_swigt__p_wxBoxSizer,
34179 &_swigt__p_wxBusyCursor,
34180 &_swigt__p_wxBusyInfo,
34181 &_swigt__p_wxCURHandler,
34182 &_swigt__p_wxCaret,
34183 &_swigt__p_wxChar,
34184 &_swigt__p_wxChildFocusEvent,
34185 &_swigt__p_wxClipboard,
34186 &_swigt__p_wxClipboardLocker,
34187 &_swigt__p_wxCloseEvent,
34188 &_swigt__p_wxColour,
34189 &_swigt__p_wxCommandEvent,
34190 &_swigt__p_wxConfig,
34191 &_swigt__p_wxConfigBase,
34192 &_swigt__p_wxConfigPathChanger,
34193 &_swigt__p_wxContextMenuEvent,
34194 &_swigt__p_wxControl,
34195 &_swigt__p_wxControlWithItems,
34196 &_swigt__p_wxCursor,
34197 &_swigt__p_wxCustomDataObject,
34198 &_swigt__p_wxDC,
34199 &_swigt__p_wxDataFormat,
34200 &_swigt__p_wxDataObject,
34201 &_swigt__p_wxDataObjectComposite,
34202 &_swigt__p_wxDataObjectSimple,
34203 &_swigt__p_wxDateEvent,
34204 &_swigt__p_wxDateSpan,
34205 &_swigt__p_wxDateTime,
34206 &_swigt__p_wxDateTime__TimeZone,
34207 &_swigt__p_wxDisplay,
34208 &_swigt__p_wxDisplayChangedEvent,
34209 &_swigt__p_wxDropFilesEvent,
34210 &_swigt__p_wxDuplexMode,
34211 &_swigt__p_wxEraseEvent,
34212 &_swigt__p_wxEvent,
34213 &_swigt__p_wxEvtHandler,
34214 &_swigt__p_wxFSFile,
34215 &_swigt__p_wxFileConfig,
34216 &_swigt__p_wxFileDataObject,
34217 &_swigt__p_wxFileHistory,
34218 &_swigt__p_wxFileSystem,
34219 &_swigt__p_wxFileType,
34220 &_swigt__p_wxFileTypeInfo,
34221 &_swigt__p_wxFlexGridSizer,
34222 &_swigt__p_wxFocusEvent,
34223 &_swigt__p_wxFont,
34224 &_swigt__p_wxFrame,
34225 &_swigt__p_wxGBSizerItem,
34226 &_swigt__p_wxGIFHandler,
34227 &_swigt__p_wxGridBagSizer,
34228 &_swigt__p_wxGridSizer,
34229 &_swigt__p_wxICOHandler,
34230 &_swigt__p_wxIcon,
34231 &_swigt__p_wxIconizeEvent,
34232 &_swigt__p_wxIdleEvent,
34233 &_swigt__p_wxImage,
34234 &_swigt__p_wxImageHandler,
34235 &_swigt__p_wxIndividualLayoutConstraint,
34236 &_swigt__p_wxInitDialogEvent,
34237 &_swigt__p_wxJPEGHandler,
34238 &_swigt__p_wxJoystick,
34239 &_swigt__p_wxJoystickEvent,
34240 &_swigt__p_wxKeyEvent,
34241 &_swigt__p_wxKillError,
34242 &_swigt__p_wxLayoutConstraints,
34243 &_swigt__p_wxLog,
34244 &_swigt__p_wxLogBuffer,
34245 &_swigt__p_wxLogChain,
34246 &_swigt__p_wxLogGui,
34247 &_swigt__p_wxLogNull,
34248 &_swigt__p_wxLogStderr,
34249 &_swigt__p_wxLogTextCtrl,
34250 &_swigt__p_wxLogWindow,
34251 &_swigt__p_wxMaximizeEvent,
34252 &_swigt__p_wxMemorySize,
34253 &_swigt__p_wxMenu,
34254 &_swigt__p_wxMenuBar,
34255 &_swigt__p_wxMenuEvent,
34256 &_swigt__p_wxMenuItem,
34257 &_swigt__p_wxMetafileDataObject,
34258 &_swigt__p_wxMimeTypesManager,
34259 &_swigt__p_wxMouseCaptureChangedEvent,
34260 &_swigt__p_wxMouseEvent,
34261 &_swigt__p_wxMouseState,
34262 &_swigt__p_wxMoveEvent,
34263 &_swigt__p_wxMutexGuiLocker,
34264 &_swigt__p_wxNavigationKeyEvent,
34265 &_swigt__p_wxNcPaintEvent,
34266 &_swigt__p_wxNotifyEvent,
34267 &_swigt__p_wxObject,
34268 &_swigt__p_wxOutputStream,
34269 &_swigt__p_wxPCXHandler,
34270 &_swigt__p_wxPNGHandler,
34271 &_swigt__p_wxPNMHandler,
34272 &_swigt__p_wxPaintEvent,
34273 &_swigt__p_wxPaletteChangedEvent,
34274 &_swigt__p_wxPaperSize,
34275 &_swigt__p_wxPoint,
34276 &_swigt__p_wxProcessEvent,
34277 &_swigt__p_wxPyApp,
34278 &_swigt__p_wxPyArtProvider,
34279 &_swigt__p_wxPyBitmapDataObject,
34280 &_swigt__p_wxPyCommandEvent,
34281 &_swigt__p_wxPyDataObjectSimple,
34282 &_swigt__p_wxPyDropSource,
34283 &_swigt__p_wxPyDropTarget,
34284 &_swigt__p_wxPyEvent,
34285 &_swigt__p_wxPyFileDropTarget,
34286 &_swigt__p_wxPyImageHandler,
34287 &_swigt__p_wxPyLog,
34288 &_swigt__p_wxPyProcess,
34289 &_swigt__p_wxPySizer,
34290 &_swigt__p_wxPyTextDataObject,
34291 &_swigt__p_wxPyTextDropTarget,
34292 &_swigt__p_wxPyTimer,
34293 &_swigt__p_wxPyTipProvider,
34294 &_swigt__p_wxPyValidator,
34295 &_swigt__p_wxQueryNewPaletteEvent,
34296 &_swigt__p_wxRect,
34297 &_swigt__p_wxScrollEvent,
34298 &_swigt__p_wxScrollWinEvent,
34299 &_swigt__p_wxSetCursorEvent,
34300 &_swigt__p_wxShowEvent,
34301 &_swigt__p_wxSingleInstanceChecker,
34302 &_swigt__p_wxSize,
34303 &_swigt__p_wxSizeEvent,
34304 &_swigt__p_wxSizer,
34305 &_swigt__p_wxSizerItem,
34306 &_swigt__p_wxSound,
34307 &_swigt__p_wxStandardPaths,
34308 &_swigt__p_wxStaticBoxSizer,
34309 &_swigt__p_wxStdDialogButtonSizer,
34310 &_swigt__p_wxStopWatch,
34311 &_swigt__p_wxString,
34312 &_swigt__p_wxSysColourChangedEvent,
34313 &_swigt__p_wxSystemOptions,
34314 &_swigt__p_wxSystemSettings,
34315 &_swigt__p_wxTIFFHandler,
34316 &_swigt__p_wxTextCtrl,
34317 &_swigt__p_wxTextDataObject,
34318 &_swigt__p_wxTimeSpan,
34319 &_swigt__p_wxTimer,
34320 &_swigt__p_wxTimerEvent,
34321 &_swigt__p_wxTimerRunner,
34322 &_swigt__p_wxTipProvider,
34323 &_swigt__p_wxToolTip,
34324 &_swigt__p_wxURLDataObject,
34325 &_swigt__p_wxUpdateUIEvent,
34326 &_swigt__p_wxValidator,
34327 &_swigt__p_wxVideoMode,
34328 &_swigt__p_wxWindow,
34329 &_swigt__p_wxWindowCreateEvent,
34330 &_swigt__p_wxWindowDestroyEvent,
34331 &_swigt__p_wxWindowDisabler,
34332 &_swigt__p_wxXPMHandler,
34333 &_swigt__ptrdiff_t,
34334 &_swigt__std__ptrdiff_t,
34335 &_swigt__unsigned_int,
34336 };
34337
34338 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
34339 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
34340 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
34341 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
34342 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
34343 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
34344 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
34345 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
34346 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
34347 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}};
34348 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
34349 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
34350 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
34351 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
34352 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
34353 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
34354 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
34355 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
34356 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}};
34357 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
34358 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
34359 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
34360 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
34361 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
34362 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}};
34363 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
34364 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}};
34365 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
34366 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
34367 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
34368 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
34369 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
34370 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
34371 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
34372 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
34373 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
34374 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
34375 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
34376 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
34377 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
34378 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
34379 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
34380 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
34381 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
34382 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
34383 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
34384 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
34385 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
34386 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
34387 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
34388 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
34389 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
34390 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
34391 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
34392 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34393 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34394 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34395 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34396 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
34397 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
34398 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
34399 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
34400 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
34401 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
34402 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
34403 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
34404 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
34405 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
34406 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}};
34407 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
34408 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
34409 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
34410 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
34411 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
34412 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
34413 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}};
34414 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
34415 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
34416 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
34417 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
34418 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
34419 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
34420 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
34421 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
34422 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
34423 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
34424 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
34425 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}};
34426 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
34427 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
34428 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
34429 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
34430 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
34431 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
34432 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
34433 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
34434 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
34435 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
34436 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
34437 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
34438 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
34439 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
34440 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
34441 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
34442 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
34443 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
34444 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
34445 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
34446 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
34447 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
34448 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
34449 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
34450 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
34451 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
34452 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
34453 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
34454 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
34455 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
34456 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
34457 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
34458 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
34459 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
34460 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
34461 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
34462 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
34463 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
34464 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
34465 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
34466 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
34467 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
34468 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
34469 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}};
34470 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
34471 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
34472 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
34473 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
34474 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
34475 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
34476 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
34477 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
34478 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}};
34479 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
34480 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
34481 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
34482 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
34483 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
34484 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
34485 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
34486 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
34487 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
34488 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
34489 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
34490 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
34491 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
34492 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
34493 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
34494 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
34495 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
34496 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}};
34497 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
34498 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
34499 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
34500 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
34501 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}};
34502 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
34503 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
34504 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
34505 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}};
34506 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
34507 static swig_cast_info _swigc__ptrdiff_t[] = { {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
34508 static swig_cast_info _swigc__std__ptrdiff_t[] = { {&_swigt__std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
34509 static swig_cast_info _swigc__unsigned_int[] = { {&_swigt__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
34510
34511 static swig_cast_info *swig_cast_initial[] = {
34512 _swigc__p_char,
34513 _swigc__p_form_ops_t,
34514 _swigc__p_int,
34515 _swigc__p_unsigned_char,
34516 _swigc__p_unsigned_int,
34517 _swigc__p_unsigned_long,
34518 _swigc__p_void,
34519 _swigc__p_wxANIHandler,
34520 _swigc__p_wxAcceleratorTable,
34521 _swigc__p_wxActivateEvent,
34522 _swigc__p_wxArrayString,
34523 _swigc__p_wxBMPHandler,
34524 _swigc__p_wxBitmap,
34525 _swigc__p_wxBitmapDataObject,
34526 _swigc__p_wxBoxSizer,
34527 _swigc__p_wxBusyCursor,
34528 _swigc__p_wxBusyInfo,
34529 _swigc__p_wxCURHandler,
34530 _swigc__p_wxCaret,
34531 _swigc__p_wxChar,
34532 _swigc__p_wxChildFocusEvent,
34533 _swigc__p_wxClipboard,
34534 _swigc__p_wxClipboardLocker,
34535 _swigc__p_wxCloseEvent,
34536 _swigc__p_wxColour,
34537 _swigc__p_wxCommandEvent,
34538 _swigc__p_wxConfig,
34539 _swigc__p_wxConfigBase,
34540 _swigc__p_wxConfigPathChanger,
34541 _swigc__p_wxContextMenuEvent,
34542 _swigc__p_wxControl,
34543 _swigc__p_wxControlWithItems,
34544 _swigc__p_wxCursor,
34545 _swigc__p_wxCustomDataObject,
34546 _swigc__p_wxDC,
34547 _swigc__p_wxDataFormat,
34548 _swigc__p_wxDataObject,
34549 _swigc__p_wxDataObjectComposite,
34550 _swigc__p_wxDataObjectSimple,
34551 _swigc__p_wxDateEvent,
34552 _swigc__p_wxDateSpan,
34553 _swigc__p_wxDateTime,
34554 _swigc__p_wxDateTime__TimeZone,
34555 _swigc__p_wxDisplay,
34556 _swigc__p_wxDisplayChangedEvent,
34557 _swigc__p_wxDropFilesEvent,
34558 _swigc__p_wxDuplexMode,
34559 _swigc__p_wxEraseEvent,
34560 _swigc__p_wxEvent,
34561 _swigc__p_wxEvtHandler,
34562 _swigc__p_wxFSFile,
34563 _swigc__p_wxFileConfig,
34564 _swigc__p_wxFileDataObject,
34565 _swigc__p_wxFileHistory,
34566 _swigc__p_wxFileSystem,
34567 _swigc__p_wxFileType,
34568 _swigc__p_wxFileTypeInfo,
34569 _swigc__p_wxFlexGridSizer,
34570 _swigc__p_wxFocusEvent,
34571 _swigc__p_wxFont,
34572 _swigc__p_wxFrame,
34573 _swigc__p_wxGBSizerItem,
34574 _swigc__p_wxGIFHandler,
34575 _swigc__p_wxGridBagSizer,
34576 _swigc__p_wxGridSizer,
34577 _swigc__p_wxICOHandler,
34578 _swigc__p_wxIcon,
34579 _swigc__p_wxIconizeEvent,
34580 _swigc__p_wxIdleEvent,
34581 _swigc__p_wxImage,
34582 _swigc__p_wxImageHandler,
34583 _swigc__p_wxIndividualLayoutConstraint,
34584 _swigc__p_wxInitDialogEvent,
34585 _swigc__p_wxJPEGHandler,
34586 _swigc__p_wxJoystick,
34587 _swigc__p_wxJoystickEvent,
34588 _swigc__p_wxKeyEvent,
34589 _swigc__p_wxKillError,
34590 _swigc__p_wxLayoutConstraints,
34591 _swigc__p_wxLog,
34592 _swigc__p_wxLogBuffer,
34593 _swigc__p_wxLogChain,
34594 _swigc__p_wxLogGui,
34595 _swigc__p_wxLogNull,
34596 _swigc__p_wxLogStderr,
34597 _swigc__p_wxLogTextCtrl,
34598 _swigc__p_wxLogWindow,
34599 _swigc__p_wxMaximizeEvent,
34600 _swigc__p_wxMemorySize,
34601 _swigc__p_wxMenu,
34602 _swigc__p_wxMenuBar,
34603 _swigc__p_wxMenuEvent,
34604 _swigc__p_wxMenuItem,
34605 _swigc__p_wxMetafileDataObject,
34606 _swigc__p_wxMimeTypesManager,
34607 _swigc__p_wxMouseCaptureChangedEvent,
34608 _swigc__p_wxMouseEvent,
34609 _swigc__p_wxMouseState,
34610 _swigc__p_wxMoveEvent,
34611 _swigc__p_wxMutexGuiLocker,
34612 _swigc__p_wxNavigationKeyEvent,
34613 _swigc__p_wxNcPaintEvent,
34614 _swigc__p_wxNotifyEvent,
34615 _swigc__p_wxObject,
34616 _swigc__p_wxOutputStream,
34617 _swigc__p_wxPCXHandler,
34618 _swigc__p_wxPNGHandler,
34619 _swigc__p_wxPNMHandler,
34620 _swigc__p_wxPaintEvent,
34621 _swigc__p_wxPaletteChangedEvent,
34622 _swigc__p_wxPaperSize,
34623 _swigc__p_wxPoint,
34624 _swigc__p_wxProcessEvent,
34625 _swigc__p_wxPyApp,
34626 _swigc__p_wxPyArtProvider,
34627 _swigc__p_wxPyBitmapDataObject,
34628 _swigc__p_wxPyCommandEvent,
34629 _swigc__p_wxPyDataObjectSimple,
34630 _swigc__p_wxPyDropSource,
34631 _swigc__p_wxPyDropTarget,
34632 _swigc__p_wxPyEvent,
34633 _swigc__p_wxPyFileDropTarget,
34634 _swigc__p_wxPyImageHandler,
34635 _swigc__p_wxPyLog,
34636 _swigc__p_wxPyProcess,
34637 _swigc__p_wxPySizer,
34638 _swigc__p_wxPyTextDataObject,
34639 _swigc__p_wxPyTextDropTarget,
34640 _swigc__p_wxPyTimer,
34641 _swigc__p_wxPyTipProvider,
34642 _swigc__p_wxPyValidator,
34643 _swigc__p_wxQueryNewPaletteEvent,
34644 _swigc__p_wxRect,
34645 _swigc__p_wxScrollEvent,
34646 _swigc__p_wxScrollWinEvent,
34647 _swigc__p_wxSetCursorEvent,
34648 _swigc__p_wxShowEvent,
34649 _swigc__p_wxSingleInstanceChecker,
34650 _swigc__p_wxSize,
34651 _swigc__p_wxSizeEvent,
34652 _swigc__p_wxSizer,
34653 _swigc__p_wxSizerItem,
34654 _swigc__p_wxSound,
34655 _swigc__p_wxStandardPaths,
34656 _swigc__p_wxStaticBoxSizer,
34657 _swigc__p_wxStdDialogButtonSizer,
34658 _swigc__p_wxStopWatch,
34659 _swigc__p_wxString,
34660 _swigc__p_wxSysColourChangedEvent,
34661 _swigc__p_wxSystemOptions,
34662 _swigc__p_wxSystemSettings,
34663 _swigc__p_wxTIFFHandler,
34664 _swigc__p_wxTextCtrl,
34665 _swigc__p_wxTextDataObject,
34666 _swigc__p_wxTimeSpan,
34667 _swigc__p_wxTimer,
34668 _swigc__p_wxTimerEvent,
34669 _swigc__p_wxTimerRunner,
34670 _swigc__p_wxTipProvider,
34671 _swigc__p_wxToolTip,
34672 _swigc__p_wxURLDataObject,
34673 _swigc__p_wxUpdateUIEvent,
34674 _swigc__p_wxValidator,
34675 _swigc__p_wxVideoMode,
34676 _swigc__p_wxWindow,
34677 _swigc__p_wxWindowCreateEvent,
34678 _swigc__p_wxWindowDestroyEvent,
34679 _swigc__p_wxWindowDisabler,
34680 _swigc__p_wxXPMHandler,
34681 _swigc__ptrdiff_t,
34682 _swigc__std__ptrdiff_t,
34683 _swigc__unsigned_int,
34684 };
34685
34686
34687 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
34688
34689 static swig_const_info swig_const_table[] = {
34690 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
34691 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
34692 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
34693 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
34694 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
34695 {0, 0, 0, 0.0, 0, 0}};
34696
34697 #ifdef __cplusplus
34698 }
34699 #endif
34700 /*************************************************************************
34701 * Type initialization:
34702 * This problem is tough by the requirement that no dynamic
34703 * memory is used. Also, since swig_type_info structures store pointers to
34704 * swig_cast_info structures and swig_cast_info structures store pointers back
34705 * to swig_type_info structures, we need some lookup code at initialization.
34706 * The idea is that swig generates all the structures that are needed.
34707 * The runtime then collects these partially filled structures.
34708 * The SWIG_InitializeModule function takes these initial arrays out of
34709 * swig_module, and does all the lookup, filling in the swig_module.types
34710 * array with the correct data and linking the correct swig_cast_info
34711 * structures together.
34712
34713 * The generated swig_type_info structures are assigned staticly to an initial
34714 * array. We just loop though that array, and handle each type individually.
34715 * First we lookup if this type has been already loaded, and if so, use the
34716 * loaded structure instead of the generated one. Then we have to fill in the
34717 * cast linked list. The cast data is initially stored in something like a
34718 * two-dimensional array. Each row corresponds to a type (there are the same
34719 * number of rows as there are in the swig_type_initial array). Each entry in
34720 * a column is one of the swig_cast_info structures for that type.
34721 * The cast_initial array is actually an array of arrays, because each row has
34722 * a variable number of columns. So to actually build the cast linked list,
34723 * we find the array of casts associated with the type, and loop through it
34724 * adding the casts to the list. The one last trick we need to do is making
34725 * sure the type pointer in the swig_cast_info struct is correct.
34726
34727 * First off, we lookup the cast->type name to see if it is already loaded.
34728 * There are three cases to handle:
34729 * 1) If the cast->type has already been loaded AND the type we are adding
34730 * casting info to has not been loaded (it is in this module), THEN we
34731 * replace the cast->type pointer with the type pointer that has already
34732 * been loaded.
34733 * 2) If BOTH types (the one we are adding casting info to, and the
34734 * cast->type) are loaded, THEN the cast info has already been loaded by
34735 * the previous module so we just ignore it.
34736 * 3) Finally, if cast->type has not already been loaded, then we add that
34737 * swig_cast_info to the linked list (because the cast->type) pointer will
34738 * be correct.
34739 **/
34740
34741 #ifdef __cplusplus
34742 extern "C" {
34743 #if 0
34744 } /* c-mode */
34745 #endif
34746 #endif
34747
34748 #if 0
34749 #define SWIGRUNTIME_DEBUG
34750 #endif
34751
34752 SWIGRUNTIME void
34753 SWIG_InitializeModule(void *clientdata) {
34754 size_t i;
34755 swig_module_info *module_head;
34756 static int init_run = 0;
34757
34758 clientdata = clientdata;
34759
34760 if (init_run) return;
34761 init_run = 1;
34762
34763 /* Initialize the swig_module */
34764 swig_module.type_initial = swig_type_initial;
34765 swig_module.cast_initial = swig_cast_initial;
34766
34767 /* Try and load any already created modules */
34768 module_head = SWIG_GetModule(clientdata);
34769 if (module_head) {
34770 swig_module.next = module_head->next;
34771 module_head->next = &swig_module;
34772 } else {
34773 /* This is the first module loaded */
34774 swig_module.next = &swig_module;
34775 SWIG_SetModule(clientdata, &swig_module);
34776 }
34777
34778 /* Now work on filling in swig_module.types */
34779 #ifdef SWIGRUNTIME_DEBUG
34780 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
34781 #endif
34782 for (i = 0; i < swig_module.size; ++i) {
34783 swig_type_info *type = 0;
34784 swig_type_info *ret;
34785 swig_cast_info *cast;
34786
34787 #ifdef SWIGRUNTIME_DEBUG
34788 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
34789 #endif
34790
34791 /* if there is another module already loaded */
34792 if (swig_module.next != &swig_module) {
34793 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
34794 }
34795 if (type) {
34796 /* Overwrite clientdata field */
34797 #ifdef SWIGRUNTIME_DEBUG
34798 printf("SWIG_InitializeModule: found type %s\n", type->name);
34799 #endif
34800 if (swig_module.type_initial[i]->clientdata) {
34801 type->clientdata = swig_module.type_initial[i]->clientdata;
34802 #ifdef SWIGRUNTIME_DEBUG
34803 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
34804 #endif
34805 }
34806 } else {
34807 type = swig_module.type_initial[i];
34808 }
34809
34810 /* Insert casting types */
34811 cast = swig_module.cast_initial[i];
34812 while (cast->type) {
34813 /* Don't need to add information already in the list */
34814 ret = 0;
34815 #ifdef SWIGRUNTIME_DEBUG
34816 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
34817 #endif
34818 if (swig_module.next != &swig_module) {
34819 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
34820 #ifdef SWIGRUNTIME_DEBUG
34821 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
34822 #endif
34823 }
34824 if (ret) {
34825 if (type == swig_module.type_initial[i]) {
34826 #ifdef SWIGRUNTIME_DEBUG
34827 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
34828 #endif
34829 cast->type = ret;
34830 ret = 0;
34831 } else {
34832 /* Check for casting already in the list */
34833 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
34834 #ifdef SWIGRUNTIME_DEBUG
34835 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
34836 #endif
34837 if (!ocast) ret = 0;
34838 }
34839 }
34840
34841 if (!ret) {
34842 #ifdef SWIGRUNTIME_DEBUG
34843 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
34844 #endif
34845 if (type->cast) {
34846 type->cast->prev = cast;
34847 cast->next = type->cast;
34848 }
34849 type->cast = cast;
34850 }
34851 cast++;
34852 }
34853 /* Set entry in modules->types array equal to the type */
34854 swig_module.types[i] = type;
34855 }
34856 swig_module.types[i] = 0;
34857
34858 #ifdef SWIGRUNTIME_DEBUG
34859 printf("**** SWIG_InitializeModule: Cast List ******\n");
34860 for (i = 0; i < swig_module.size; ++i) {
34861 int j = 0;
34862 swig_cast_info *cast = swig_module.cast_initial[i];
34863 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
34864 while (cast->type) {
34865 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
34866 cast++;
34867 ++j;
34868 }
34869 printf("---- Total casts: %d\n",j);
34870 }
34871 printf("**** SWIG_InitializeModule: Cast List ******\n");
34872 #endif
34873 }
34874
34875 /* This function will propagate the clientdata field of type to
34876 * any new swig_type_info structures that have been added into the list
34877 * of equivalent types. It is like calling
34878 * SWIG_TypeClientData(type, clientdata) a second time.
34879 */
34880 SWIGRUNTIME void
34881 SWIG_PropagateClientData(void) {
34882 size_t i;
34883 swig_cast_info *equiv;
34884 static int init_run = 0;
34885
34886 if (init_run) return;
34887 init_run = 1;
34888
34889 for (i = 0; i < swig_module.size; i++) {
34890 if (swig_module.types[i]->clientdata) {
34891 equiv = swig_module.types[i]->cast;
34892 while (equiv) {
34893 if (!equiv->converter) {
34894 if (equiv->type && !equiv->type->clientdata)
34895 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
34896 }
34897 equiv = equiv->next;
34898 }
34899 }
34900 }
34901 }
34902
34903 #ifdef __cplusplus
34904 #if 0
34905 {
34906 /* c-mode */
34907 #endif
34908 }
34909 #endif
34910
34911
34912
34913 #ifdef __cplusplus
34914 extern "C" {
34915 #endif
34916
34917 /* Python-specific SWIG API */
34918 #define SWIG_newvarlink() SWIG_Python_newvarlink()
34919 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
34920 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
34921
34922 /* -----------------------------------------------------------------------------
34923 * global variable support code.
34924 * ----------------------------------------------------------------------------- */
34925
34926 typedef struct swig_globalvar {
34927 char *name; /* Name of global variable */
34928 PyObject *(*get_attr)(void); /* Return the current value */
34929 int (*set_attr)(PyObject *); /* Set the value */
34930 struct swig_globalvar *next;
34931 } swig_globalvar;
34932
34933 typedef struct swig_varlinkobject {
34934 PyObject_HEAD
34935 swig_globalvar *vars;
34936 } swig_varlinkobject;
34937
34938 SWIGINTERN PyObject *
34939 swig_varlink_repr(swig_varlinkobject *v) {
34940 v = v;
34941 return PyString_FromString("<Swig global variables>");
34942 }
34943
34944 SWIGINTERN int
34945 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
34946 swig_globalvar *var;
34947 flags = flags;
34948 fprintf(fp,"Swig global variables { ");
34949 for (var = v->vars; var; var=var->next) {
34950 fprintf(fp,"%s", var->name);
34951 if (var->next) fprintf(fp,", ");
34952 }
34953 fprintf(fp," }\n");
34954 return 0;
34955 }
34956
34957 SWIGINTERN PyObject *
34958 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
34959 swig_globalvar *var = v->vars;
34960 while (var) {
34961 if (strcmp(var->name,n) == 0) {
34962 return (*var->get_attr)();
34963 }
34964 var = var->next;
34965 }
34966 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
34967 return NULL;
34968 }
34969
34970 SWIGINTERN int
34971 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
34972 swig_globalvar *var = v->vars;
34973 while (var) {
34974 if (strcmp(var->name,n) == 0) {
34975 return (*var->set_attr)(p);
34976 }
34977 var = var->next;
34978 }
34979 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
34980 return 1;
34981 }
34982
34983 SWIGINTERN PyTypeObject*
34984 swig_varlink_type(void) {
34985 static char varlink__doc__[] = "Swig var link object";
34986 static PyTypeObject varlink_type
34987 #if !defined(__cplusplus)
34988 ;
34989 static int type_init = 0;
34990 if (!type_init) {
34991 PyTypeObject tmp
34992 #endif
34993 = {
34994 PyObject_HEAD_INIT(&PyType_Type)
34995 0, /* Number of items in variable part (ob_size) */
34996 (char *)"swigvarlink", /* Type name (tp_name) */
34997 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
34998 0, /* Itemsize (tp_itemsize) */
34999 0, /* Deallocator (tp_dealloc) */
35000 (printfunc) swig_varlink_print, /* Print (tp_print) */
35001 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
35002 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
35003 0, /* tp_compare */
35004 (reprfunc) swig_varlink_repr, /* tp_repr */
35005 0, /* tp_as_number */
35006 0, /* tp_as_sequence */
35007 0, /* tp_as_mapping */
35008 0, /* tp_hash */
35009 0, /* tp_call */
35010 0, /* tp_str */
35011 0, /* tp_getattro */
35012 0, /* tp_setattro */
35013 0, /* tp_as_buffer */
35014 0, /* tp_flags */
35015 varlink__doc__, /* tp_doc */
35016 #if PY_VERSION_HEX >= 0x02000000
35017 0, /* tp_traverse */
35018 0, /* tp_clear */
35019 #endif
35020 #if PY_VERSION_HEX >= 0x02010000
35021 0, /* tp_richcompare */
35022 0, /* tp_weaklistoffset */
35023 #endif
35024 #if PY_VERSION_HEX >= 0x02020000
35025 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
35026 #endif
35027 #if PY_VERSION_HEX >= 0x02030000
35028 0, /* tp_del */
35029 #endif
35030 #ifdef COUNT_ALLOCS
35031 0,0,0,0 /* tp_alloc -> tp_next */
35032 #endif
35033 };
35034 #if !defined(__cplusplus)
35035 varlink_type = tmp;
35036 type_init = 1;
35037 }
35038 #endif
35039 return &varlink_type;
35040 }
35041
35042 /* Create a variable linking object for use later */
35043 SWIGINTERN PyObject *
35044 SWIG_Python_newvarlink(void) {
35045 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
35046 if (result) {
35047 result->vars = 0;
35048 }
35049 return ((PyObject*) result);
35050 }
35051
35052 SWIGINTERN void
35053 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
35054 swig_varlinkobject *v = (swig_varlinkobject *) p;
35055 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
35056 if (gv) {
35057 size_t size = strlen(name)+1;
35058 gv->name = (char *)malloc(size);
35059 if (gv->name) {
35060 strncpy(gv->name,name,size);
35061 gv->get_attr = get_attr;
35062 gv->set_attr = set_attr;
35063 gv->next = v->vars;
35064 }
35065 }
35066 v->vars = gv;
35067 }
35068
35069 /* -----------------------------------------------------------------------------
35070 * constants/methods manipulation
35071 * ----------------------------------------------------------------------------- */
35072
35073 /* Install Constants */
35074 SWIGINTERN void
35075 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
35076 PyObject *obj = 0;
35077 size_t i;
35078 for (i = 0; constants[i].type; ++i) {
35079 switch(constants[i].type) {
35080 case SWIG_PY_INT:
35081 obj = PyInt_FromLong(constants[i].lvalue);
35082 break;
35083 case SWIG_PY_FLOAT:
35084 obj = PyFloat_FromDouble(constants[i].dvalue);
35085 break;
35086 case SWIG_PY_STRING:
35087 if (constants[i].pvalue) {
35088 obj = PyString_FromString((char *) constants[i].pvalue);
35089 } else {
35090 Py_INCREF(Py_None);
35091 obj = Py_None;
35092 }
35093 break;
35094 case SWIG_PY_POINTER:
35095 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
35096 break;
35097 case SWIG_PY_BINARY:
35098 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
35099 break;
35100 default:
35101 obj = 0;
35102 break;
35103 }
35104 if (obj) {
35105 PyDict_SetItemString(d,constants[i].name,obj);
35106 Py_DECREF(obj);
35107 }
35108 }
35109 }
35110
35111 /* -----------------------------------------------------------------------------*/
35112 /* Fix SwigMethods to carry the callback ptrs when needed */
35113 /* -----------------------------------------------------------------------------*/
35114
35115 SWIGINTERN void
35116 SWIG_Python_FixMethods(PyMethodDef *methods,
35117 swig_const_info *const_table,
35118 swig_type_info **types,
35119 swig_type_info **types_initial) {
35120 size_t i;
35121 for (i = 0; methods[i].ml_name; ++i) {
35122 char *c = methods[i].ml_doc;
35123 if (c && (c = strstr(c, "swig_ptr: "))) {
35124 int j;
35125 swig_const_info *ci = 0;
35126 char *name = c + 10;
35127 for (j = 0; const_table[j].type; ++j) {
35128 if (strncmp(const_table[j].name, name,
35129 strlen(const_table[j].name)) == 0) {
35130 ci = &(const_table[j]);
35131 break;
35132 }
35133 }
35134 if (ci) {
35135 size_t shift = (ci->ptype) - types;
35136 swig_type_info *ty = types_initial[shift];
35137 size_t ldoc = (c - methods[i].ml_doc);
35138 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
35139 char *ndoc = (char*)malloc(ldoc + lptr + 10);
35140 if (ndoc) {
35141 char *buff = ndoc;
35142 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
35143 if (ptr) {
35144 strncpy(buff, methods[i].ml_doc, ldoc);
35145 buff += ldoc;
35146 strncpy(buff, "swig_ptr: ", 10);
35147 buff += 10;
35148 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
35149 methods[i].ml_doc = ndoc;
35150 }
35151 }
35152 }
35153 }
35154 }
35155 }
35156
35157 /* -----------------------------------------------------------------------------*
35158 * Initialize type list
35159 * -----------------------------------------------------------------------------*/
35160
35161 #ifdef __cplusplus
35162 }
35163 #endif
35164
35165 /* -----------------------------------------------------------------------------*
35166 * Partial Init method
35167 * -----------------------------------------------------------------------------*/
35168
35169 #ifdef __cplusplus
35170 extern "C"
35171 #endif
35172 SWIGEXPORT void SWIG_init(void) {
35173 static PyObject *SWIG_globals = 0;
35174 PyObject *m, *d;
35175 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
35176
35177 /* Fix SwigMethods to carry the callback ptrs when needed */
35178 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
35179
35180 m = Py_InitModule((char *) SWIG_name, SwigMethods);
35181 d = PyModule_GetDict(m);
35182
35183 SWIG_InitializeModule(0);
35184 SWIG_InstallConstants(d,swig_const_table);
35185
35186 {
35187 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int(static_cast<int >(wxSYS_OEM_FIXED_FONT)));
35188 }
35189 {
35190 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int(static_cast<int >(wxSYS_ANSI_FIXED_FONT)));
35191 }
35192 {
35193 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int(static_cast<int >(wxSYS_ANSI_VAR_FONT)));
35194 }
35195 {
35196 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int(static_cast<int >(wxSYS_SYSTEM_FONT)));
35197 }
35198 {
35199 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int(static_cast<int >(wxSYS_DEVICE_DEFAULT_FONT)));
35200 }
35201 {
35202 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int(static_cast<int >(wxSYS_DEFAULT_PALETTE)));
35203 }
35204 {
35205 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int(static_cast<int >(wxSYS_SYSTEM_FIXED_FONT)));
35206 }
35207 {
35208 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int(static_cast<int >(wxSYS_DEFAULT_GUI_FONT)));
35209 }
35210 {
35211 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int(static_cast<int >(wxSYS_ICONTITLE_FONT)));
35212 }
35213 {
35214 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_SCROLLBAR)));
35215 }
35216 {
35217 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BACKGROUND)));
35218 }
35219 {
35220 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_DESKTOP)));
35221 }
35222 {
35223 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_ACTIVECAPTION)));
35224 }
35225 {
35226 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INACTIVECAPTION)));
35227 }
35228 {
35229 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MENU)));
35230 }
35231 {
35232 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_WINDOW)));
35233 }
35234 {
35235 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_WINDOWFRAME)));
35236 }
35237 {
35238 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MENUTEXT)));
35239 }
35240 {
35241 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_WINDOWTEXT)));
35242 }
35243 {
35244 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_CAPTIONTEXT)));
35245 }
35246 {
35247 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_ACTIVEBORDER)));
35248 }
35249 {
35250 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INACTIVEBORDER)));
35251 }
35252 {
35253 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_APPWORKSPACE)));
35254 }
35255 {
35256 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_HIGHLIGHT)));
35257 }
35258 {
35259 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
35260 }
35261 {
35262 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNFACE)));
35263 }
35264 {
35265 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DFACE)));
35266 }
35267 {
35268 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNSHADOW)));
35269 }
35270 {
35271 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DSHADOW)));
35272 }
35273 {
35274 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_GRAYTEXT)));
35275 }
35276 {
35277 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNTEXT)));
35278 }
35279 {
35280 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
35281 }
35282 {
35283 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
35284 }
35285 {
35286 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNHILIGHT)));
35287 }
35288 {
35289 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DHIGHLIGHT)));
35290 }
35291 {
35292 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DHILIGHT)));
35293 }
35294 {
35295 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DDKSHADOW)));
35296 }
35297 {
35298 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DLIGHT)));
35299 }
35300 {
35301 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INFOTEXT)));
35302 }
35303 {
35304 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INFOBK)));
35305 }
35306 {
35307 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_LISTBOX)));
35308 }
35309 {
35310 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_HOTLIGHT)));
35311 }
35312 {
35313 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
35314 }
35315 {
35316 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
35317 }
35318 {
35319 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MENUHILIGHT)));
35320 }
35321 {
35322 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MENUBAR)));
35323 }
35324 {
35325 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MAX)));
35326 }
35327 {
35328 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int(static_cast<int >(wxSYS_MOUSE_BUTTONS)));
35329 }
35330 {
35331 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int(static_cast<int >(wxSYS_BORDER_X)));
35332 }
35333 {
35334 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int(static_cast<int >(wxSYS_BORDER_Y)));
35335 }
35336 {
35337 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int(static_cast<int >(wxSYS_CURSOR_X)));
35338 }
35339 {
35340 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int(static_cast<int >(wxSYS_CURSOR_Y)));
35341 }
35342 {
35343 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int(static_cast<int >(wxSYS_DCLICK_X)));
35344 }
35345 {
35346 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int(static_cast<int >(wxSYS_DCLICK_Y)));
35347 }
35348 {
35349 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int(static_cast<int >(wxSYS_DRAG_X)));
35350 }
35351 {
35352 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int(static_cast<int >(wxSYS_DRAG_Y)));
35353 }
35354 {
35355 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int(static_cast<int >(wxSYS_EDGE_X)));
35356 }
35357 {
35358 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int(static_cast<int >(wxSYS_EDGE_Y)));
35359 }
35360 {
35361 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int(static_cast<int >(wxSYS_HSCROLL_ARROW_X)));
35362 }
35363 {
35364 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int(static_cast<int >(wxSYS_HSCROLL_ARROW_Y)));
35365 }
35366 {
35367 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int(static_cast<int >(wxSYS_HTHUMB_X)));
35368 }
35369 {
35370 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int(static_cast<int >(wxSYS_ICON_X)));
35371 }
35372 {
35373 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int(static_cast<int >(wxSYS_ICON_Y)));
35374 }
35375 {
35376 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int(static_cast<int >(wxSYS_ICONSPACING_X)));
35377 }
35378 {
35379 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int(static_cast<int >(wxSYS_ICONSPACING_Y)));
35380 }
35381 {
35382 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int(static_cast<int >(wxSYS_WINDOWMIN_X)));
35383 }
35384 {
35385 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int(static_cast<int >(wxSYS_WINDOWMIN_Y)));
35386 }
35387 {
35388 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_X)));
35389 }
35390 {
35391 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_Y)));
35392 }
35393 {
35394 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int(static_cast<int >(wxSYS_FRAMESIZE_X)));
35395 }
35396 {
35397 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int(static_cast<int >(wxSYS_FRAMESIZE_Y)));
35398 }
35399 {
35400 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int(static_cast<int >(wxSYS_SMALLICON_X)));
35401 }
35402 {
35403 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int(static_cast<int >(wxSYS_SMALLICON_Y)));
35404 }
35405 {
35406 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int(static_cast<int >(wxSYS_HSCROLL_Y)));
35407 }
35408 {
35409 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int(static_cast<int >(wxSYS_VSCROLL_X)));
35410 }
35411 {
35412 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int(static_cast<int >(wxSYS_VSCROLL_ARROW_X)));
35413 }
35414 {
35415 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int(static_cast<int >(wxSYS_VSCROLL_ARROW_Y)));
35416 }
35417 {
35418 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int(static_cast<int >(wxSYS_VTHUMB_Y)));
35419 }
35420 {
35421 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int(static_cast<int >(wxSYS_CAPTION_Y)));
35422 }
35423 {
35424 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int(static_cast<int >(wxSYS_MENU_Y)));
35425 }
35426 {
35427 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int(static_cast<int >(wxSYS_NETWORK_PRESENT)));
35428 }
35429 {
35430 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int(static_cast<int >(wxSYS_PENWINDOWS_PRESENT)));
35431 }
35432 {
35433 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int(static_cast<int >(wxSYS_SHOW_SOUNDS)));
35434 }
35435 {
35436 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int(static_cast<int >(wxSYS_SWAP_BUTTONS)));
35437 }
35438 {
35439 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int(static_cast<int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
35440 }
35441 {
35442 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int(static_cast<int >(wxSYS_CAN_ICONIZE_FRAME)));
35443 }
35444 {
35445 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_NONE)));
35446 }
35447 {
35448 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_TINY)));
35449 }
35450 {
35451 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_PDA)));
35452 }
35453 {
35454 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_SMALL)));
35455 }
35456 {
35457 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_DESKTOP)));
35458 }
35459 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
35460 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
35461 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
35462 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
35463 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
35464 {
35465 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int(static_cast<int >(wxSHUTDOWN_POWEROFF)));
35466 }
35467 {
35468 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int(static_cast<int >(wxSHUTDOWN_REBOOT)));
35469 }
35470 {
35471 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int(static_cast<int >(wxTIMER_CONTINUOUS)));
35472 }
35473 {
35474 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int(static_cast<int >(wxTIMER_ONE_SHOT)));
35475 }
35476 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
35477
35478 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
35479
35480 {
35481 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int(static_cast<int >(wxLOG_FatalError)));
35482 }
35483 {
35484 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int(static_cast<int >(wxLOG_Error)));
35485 }
35486 {
35487 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int(static_cast<int >(wxLOG_Warning)));
35488 }
35489 {
35490 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int(static_cast<int >(wxLOG_Message)));
35491 }
35492 {
35493 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int(static_cast<int >(wxLOG_Status)));
35494 }
35495 {
35496 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int(static_cast<int >(wxLOG_Info)));
35497 }
35498 {
35499 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int(static_cast<int >(wxLOG_Debug)));
35500 }
35501 {
35502 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int(static_cast<int >(wxLOG_Trace)));
35503 }
35504 {
35505 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int(static_cast<int >(wxLOG_Progress)));
35506 }
35507 {
35508 PyDict_SetItemString(d,"LOG_User", SWIG_From_int(static_cast<int >(wxLOG_User)));
35509 }
35510 {
35511 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int(static_cast<int >(wxLOG_Max)));
35512 }
35513 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
35514 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
35515 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
35516 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
35517 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
35518 {
35519 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int(static_cast<int >(0x0001)));
35520 }
35521 {
35522 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int(static_cast<int >(0x0002)));
35523 }
35524 {
35525 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int(static_cast<int >(0x0004)));
35526 }
35527 {
35528 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int(static_cast<int >(0x0008)));
35529 }
35530 {
35531 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int(static_cast<int >(0x0100)));
35532 }
35533 {
35534 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int(static_cast<int >(wxPROCESS_DEFAULT)));
35535 }
35536 {
35537 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int(static_cast<int >(wxPROCESS_REDIRECT)));
35538 }
35539 {
35540 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int(static_cast<int >(wxKILL_OK)));
35541 }
35542 {
35543 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int(static_cast<int >(wxKILL_BAD_SIGNAL)));
35544 }
35545 {
35546 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int(static_cast<int >(wxKILL_ACCESS_DENIED)));
35547 }
35548 {
35549 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int(static_cast<int >(wxKILL_NO_PROCESS)));
35550 }
35551 {
35552 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int(static_cast<int >(wxKILL_ERROR)));
35553 }
35554 {
35555 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int(static_cast<int >(wxKILL_NOCHILDREN)));
35556 }
35557 {
35558 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int(static_cast<int >(wxKILL_CHILDREN)));
35559 }
35560 {
35561 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int(static_cast<int >(wxSIGNONE)));
35562 }
35563 {
35564 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int(static_cast<int >(wxSIGHUP)));
35565 }
35566 {
35567 PyDict_SetItemString(d,"SIGINT", SWIG_From_int(static_cast<int >(wxSIGINT)));
35568 }
35569 {
35570 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int(static_cast<int >(wxSIGQUIT)));
35571 }
35572 {
35573 PyDict_SetItemString(d,"SIGILL", SWIG_From_int(static_cast<int >(wxSIGILL)));
35574 }
35575 {
35576 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int(static_cast<int >(wxSIGTRAP)));
35577 }
35578 {
35579 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int(static_cast<int >(wxSIGABRT)));
35580 }
35581 {
35582 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int(static_cast<int >(wxSIGIOT)));
35583 }
35584 {
35585 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int(static_cast<int >(wxSIGEMT)));
35586 }
35587 {
35588 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int(static_cast<int >(wxSIGFPE)));
35589 }
35590 {
35591 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int(static_cast<int >(wxSIGKILL)));
35592 }
35593 {
35594 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int(static_cast<int >(wxSIGBUS)));
35595 }
35596 {
35597 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int(static_cast<int >(wxSIGSEGV)));
35598 }
35599 {
35600 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int(static_cast<int >(wxSIGSYS)));
35601 }
35602 {
35603 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int(static_cast<int >(wxSIGPIPE)));
35604 }
35605 {
35606 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int(static_cast<int >(wxSIGALRM)));
35607 }
35608 {
35609 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int(static_cast<int >(wxSIGTERM)));
35610 }
35611 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
35612 {
35613 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int(static_cast<int >(wxEXEC_ASYNC)));
35614 }
35615 {
35616 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int(static_cast<int >(wxEXEC_SYNC)));
35617 }
35618 {
35619 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int(static_cast<int >(wxEXEC_NOHIDE)));
35620 }
35621 {
35622 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int(static_cast<int >(wxEXEC_MAKE_GROUP_LEADER)));
35623 }
35624 {
35625 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int(static_cast<int >(wxEXEC_NODISABLE)));
35626 }
35627
35628 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
35629
35630 {
35631 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int(static_cast<int >(wxJOYSTICK1)));
35632 }
35633 {
35634 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int(static_cast<int >(wxJOYSTICK2)));
35635 }
35636 {
35637 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int(static_cast<int >(wxJOY_BUTTON_ANY)));
35638 }
35639 {
35640 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int(static_cast<int >(wxJOY_BUTTON1)));
35641 }
35642 {
35643 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int(static_cast<int >(wxJOY_BUTTON2)));
35644 }
35645 {
35646 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int(static_cast<int >(wxJOY_BUTTON3)));
35647 }
35648 {
35649 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int(static_cast<int >(wxJOY_BUTTON4)));
35650 }
35651 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
35652 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
35653 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
35654 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
35655 {
35656 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int(static_cast<int >(wxSOUND_SYNC)));
35657 }
35658 {
35659 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int(static_cast<int >(wxSOUND_ASYNC)));
35660 }
35661 {
35662 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int(static_cast<int >(wxSOUND_LOOP)));
35663 }
35664 {
35665 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int(static_cast<int >(wxMAILCAP_STANDARD)));
35666 }
35667 {
35668 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int(static_cast<int >(wxMAILCAP_NETSCAPE)));
35669 }
35670 {
35671 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int(static_cast<int >(wxMAILCAP_KDE)));
35672 }
35673 {
35674 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int(static_cast<int >(wxMAILCAP_GNOME)));
35675 }
35676 {
35677 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int(static_cast<int >(wxMAILCAP_ALL)));
35678 }
35679 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
35680 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
35681 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
35682 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
35683 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
35684 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
35685 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
35686 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
35687 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
35688 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
35689 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
35690 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
35691 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
35692 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
35693 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
35694 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
35695 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
35696 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
35697 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
35698 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
35699 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
35700 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
35701 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
35702 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
35703 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
35704 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
35705 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
35706 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
35707 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
35708 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
35709 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
35710 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
35711 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
35712 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
35713 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
35714 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
35715 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
35716 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
35717 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
35718 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
35719 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
35720 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
35721 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
35722 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
35723 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
35724 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
35725 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
35726 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
35727 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
35728 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
35729 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
35730 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW",_wrap_ART_NEW_get, _wrap_ART_NEW_set);
35731 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
35732 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
35733 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
35734 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
35735 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
35736
35737 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
35738
35739 {
35740 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int(static_cast<int >(wxCONFIG_USE_LOCAL_FILE)));
35741 }
35742 {
35743 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int(static_cast<int >(wxCONFIG_USE_GLOBAL_FILE)));
35744 }
35745 {
35746 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int(static_cast<int >(wxCONFIG_USE_RELATIVE_PATH)));
35747 }
35748 {
35749 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int(static_cast<int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
35750 }
35751 {
35752 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int(static_cast<int >(wxConfigBase::Type_Unknown)));
35753 }
35754 {
35755 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int(static_cast<int >(wxConfigBase::Type_String)));
35756 }
35757 {
35758 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int(static_cast<int >(wxConfigBase::Type_Boolean)));
35759 }
35760 {
35761 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int(static_cast<int >(wxConfigBase::Type_Integer)));
35762 }
35763 {
35764 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int(static_cast<int >(wxConfigBase::Type_Float)));
35765 }
35766 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
35767 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
35768 {
35769 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int(static_cast<int >(wxDateTime::Local)));
35770 }
35771 {
35772 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int(static_cast<int >(wxDateTime::GMT_12)));
35773 }
35774 {
35775 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int(static_cast<int >(wxDateTime::GMT_11)));
35776 }
35777 {
35778 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int(static_cast<int >(wxDateTime::GMT_10)));
35779 }
35780 {
35781 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int(static_cast<int >(wxDateTime::GMT_9)));
35782 }
35783 {
35784 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int(static_cast<int >(wxDateTime::GMT_8)));
35785 }
35786 {
35787 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int(static_cast<int >(wxDateTime::GMT_7)));
35788 }
35789 {
35790 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int(static_cast<int >(wxDateTime::GMT_6)));
35791 }
35792 {
35793 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int(static_cast<int >(wxDateTime::GMT_5)));
35794 }
35795 {
35796 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int(static_cast<int >(wxDateTime::GMT_4)));
35797 }
35798 {
35799 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int(static_cast<int >(wxDateTime::GMT_3)));
35800 }
35801 {
35802 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int(static_cast<int >(wxDateTime::GMT_2)));
35803 }
35804 {
35805 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int(static_cast<int >(wxDateTime::GMT_1)));
35806 }
35807 {
35808 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int(static_cast<int >(wxDateTime::GMT0)));
35809 }
35810 {
35811 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int(static_cast<int >(wxDateTime::GMT1)));
35812 }
35813 {
35814 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int(static_cast<int >(wxDateTime::GMT2)));
35815 }
35816 {
35817 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int(static_cast<int >(wxDateTime::GMT3)));
35818 }
35819 {
35820 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int(static_cast<int >(wxDateTime::GMT4)));
35821 }
35822 {
35823 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int(static_cast<int >(wxDateTime::GMT5)));
35824 }
35825 {
35826 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int(static_cast<int >(wxDateTime::GMT6)));
35827 }
35828 {
35829 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int(static_cast<int >(wxDateTime::GMT7)));
35830 }
35831 {
35832 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int(static_cast<int >(wxDateTime::GMT8)));
35833 }
35834 {
35835 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int(static_cast<int >(wxDateTime::GMT9)));
35836 }
35837 {
35838 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int(static_cast<int >(wxDateTime::GMT10)));
35839 }
35840 {
35841 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int(static_cast<int >(wxDateTime::GMT11)));
35842 }
35843 {
35844 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int(static_cast<int >(wxDateTime::GMT12)));
35845 }
35846 {
35847 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int(static_cast<int >(wxDateTime::WET)));
35848 }
35849 {
35850 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int(static_cast<int >(wxDateTime::WEST)));
35851 }
35852 {
35853 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int(static_cast<int >(wxDateTime::CET)));
35854 }
35855 {
35856 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int(static_cast<int >(wxDateTime::CEST)));
35857 }
35858 {
35859 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int(static_cast<int >(wxDateTime::EET)));
35860 }
35861 {
35862 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int(static_cast<int >(wxDateTime::EEST)));
35863 }
35864 {
35865 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int(static_cast<int >(wxDateTime::MSK)));
35866 }
35867 {
35868 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int(static_cast<int >(wxDateTime::MSD)));
35869 }
35870 {
35871 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int(static_cast<int >(wxDateTime::AST)));
35872 }
35873 {
35874 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int(static_cast<int >(wxDateTime::ADT)));
35875 }
35876 {
35877 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int(static_cast<int >(wxDateTime::EST)));
35878 }
35879 {
35880 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int(static_cast<int >(wxDateTime::EDT)));
35881 }
35882 {
35883 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int(static_cast<int >(wxDateTime::CST)));
35884 }
35885 {
35886 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int(static_cast<int >(wxDateTime::CDT)));
35887 }
35888 {
35889 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int(static_cast<int >(wxDateTime::MST)));
35890 }
35891 {
35892 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int(static_cast<int >(wxDateTime::MDT)));
35893 }
35894 {
35895 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int(static_cast<int >(wxDateTime::PST)));
35896 }
35897 {
35898 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int(static_cast<int >(wxDateTime::PDT)));
35899 }
35900 {
35901 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int(static_cast<int >(wxDateTime::HST)));
35902 }
35903 {
35904 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int(static_cast<int >(wxDateTime::AKST)));
35905 }
35906 {
35907 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int(static_cast<int >(wxDateTime::AKDT)));
35908 }
35909 {
35910 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int(static_cast<int >(wxDateTime::A_WST)));
35911 }
35912 {
35913 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int(static_cast<int >(wxDateTime::A_CST)));
35914 }
35915 {
35916 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int(static_cast<int >(wxDateTime::A_EST)));
35917 }
35918 {
35919 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int(static_cast<int >(wxDateTime::A_ESST)));
35920 }
35921 {
35922 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int(static_cast<int >(wxDateTime::UTC)));
35923 }
35924 {
35925 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int(static_cast<int >(wxDateTime::Gregorian)));
35926 }
35927 {
35928 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int(static_cast<int >(wxDateTime::Julian)));
35929 }
35930 {
35931 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Unknown)));
35932 }
35933 {
35934 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Standard)));
35935 }
35936 {
35937 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Alaska)));
35938 }
35939 {
35940 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Albania)));
35941 }
35942 {
35943 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria)));
35944 }
35945 {
35946 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Brixen)));
35947 }
35948 {
35949 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Salzburg)));
35950 }
35951 {
35952 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Tyrol)));
35953 }
35954 {
35955 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Carinthia)));
35956 }
35957 {
35958 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Styria)));
35959 }
35960 {
35961 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Belgium)));
35962 }
35963 {
35964 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Bulgaria)));
35965 }
35966 {
35967 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Bulgaria_1)));
35968 }
35969 {
35970 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Bulgaria_2)));
35971 }
35972 {
35973 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Bulgaria_3)));
35974 }
35975 {
35976 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Canada)));
35977 }
35978 {
35979 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int(static_cast<int >(wxDateTime::Gr_China)));
35980 }
35981 {
35982 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int(static_cast<int >(wxDateTime::Gr_China_1)));
35983 }
35984 {
35985 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int(static_cast<int >(wxDateTime::Gr_China_2)));
35986 }
35987 {
35988 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Czechoslovakia)));
35989 }
35990 {
35991 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Denmark)));
35992 }
35993 {
35994 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Egypt)));
35995 }
35996 {
35997 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Estonia)));
35998 }
35999 {
36000 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Finland)));
36001 }
36002 {
36003 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int(static_cast<int >(wxDateTime::Gr_France)));
36004 }
36005 {
36006 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int(static_cast<int >(wxDateTime::Gr_France_Alsace)));
36007 }
36008 {
36009 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int(static_cast<int >(wxDateTime::Gr_France_Lorraine)));
36010 }
36011 {
36012 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int(static_cast<int >(wxDateTime::Gr_France_Strasbourg)));
36013 }
36014 {
36015 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Germany)));
36016 }
36017 {
36018 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Germany_Catholic)));
36019 }
36020 {
36021 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Germany_Prussia)));
36022 }
36023 {
36024 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Germany_Protestant)));
36025 }
36026 {
36027 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int(static_cast<int >(wxDateTime::Gr_GreatBritain)));
36028 }
36029 {
36030 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Greece)));
36031 }
36032 {
36033 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Hungary)));
36034 }
36035 {
36036 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Ireland)));
36037 }
36038 {
36039 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Italy)));
36040 }
36041 {
36042 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Japan)));
36043 }
36044 {
36045 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Japan_1)));
36046 }
36047 {
36048 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Japan_2)));
36049 }
36050 {
36051 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Japan_3)));
36052 }
36053 {
36054 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Latvia)));
36055 }
36056 {
36057 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Lithuania)));
36058 }
36059 {
36060 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Luxemburg)));
36061 }
36062 {
36063 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands)));
36064 }
36065 {
36066 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands_Groningen)));
36067 }
36068 {
36069 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands_Gelderland)));
36070 }
36071 {
36072 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands_Utrecht)));
36073 }
36074 {
36075 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands_Friesland)));
36076 }
36077 {
36078 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Norway)));
36079 }
36080 {
36081 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Poland)));
36082 }
36083 {
36084 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Portugal)));
36085 }
36086 {
36087 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Romania)));
36088 }
36089 {
36090 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Russia)));
36091 }
36092 {
36093 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Scotland)));
36094 }
36095 {
36096 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Spain)));
36097 }
36098 {
36099 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Sweden)));
36100 }
36101 {
36102 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Switzerland)));
36103 }
36104 {
36105 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Switzerland_Catholic)));
36106 }
36107 {
36108 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Switzerland_Protestant)));
36109 }
36110 {
36111 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Turkey)));
36112 }
36113 {
36114 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int(static_cast<int >(wxDateTime::Gr_USA)));
36115 }
36116 {
36117 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Wales)));
36118 }
36119 {
36120 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Yugoslavia)));
36121 }
36122 {
36123 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int(static_cast<int >(wxDateTime::Country_Unknown)));
36124 }
36125 {
36126 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int(static_cast<int >(wxDateTime::Country_Default)));
36127 }
36128 {
36129 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int(static_cast<int >(wxDateTime::Country_WesternEurope_Start)));
36130 }
36131 {
36132 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int(static_cast<int >(wxDateTime::Country_EEC)));
36133 }
36134 {
36135 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int(static_cast<int >(wxDateTime::France)));
36136 }
36137 {
36138 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int(static_cast<int >(wxDateTime::Germany)));
36139 }
36140 {
36141 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int(static_cast<int >(wxDateTime::UK)));
36142 }
36143 {
36144 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int(static_cast<int >(wxDateTime::Country_WesternEurope_End)));
36145 }
36146 {
36147 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int(static_cast<int >(wxDateTime::Russia)));
36148 }
36149 {
36150 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int(static_cast<int >(wxDateTime::USA)));
36151 }
36152 {
36153 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int(static_cast<int >(wxDateTime::Jan)));
36154 }
36155 {
36156 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int(static_cast<int >(wxDateTime::Feb)));
36157 }
36158 {
36159 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int(static_cast<int >(wxDateTime::Mar)));
36160 }
36161 {
36162 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int(static_cast<int >(wxDateTime::Apr)));
36163 }
36164 {
36165 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int(static_cast<int >(wxDateTime::May)));
36166 }
36167 {
36168 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int(static_cast<int >(wxDateTime::Jun)));
36169 }
36170 {
36171 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int(static_cast<int >(wxDateTime::Jul)));
36172 }
36173 {
36174 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int(static_cast<int >(wxDateTime::Aug)));
36175 }
36176 {
36177 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int(static_cast<int >(wxDateTime::Sep)));
36178 }
36179 {
36180 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int(static_cast<int >(wxDateTime::Oct)));
36181 }
36182 {
36183 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int(static_cast<int >(wxDateTime::Nov)));
36184 }
36185 {
36186 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int(static_cast<int >(wxDateTime::Dec)));
36187 }
36188 {
36189 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int(static_cast<int >(wxDateTime::Inv_Month)));
36190 }
36191 {
36192 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int(static_cast<int >(wxDateTime::Sun)));
36193 }
36194 {
36195 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int(static_cast<int >(wxDateTime::Mon)));
36196 }
36197 {
36198 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int(static_cast<int >(wxDateTime::Tue)));
36199 }
36200 {
36201 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int(static_cast<int >(wxDateTime::Wed)));
36202 }
36203 {
36204 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int(static_cast<int >(wxDateTime::Thu)));
36205 }
36206 {
36207 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int(static_cast<int >(wxDateTime::Fri)));
36208 }
36209 {
36210 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int(static_cast<int >(wxDateTime::Sat)));
36211 }
36212 {
36213 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int(static_cast<int >(wxDateTime::Inv_WeekDay)));
36214 }
36215 {
36216 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int(static_cast<int >(wxDateTime::Inv_Year)));
36217 }
36218 {
36219 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int(static_cast<int >(wxDateTime::Name_Full)));
36220 }
36221 {
36222 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int(static_cast<int >(wxDateTime::Name_Abbr)));
36223 }
36224 {
36225 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int(static_cast<int >(wxDateTime::Default_First)));
36226 }
36227 {
36228 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int(static_cast<int >(wxDateTime::Monday_First)));
36229 }
36230 {
36231 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int(static_cast<int >(wxDateTime::Sunday_First)));
36232 }
36233 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
36234 {
36235 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int(static_cast<int >(wxDF_INVALID)));
36236 }
36237 {
36238 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int(static_cast<int >(wxDF_TEXT)));
36239 }
36240 {
36241 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int(static_cast<int >(wxDF_BITMAP)));
36242 }
36243 {
36244 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int(static_cast<int >(wxDF_METAFILE)));
36245 }
36246 {
36247 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int(static_cast<int >(wxDF_SYLK)));
36248 }
36249 {
36250 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int(static_cast<int >(wxDF_DIF)));
36251 }
36252 {
36253 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int(static_cast<int >(wxDF_TIFF)));
36254 }
36255 {
36256 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int(static_cast<int >(wxDF_OEMTEXT)));
36257 }
36258 {
36259 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int(static_cast<int >(wxDF_DIB)));
36260 }
36261 {
36262 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int(static_cast<int >(wxDF_PALETTE)));
36263 }
36264 {
36265 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int(static_cast<int >(wxDF_PENDATA)));
36266 }
36267 {
36268 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int(static_cast<int >(wxDF_RIFF)));
36269 }
36270 {
36271 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int(static_cast<int >(wxDF_WAVE)));
36272 }
36273 {
36274 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int(static_cast<int >(wxDF_UNICODETEXT)));
36275 }
36276 {
36277 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int(static_cast<int >(wxDF_ENHMETAFILE)));
36278 }
36279 {
36280 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int(static_cast<int >(wxDF_FILENAME)));
36281 }
36282 {
36283 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int(static_cast<int >(wxDF_LOCALE)));
36284 }
36285 {
36286 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int(static_cast<int >(wxDF_PRIVATE)));
36287 }
36288 {
36289 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int(static_cast<int >(wxDF_HTML)));
36290 }
36291 {
36292 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int(static_cast<int >(wxDF_MAX)));
36293 }
36294 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
36295 {
36296 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int(static_cast<int >(wxDataObject::Get)));
36297 }
36298 {
36299 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int(static_cast<int >(wxDataObject::Set)));
36300 }
36301 {
36302 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int(static_cast<int >(wxDataObject::Both)));
36303 }
36304 {
36305 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int(static_cast<int >(wxDrag_CopyOnly)));
36306 }
36307 {
36308 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int(static_cast<int >(wxDrag_AllowMove)));
36309 }
36310 {
36311 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int(static_cast<int >(wxDrag_DefaultMove)));
36312 }
36313 {
36314 PyDict_SetItemString(d,"DragError", SWIG_From_int(static_cast<int >(wxDragError)));
36315 }
36316 {
36317 PyDict_SetItemString(d,"DragNone", SWIG_From_int(static_cast<int >(wxDragNone)));
36318 }
36319 {
36320 PyDict_SetItemString(d,"DragCopy", SWIG_From_int(static_cast<int >(wxDragCopy)));
36321 }
36322 {
36323 PyDict_SetItemString(d,"DragMove", SWIG_From_int(static_cast<int >(wxDragMove)));
36324 }
36325 {
36326 PyDict_SetItemString(d,"DragLink", SWIG_From_int(static_cast<int >(wxDragLink)));
36327 }
36328 {
36329 PyDict_SetItemString(d,"DragCancel", SWIG_From_int(static_cast<int >(wxDragCancel)));
36330 }
36331
36332 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
36333 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
36334 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
36335 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
36336
36337 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
36338 }
36339
wxWidgets (Impactor)