]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
Tweaks for demos on MacOSX
[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_Python_TypeError("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* result, PyObject* obj)
1805 {
1806 PyObject* o2;
1807 PyObject* o3;
1808 if (!result) {
1809 result = obj;
1810 } else if (result == Py_None) {
1811 Py_DECREF(result);
1812 result = obj;
1813 } else {
1814 if (!PyTuple_Check(result)) {
1815 o2 = result;
1816 result = PyTuple_New(1);
1817 PyTuple_SET_ITEM(result, 0, o2);
1818 }
1819 o3 = PyTuple_New(1);
1820 PyTuple_SetItem(o3, 0, obj);
1821 o2 = result;
1822 result = PySequence_Concat(o2, o3);
1823 Py_DECREF(o2);
1824 Py_DECREF(o3);
1825 }
1826 return result;
1827 }
1828
1829
1830
1831 wxMemorySize wxGetFreeMemory()
1832 { wxPyRaiseNotImplemented(); return 0; }
1833
1834
1835 SWIGINTERN int
1836 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1837 {
1838 long v = 0;
1839 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1840 SWIG_Python_TypeError("unsigned number", obj);
1841 }
1842 else if (val)
1843 *val = (unsigned long)v;
1844 return 1;
1845 }
1846
1847
1848 SWIGINTERNINLINE unsigned long
1849 SWIG_As_unsigned_SS_long(PyObject* obj)
1850 {
1851 unsigned long v;
1852 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1853 /*
1854 this is needed to make valgrind/purify happier.
1855 */
1856 memset((void*)&v, 0, sizeof(unsigned long));
1857 }
1858 return v;
1859 }
1860
1861
1862 SWIGINTERNINLINE int
1863 SWIG_Check_unsigned_SS_long(PyObject* obj)
1864 {
1865 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1866 }
1867
1868
1869 SWIGINTERNINLINE PyObject*
1870 SWIG_From_unsigned_SS_long(unsigned long value)
1871 {
1872 return (value > LONG_MAX) ?
1873 PyLong_FromUnsignedLong(value)
1874 : PyInt_FromLong(static_cast<long >(value));
1875 }
1876
1877
1878 void* wxGetXDisplay()
1879 {
1880 #ifdef __WXGTK__
1881 return wxGetDisplay();
1882 #else
1883 return NULL;
1884 #endif
1885 }
1886
1887
1888 wxWindow* FindWindowAtPointer() {
1889 wxPoint unused;
1890 return wxFindWindowAtPointer(unused);
1891 }
1892
1893
1894 void wxWakeUpMainThread() {}
1895
1896
1897 bool wxThread_IsMain() {
1898 #ifdef WXP_WITH_THREAD
1899 return wxThread::IsMain();
1900 #else
1901 return true;
1902 #endif
1903 }
1904
1905 static void wxCaret_Destroy(wxCaret *self){
1906 delete self;
1907 }
1908
1909 #include <wx/snglinst.h>
1910
1911
1912 #ifdef __WXMSW__
1913 #include <wx/msw/private.h>
1914 #include <wx/dynload.h>
1915 #endif
1916
1917
1918
1919 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1920 #if 0
1921 , int method
1922 #endif
1923 )
1924 {
1925 #ifdef __WXMSW__
1926 #if 0
1927 switch (method)
1928 {
1929 case 1:
1930 // This one only partially works. Appears to be an undocumented
1931 // "standard" convention that not all widgets adhear to. For
1932 // example, for some widgets backgrounds or non-client areas may
1933 // not be painted.
1934 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1935 break;
1936
1937 case 2:
1938 #endif
1939 // This one works much better, nearly all widgets and their
1940 // children are captured correctly[**]. Prior to the big
1941 // background erase changes that Vadim did in 2004-2005 this
1942 // method failed badly on XP with Themes activated, most native
1943 // widgets draw only partially, if at all. Without themes it
1944 // worked just like on Win2k. After those changes this method
1945 // works very well.
1946 //
1947 // ** For example the radio buttons in a wxRadioBox are not its
1948 // children by default, but you can capture it via the panel
1949 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1950 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1951 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1952 PRF_ERASEBKGND | PRF_OWNED );
1953 return true;
1954 #if 0
1955 break;
1956
1957 case 3:
1958 // This one is only defined in the latest SDK and is only
1959 // available on XP. MSDN says it is similar to sending WM_PRINT
1960 // so I expect that it will work similar to the above. Since it
1961 // is avaialble only on XP, it can't be compiled like this and
1962 // will have to be loaded dynamically.
1963 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1964
1965 // fall through
1966
1967 case 4:
1968 // Use PrintWindow if available, or fallback to WM_PRINT
1969 // otherwise. Unfortunately using PrintWindow is even worse than
1970 // WM_PRINT. For most native widgets nothing is drawn to the dc
1971 // at all, with or without Themes.
1972 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1973 static bool s_triedToLoad = false;
1974 static PrintWindow_t pfnPrintWindow = NULL;
1975 if ( !s_triedToLoad )
1976 {
1977
1978 s_triedToLoad = true;
1979 wxDynamicLibrary dllUser32(_T("user32.dll"));
1980 if ( dllUser32.IsLoaded() )
1981 {
1982 wxLogNull nolog; // Don't report errors here
1983 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1984 }
1985 }
1986 if (pfnPrintWindow)
1987 {
1988 //printf("Using PrintWindow\n");
1989 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1990 }
1991 else
1992 {
1993 //printf("Using WM_PRINT\n");
1994 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1995 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1996 PRF_ERASEBKGND | PRF_OWNED );
1997 }
1998 }
1999 #endif // 0
2000 #else
2001 return false;
2002 #endif // __WXMSW__
2003 }
2004
2005
2006
2007 #include <wx/tipdlg.h>
2008
2009
2010 class wxPyTipProvider : public wxTipProvider {
2011 public:
2012 wxPyTipProvider(size_t currentTip)
2013 : wxTipProvider(currentTip) {}
2014
2015 DEC_PYCALLBACK_STRING__pure(GetTip);
2016 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2017 PYPRIVATE;
2018 };
2019
2020 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2021 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2022
2023
2024 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
2025
2026 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
2027
2028 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
2029 : wxTimer(owner, id)
2030 {
2031 if (owner == NULL) SetOwner(this);
2032 }
2033
2034
2035 SWIGINTERN PyObject *
2036 SWIG_FromCharPtr(const char* cptr)
2037 {
2038 if (cptr) {
2039 size_t size = strlen(cptr);
2040 if (size > INT_MAX) {
2041 return SWIG_NewPointerObj(const_cast<char* >(cptr),
2042 SWIG_TypeQuery("char *"), 0);
2043 } else {
2044 if (size != 0) {
2045 return PyString_FromStringAndSize(cptr, size);
2046 } else {
2047 return PyString_FromString(cptr);
2048 }
2049 }
2050 }
2051 Py_INCREF(Py_None);
2052 return Py_None;
2053 }
2054
2055
2056 SWIGINTERNINLINE int
2057 SWIG_CheckUnsignedLongInRange(unsigned long value,
2058 unsigned long max_value,
2059 const char *errmsg)
2060 {
2061 if (value > max_value) {
2062 if (errmsg) {
2063 PyErr_Format(PyExc_OverflowError,
2064 "value %lu is greater than '%s' minimum %lu",
2065 value, errmsg, max_value);
2066 }
2067 return 0;
2068 }
2069 return 1;
2070 }
2071
2072
2073 #if UINT_MAX != ULONG_MAX
2074 SWIGINTERN int
2075 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2076 {
2077 const char* errmsg = val ? "unsigned int" : (char*)0;
2078 unsigned long v;
2079 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2080 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2081 if (val) *val = static_cast<unsigned int >(v);
2082 return 1;
2083 }
2084 } else {
2085 PyErr_Clear();
2086 }
2087 if (val) {
2088 SWIG_type_error(errmsg, obj);
2089 }
2090 return 0;
2091 }
2092 #else
2093 SWIGINTERNINLINE unsigned int
2094 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2095 {
2096 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2097 }
2098 #endif
2099
2100
2101 SWIGINTERNINLINE unsigned int
2102 SWIG_As_unsigned_SS_int(PyObject* obj)
2103 {
2104 unsigned int v;
2105 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2106 /*
2107 this is needed to make valgrind/purify happier.
2108 */
2109 memset((void*)&v, 0, sizeof(unsigned int));
2110 }
2111 return v;
2112 }
2113
2114
2115 SWIGINTERNINLINE int
2116 SWIG_Check_unsigned_SS_int(PyObject* obj)
2117 {
2118 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2119 }
2120
2121 static wxString wxLog_TimeStamp(){
2122 wxString msg;
2123 wxLog::TimeStamp(&msg);
2124 return msg;
2125 }
2126 static void wxLog_Destroy(wxLog *self){ delete self; }
2127 // Make some wrappers that double any % signs so they are 'escaped'
2128 void wxPyLogFatalError(const wxString& msg)
2129 {
2130 wxString m(msg);
2131 m.Replace(wxT("%"), wxT("%%"));
2132 wxLogFatalError(m);
2133 }
2134
2135 void wxPyLogError(const wxString& msg)
2136 {
2137 wxString m(msg);
2138 m.Replace(wxT("%"), wxT("%%"));
2139 wxLogError(m);
2140 }
2141
2142 void wxPyLogWarning(const wxString& msg)
2143 {
2144 wxString m(msg);
2145 m.Replace(wxT("%"), wxT("%%"));
2146 wxLogWarning(m);
2147 }
2148
2149 void wxPyLogMessage(const wxString& msg)
2150 {
2151 wxString m(msg);
2152 m.Replace(wxT("%"), wxT("%%"));
2153 wxLogMessage(m);
2154 }
2155
2156 void wxPyLogInfo(const wxString& msg)
2157 {
2158 wxString m(msg);
2159 m.Replace(wxT("%"), wxT("%%"));
2160 wxLogInfo(m);
2161 }
2162
2163 void wxPyLogDebug(const wxString& msg)
2164 {
2165 wxString m(msg);
2166 m.Replace(wxT("%"), wxT("%%"));
2167 wxLogDebug(m);
2168 }
2169
2170 void wxPyLogVerbose(const wxString& msg)
2171 {
2172 wxString m(msg);
2173 m.Replace(wxT("%"), wxT("%%"));
2174 wxLogVerbose(m);
2175 }
2176
2177 void wxPyLogStatus(const wxString& msg)
2178 {
2179 wxString m(msg);
2180 m.Replace(wxT("%"), wxT("%%"));
2181 wxLogStatus(m);
2182 }
2183
2184 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2185 {
2186 wxString m(msg);
2187 m.Replace(wxT("%"), wxT("%%"));
2188 wxLogStatus(pFrame, m);
2189 }
2190
2191 void wxPyLogSysError(const wxString& msg)
2192 {
2193 wxString m(msg);
2194 m.Replace(wxT("%"), wxT("%%"));
2195 wxLogSysError(m);
2196 }
2197
2198 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2199 {
2200 wxString m(msg);
2201 m.Replace(wxT("%"), wxT("%%"));
2202 wxLogGeneric(level, m);
2203 }
2204
2205 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2206 {
2207 wxString m(msg);
2208 m.Replace(wxT("%"), wxT("%%"));
2209 wxLogTrace(mask, m);
2210 }
2211
2212 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2213 {
2214 wxString m(msg);
2215 m.Replace(wxT("%"), wxT("%%"));
2216 wxLogTrace(mask, m);
2217 }
2218
2219
2220
2221 // A wxLog class that can be derived from in wxPython
2222 class wxPyLog : public wxLog {
2223 public:
2224 wxPyLog() : wxLog() {}
2225
2226 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2227 bool found;
2228 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2229 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2230 PyObject* s = wx2PyString(szString);
2231 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2232 Py_DECREF(s);
2233 }
2234 wxPyEndBlockThreads(blocked);
2235 if (! found)
2236 wxLog::DoLog(level, szString, t);
2237 }
2238
2239 virtual void DoLogString(const wxChar *szString, time_t t) {
2240 bool found;
2241 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2242 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2243 PyObject* s = wx2PyString(szString);
2244 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2245 Py_DECREF(s);
2246 }
2247 wxPyEndBlockThreads(blocked);
2248 if (! found)
2249 wxLog::DoLogString(szString, t);
2250 }
2251
2252 DEC_PYCALLBACK_VOID_(Flush);
2253 PYPRIVATE;
2254 };
2255 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
2256
2257
2258
2259
2260 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2261
2262
2263 #include <wx/joystick.h>
2264
2265
2266 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2267 // A C++ stub class for wxJoystick for platforms that don't have it.
2268 class wxJoystick : public wxObject {
2269 public:
2270 wxJoystick(int joystick = wxJOYSTICK1) {
2271 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2272 PyErr_SetString(PyExc_NotImplementedError,
2273 "wxJoystick is not available on this platform.");
2274 wxPyEndBlockThreads(blocked);
2275 }
2276 wxPoint GetPosition() { return wxPoint(-1,-1); }
2277 int GetZPosition() { return -1; }
2278 int GetButtonState() { return -1; }
2279 int GetPOVPosition() { return -1; }
2280 int GetPOVCTSPosition() { return -1; }
2281 int GetRudderPosition() { return -1; }
2282 int GetUPosition() { return -1; }
2283 int GetVPosition() { return -1; }
2284 int GetMovementThreshold() { return -1; }
2285 void SetMovementThreshold(int threshold) {}
2286
2287 bool IsOk(void) { return false; }
2288 int GetNumberJoysticks() { return -1; }
2289 int GetManufacturerId() { return -1; }
2290 int GetProductId() { return -1; }
2291 wxString GetProductName() { return wxEmptyString; }
2292 int GetXMin() { return -1; }
2293 int GetYMin() { return -1; }
2294 int GetZMin() { return -1; }
2295 int GetXMax() { return -1; }
2296 int GetYMax() { return -1; }
2297 int GetZMax() { return -1; }
2298 int GetNumberButtons() { return -1; }
2299 int GetNumberAxes() { return -1; }
2300 int GetMaxButtons() { return -1; }
2301 int GetMaxAxes() { return -1; }
2302 int GetPollingMin() { return -1; }
2303 int GetPollingMax() { return -1; }
2304 int GetRudderMin() { return -1; }
2305 int GetRudderMax() { return -1; }
2306 int GetUMin() { return -1; }
2307 int GetUMax() { return -1; }
2308 int GetVMin() { return -1; }
2309 int GetVMax() { return -1; }
2310
2311 bool HasRudder() { return false; }
2312 bool HasZ() { return false; }
2313 bool HasU() { return false; }
2314 bool HasV() { return false; }
2315 bool HasPOV() { return false; }
2316 bool HasPOV4Dir() { return false; }
2317 bool HasPOVCTS() { return false; }
2318
2319 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2320 bool ReleaseCapture() { return false; }
2321 };
2322 #endif
2323
2324
2325 #include <wx/sound.h>
2326
2327
2328 #if !wxUSE_SOUND
2329 // A C++ stub class for wxWave for platforms that don't have it.
2330 class wxSound : public wxObject
2331 {
2332 public:
2333 wxSound() {
2334 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2335 PyErr_SetString(PyExc_NotImplementedError,
2336 "wxSound is not available on this platform.");
2337 wxPyEndBlockThreads(blocked);
2338 }
2339 wxSound(const wxString&/*, bool*/) {
2340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2341 PyErr_SetString(PyExc_NotImplementedError,
2342 "wxSound is not available on this platform.");
2343 wxPyEndBlockThreads(blocked);
2344 }
2345 wxSound(int, const wxByte*) {
2346 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2347 PyErr_SetString(PyExc_NotImplementedError,
2348 "wxSound is not available on this platform.");
2349 wxPyEndBlockThreads(blocked);
2350 }
2351
2352 ~wxSound() {};
2353
2354 bool Create(const wxString&/*, bool*/) { return false; }
2355 bool Create(int, const wxByte*) { return false; };
2356 bool IsOk() { return false; };
2357 bool Play(unsigned) const { return false; }
2358 static bool Play(const wxString&, unsigned) { return false; }
2359 static void Stop() {}
2360 };
2361
2362 #endif
2363
2364 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2365 if (fileName.Length() == 0)
2366 return new wxSound;
2367 else
2368 return new wxSound(fileName);
2369 }
2370 static wxSound *new_wxSound(PyObject *data){
2371 unsigned char* buffer; int size;
2372 wxSound *sound = NULL;
2373
2374 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2375 if (!PyArg_Parse(data, "t#", &buffer, &size))
2376 goto done;
2377 sound = new wxSound(size, buffer);
2378 done:
2379 wxPyEndBlockThreads(blocked);
2380 return sound;
2381 }
2382 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2383 #ifndef __WXMAC__
2384 unsigned char* buffer;
2385 int size;
2386 bool rv = false;
2387
2388 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2389 if (!PyArg_Parse(data, "t#", &buffer, &size))
2390 goto done;
2391 rv = self->Create(size, buffer);
2392 done:
2393 wxPyEndBlockThreads(blocked);
2394 return rv;
2395 #else
2396 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2397 PyErr_SetString(PyExc_NotImplementedError,
2398 "Create from data is not available on this platform.");
2399 wxPyEndBlockThreads(blocked);
2400 return false;
2401 #endif
2402 }
2403
2404 #include <wx/mimetype.h>
2405
2406 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2407 wxString str;
2408 if (self->GetMimeType(&str))
2409 return wx2PyString(str);
2410 else
2411 RETURN_NONE();
2412 }
2413 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2414 wxArrayString arr;
2415 if (self->GetMimeTypes(arr))
2416 return wxArrayString2PyList_helper(arr);
2417 else
2418 RETURN_NONE();
2419 }
2420 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2421 wxArrayString arr;
2422 if (self->GetExtensions(arr))
2423 return wxArrayString2PyList_helper(arr);
2424 else
2425 RETURN_NONE();
2426 }
2427 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2428 wxIconLocation loc;
2429 if (self->GetIcon(&loc))
2430 return new wxIcon(loc);
2431 else
2432 return NULL;
2433 }
2434 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2435 wxIconLocation loc;
2436 if (self->GetIcon(&loc)) {
2437 wxString iconFile = loc.GetFileName();
2438 int iconIndex = -1;
2439
2440
2441
2442 // Make a tuple and put the values in it
2443 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2444 PyObject* tuple = PyTuple_New(3);
2445 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2446 wxT("wxIcon"), true));
2447 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2448 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2449 wxPyEndBlockThreads(blocked);
2450 return tuple;
2451 }
2452 else
2453 RETURN_NONE();
2454 }
2455 static PyObject *wxFileType_GetDescription(wxFileType *self){
2456 wxString str;
2457 if (self->GetDescription(&str))
2458 return wx2PyString(str);
2459 else
2460 RETURN_NONE();
2461 }
2462 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2463 wxString str;
2464 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2465 return wx2PyString(str);
2466 else
2467 RETURN_NONE();
2468 }
2469 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2470 wxString str;
2471 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2472 return wx2PyString(str);
2473 else
2474 RETURN_NONE();
2475 }
2476 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2477 wxArrayString verbs;
2478 wxArrayString commands;
2479 if (self->GetAllCommands(&verbs, &commands,
2480 wxFileType::MessageParameters(filename, mimetype))) {
2481 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2482 PyObject* tuple = PyTuple_New(2);
2483 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2484 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2485 wxPyEndBlockThreads(blocked);
2486 return tuple;
2487 }
2488 else
2489 RETURN_NONE();
2490 }
2491 static wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2492 return wxFileType::ExpandCommand(command,
2493 wxFileType::MessageParameters(filename, mimetype));
2494 }
2495 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2496 wxArrayString arr;
2497 self->EnumAllFileTypes(arr);
2498 return wxArrayString2PyList_helper(arr);
2499 }
2500
2501 #include <wx/artprov.h>
2502
2503 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2504 static const wxString wxPyART_MENU(wxART_MENU);
2505 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2506 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2507 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2508 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2509 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2510 static const wxString wxPyART_OTHER(wxART_OTHER);
2511 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2512 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2513 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2514 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2515 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2516 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2517 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2518 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2519 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2520 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2521 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2522 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2523 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2524 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2525 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2526 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2527 static const wxString wxPyART_PRINT(wxART_PRINT);
2528 static const wxString wxPyART_HELP(wxART_HELP);
2529 static const wxString wxPyART_TIP(wxART_TIP);
2530 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2531 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2532 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2533 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2534 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2535 static const wxString wxPyART_CDROM(wxART_CDROM);
2536 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2537 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2538 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2539 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2540 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2541 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2542 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2543 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2544 static const wxString wxPyART_ERROR(wxART_ERROR);
2545 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2546 static const wxString wxPyART_WARNING(wxART_WARNING);
2547 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2548 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2549 static const wxString wxPyART_COPY(wxART_COPY);
2550 static const wxString wxPyART_CUT(wxART_CUT);
2551 static const wxString wxPyART_PASTE(wxART_PASTE);
2552 static const wxString wxPyART_DELETE(wxART_DELETE);
2553 static const wxString wxPyART_NEW(wxART_NEW);
2554 static const wxString wxPyART_UNDO(wxART_UNDO);
2555 static const wxString wxPyART_REDO(wxART_REDO);
2556 static const wxString wxPyART_QUIT(wxART_QUIT);
2557 static const wxString wxPyART_FIND(wxART_FIND);
2558 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2559 // Python aware wxArtProvider
2560 class wxPyArtProvider : public wxArtProvider {
2561 public:
2562
2563 virtual wxBitmap CreateBitmap(const wxArtID& id,
2564 const wxArtClient& client,
2565 const wxSize& size) {
2566 wxBitmap rval = wxNullBitmap;
2567 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2568 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2569 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2570 PyObject* ro;
2571 wxBitmap* ptr;
2572 PyObject* s1, *s2;
2573 s1 = wx2PyString(id);
2574 s2 = wx2PyString(client);
2575 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2576 Py_DECREF(so);
2577 Py_DECREF(s1);
2578 Py_DECREF(s2);
2579 if (ro) {
2580 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2581 rval = *ptr;
2582 Py_DECREF(ro);
2583 }
2584 }
2585 wxPyEndBlockThreads(blocked);
2586 return rval;
2587 }
2588
2589 PYPRIVATE;
2590 };
2591
2592 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2593
2594
2595
2596 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2597 PyObject* ret = PyTuple_New(3);
2598 if (ret) {
2599 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2600 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2601 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2602 }
2603 return ret;
2604 }
2605
2606 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2607 bool cont;
2608 long index = 0;
2609 wxString value;
2610
2611 cont = self->GetFirstGroup(value, index);
2612 return __EnumerationHelper(cont, value, index);
2613 }
2614 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2615 bool cont;
2616 wxString value;
2617
2618 cont = self->GetNextGroup(value, index);
2619 return __EnumerationHelper(cont, value, index);
2620 }
2621 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2622 bool cont;
2623 long index = 0;
2624 wxString value;
2625
2626 cont = self->GetFirstEntry(value, index);
2627 return __EnumerationHelper(cont, value, index);
2628 }
2629 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2630 bool cont;
2631 wxString value;
2632
2633 cont = self->GetNextEntry(value, index);
2634 return __EnumerationHelper(cont, value, index);
2635 }
2636 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2637 long rv;
2638 self->Read(key, &rv, defaultVal);
2639 return rv;
2640 }
2641
2642 SWIGINTERN int
2643 SWIG_AsVal_double(PyObject *obj, double* val)
2644 {
2645 if (PyNumber_Check(obj)) {
2646 if (val) *val = PyFloat_AsDouble(obj);
2647 return 1;
2648 }
2649 else {
2650 SWIG_Python_TypeError("number", obj);
2651 }
2652 return 0;
2653 }
2654
2655
2656 SWIGINTERNINLINE double
2657 SWIG_As_double(PyObject* obj)
2658 {
2659 double v;
2660 if (!SWIG_AsVal_double(obj, &v)) {
2661 /*
2662 this is needed to make valgrind/purify happier.
2663 */
2664 memset((void*)&v, 0, sizeof(double));
2665 }
2666 return v;
2667 }
2668
2669
2670 SWIGINTERNINLINE int
2671 SWIG_Check_double(PyObject* obj)
2672 {
2673 return SWIG_AsVal_double(obj, (double*)0);
2674 }
2675
2676 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2677 double rv;
2678 self->Read(key, &rv, defaultVal);
2679 return rv;
2680 }
2681
2682 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2683 #define SWIG_From_double PyFloat_FromDouble
2684 /*@@*/
2685
2686 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2687 bool rv;
2688 self->Read(key, &rv, defaultVal);
2689 return rv;
2690 }
2691
2692 #include <wx/datetime.h>
2693
2694 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2695 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2696
2697 #define LOCAL_TZ wxDateTime::Local
2698
2699 static PyObject *wxDateTime_GetAmPmStrings(){
2700 wxString am;
2701 wxString pm;
2702 wxDateTime::GetAmPmStrings(&am, &pm);
2703 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2704 PyObject* tup = PyTuple_New(2);
2705 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2706 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2707 wxPyEndBlockThreads(blocked);
2708 return tup;
2709 }
2710
2711 #if UINT_MAX < LONG_MAX
2712 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2713 #define SWIG_From_unsigned_SS_int SWIG_From_long
2714 /*@@*/
2715 #else
2716 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2717 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2718 /*@@*/
2719 #endif
2720
2721 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2722 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2723 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2724 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2725 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2726 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2727 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2728 return (*self < *other);
2729 }
2730 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2731 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2732 return (*self <= *other);
2733 }
2734 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2735 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2736 return (*self > *other);
2737 }
2738 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2739 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2740 return (*self >= *other);
2741 }
2742 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2743 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2744 return (*self == *other);
2745 }
2746 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2747 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2748 return (*self != *other);
2749 }
2750 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2751 const wxChar* rv;
2752 const wxChar* _date = date;
2753 rv = self->ParseRfc822Date(_date);
2754 if (rv == NULL) return -1;
2755 return rv - _date;
2756 }
2757 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2758 const wxChar* rv;
2759 const wxChar* _date = date;
2760 rv = self->ParseFormat(_date, format, dateDef);
2761 if (rv == NULL) return -1;
2762 return rv - _date;
2763 }
2764 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2765 const wxChar* rv;
2766 const wxChar* _datetime = datetime;
2767 rv = self->ParseDateTime(_datetime);
2768 if (rv == NULL) return -1;
2769 return rv - _datetime;
2770 }
2771 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2772 const wxChar* rv;
2773 const wxChar* _date = date;
2774 rv = self->ParseDate(_date);
2775 if (rv == NULL) return -1;
2776 return rv - _date;
2777 }
2778 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2779 const wxChar* rv;
2780 const wxChar* _time = time;
2781 rv = self->ParseTime(_time);
2782 if (rv == NULL) return -1;
2783 return rv - _time;
2784 }
2785 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2786 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2787 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2788 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2789 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2790 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2791 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2792 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2793 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2794 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2795 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2796 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2797 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2798 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2799 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2800 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2801
2802 #include <wx/dataobj.h>
2803
2804 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2805 size_t count = self->GetFormatCount(dir);
2806 wxDataFormat* formats = new wxDataFormat[count];
2807 self->GetAllFormats(formats, dir);
2808
2809 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2810 PyObject* list = PyList_New(count);
2811 for (size_t i=0; i<count; i++) {
2812 wxDataFormat* format = new wxDataFormat(formats[i]);
2813 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2814 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
2815 }
2816 wxPyEndBlockThreads(blocked);
2817 delete [] formats;
2818 return list;
2819 }
2820 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2821 PyObject* rval = NULL;
2822 size_t size = self->GetDataSize(format);
2823 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2824 if (size) {
2825 char* buf = new char[size];
2826 if (self->GetDataHere(format, buf))
2827 rval = PyString_FromStringAndSize(buf, size);
2828 delete [] buf;
2829 }
2830 if (! rval) {
2831 rval = Py_None;
2832 Py_INCREF(rval);
2833 }
2834 wxPyEndBlockThreads(blocked);
2835 return rval;
2836 }
2837 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2838 bool rval;
2839 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2840 if (PyString_Check(data)) {
2841 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2842 }
2843 else {
2844 // raise a TypeError if not a string
2845 PyErr_SetString(PyExc_TypeError, "String expected.");
2846 rval = false;
2847 }
2848 wxPyEndBlockThreads(blocked);
2849 return rval;
2850 }
2851 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2852 PyObject* rval = NULL;
2853 size_t size = self->GetDataSize();
2854 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2855 if (size) {
2856 char* buf = new char[size];
2857 if (self->GetDataHere(buf))
2858 rval = PyString_FromStringAndSize(buf, size);
2859 delete [] buf;
2860 }
2861 if (! rval) {
2862 rval = Py_None;
2863 Py_INCREF(rval);
2864 }
2865 wxPyEndBlockThreads(blocked);
2866 return rval;
2867 }
2868 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2869 bool rval;
2870 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2871 if (PyString_Check(data)) {
2872 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2873 }
2874 else {
2875 // raise a TypeError if not a string
2876 PyErr_SetString(PyExc_TypeError, "String expected.");
2877 rval = false;
2878 }
2879 wxPyEndBlockThreads(blocked);
2880 return rval;
2881 }
2882 // Create a new class for wxPython to use
2883 class wxPyDataObjectSimple : public wxDataObjectSimple {
2884 public:
2885 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2886 : wxDataObjectSimple(format) {}
2887
2888 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2889 bool GetDataHere(void *buf) const;
2890 bool SetData(size_t len, const void *buf) const;
2891 PYPRIVATE;
2892 };
2893
2894 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2895
2896 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2897 // We need to get the data for this object and write it to buf. I think
2898 // the best way to do this for wxPython is to have the Python method
2899 // return either a string or None and then act appropriately with the
2900 // C++ version.
2901
2902 bool rval = false;
2903 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2904 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2905 PyObject* ro;
2906 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2907 if (ro) {
2908 rval = (ro != Py_None && PyString_Check(ro));
2909 if (rval)
2910 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2911 Py_DECREF(ro);
2912 }
2913 }
2914 wxPyEndBlockThreads(blocked);
2915 return rval;
2916 }
2917
2918 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2919 // For this one we simply need to make a string from buf and len
2920 // and send it to the Python method.
2921 bool rval = false;
2922 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2923 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2924 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2925 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2926 Py_DECREF(data);
2927 }
2928 wxPyEndBlockThreads(blocked);
2929 return rval;
2930 }
2931
2932 // Create a new class for wxPython to use
2933 class wxPyTextDataObject : public wxTextDataObject {
2934 public:
2935 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2936 : wxTextDataObject(text) {}
2937
2938 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2939 DEC_PYCALLBACK_STRING__const(GetText);
2940 DEC_PYCALLBACK__STRING(SetText);
2941 PYPRIVATE;
2942 };
2943
2944 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2945 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2946 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2947
2948
2949 // Create a new class for wxPython to use
2950 class wxPyBitmapDataObject : public wxBitmapDataObject {
2951 public:
2952 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2953 : wxBitmapDataObject(bitmap) {}
2954
2955 wxBitmap GetBitmap() const;
2956 void SetBitmap(const wxBitmap& bitmap);
2957 PYPRIVATE;
2958 };
2959
2960 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2961 wxBitmap* rval = &wxNullBitmap;
2962 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2963 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2964 PyObject* ro;
2965 wxBitmap* ptr;
2966 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2967 if (ro) {
2968 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2969 rval = ptr;
2970 Py_DECREF(ro);
2971 }
2972 }
2973 wxPyEndBlockThreads(blocked);
2974 return *rval;
2975 }
2976
2977 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2978 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2979 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2980 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2981 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2982 Py_DECREF(bo);
2983 }
2984 wxPyEndBlockThreads(blocked);
2985 }
2986
2987 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2988 return new wxCustomDataObject(wxDataFormat(formatName));
2989 }
2990 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2991 bool rval;
2992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2993 if (PyString_Check(data)) {
2994 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2995 }
2996 else {
2997 // raise a TypeError if not a string
2998 PyErr_SetString(PyExc_TypeError, "String expected.");
2999 rval = false;
3000 }
3001 wxPyEndBlockThreads(blocked);
3002 return rval;
3003 }
3004 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3005 PyObject* obj;
3006 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3007 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3008 wxPyEndBlockThreads(blocked);
3009 return obj;
3010 }
3011
3012 class wxMetafileDataObject : public wxDataObjectSimple
3013 {
3014 public:
3015 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3016 };
3017
3018
3019 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3020
3021
3022 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3023 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3024 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3025 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3026 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3027
3028
3029 class wxPyTextDropTarget : public wxTextDropTarget {
3030 public:
3031 wxPyTextDropTarget() {}
3032
3033 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3034
3035 DEC_PYCALLBACK__(OnLeave);
3036 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3037 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3038 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3039 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3040
3041 PYPRIVATE;
3042 };
3043
3044 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3045 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3046 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3047 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3048 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3049 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3050
3051
3052
3053 class wxPyFileDropTarget : public wxFileDropTarget {
3054 public:
3055 wxPyFileDropTarget() {}
3056
3057 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3058
3059 DEC_PYCALLBACK__(OnLeave);
3060 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3061 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3062 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3063 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3064
3065 PYPRIVATE;
3066 };
3067
3068 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3069 const wxArrayString& filenames) {
3070 bool rval = false;
3071 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3072 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3073 PyObject* list = wxArrayString2PyList_helper(filenames);
3074 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3075 Py_DECREF(list);
3076 }
3077 wxPyEndBlockThreads(blocked);
3078 return rval;
3079 }
3080
3081
3082
3083 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3084 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3085 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3086 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3087 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
3088
3089
3090
3091
3092 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
3093
3094 #include <wx/display.h>
3095
3096 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
3097 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
3098
3099 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
3100 #if !wxUSE_DISPLAY
3101 #include <wx/dynarray.h>
3102 #include <wx/vidmode.h>
3103
3104 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
3105 #include "wx/arrimpl.cpp"
3106 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
3107 const wxVideoMode wxDefaultVideoMode;
3108
3109 class wxDisplay
3110 {
3111 public:
3112 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
3113 ~wxDisplay() {}
3114
3115 static size_t GetCount()
3116 { wxPyRaiseNotImplemented(); return 0; }
3117
3118 static int GetFromPoint(const wxPoint& pt)
3119 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
3120 static int GetFromWindow(wxWindow *window)
3121 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
3122
3123 virtual bool IsOk() const { return false; }
3124 virtual wxRect GetGeometry() const { wxRect r; return r; }
3125 virtual wxString GetName() const { return wxEmptyString; }
3126 bool IsPrimary() const { return false; }
3127
3128 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
3129 { wxArrayVideoModes a; return a; }
3130
3131 virtual wxVideoMode GetCurrentMode() const
3132 { return wxDefaultVideoMode; }
3133
3134 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
3135 { return false; }
3136
3137 void ResetMode() {}
3138 };
3139 #endif
3140
3141 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
3142 PyObject* pyList = NULL;
3143 wxArrayVideoModes arr = self->GetModes(mode);
3144 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3145 pyList = PyList_New(0);
3146 for (int i=0; i < arr.GetCount(); i++) {
3147 wxVideoMode* m = new wxVideoMode(arr.Item(i));
3148 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
3149 PyList_Append(pyList, pyObj);
3150 Py_DECREF(pyObj);
3151 }
3152 wxPyEndBlockThreads(blocked);
3153 return pyList;
3154 }
3155
3156 #include <wx/stdpaths.h>
3157
3158 static wxStandardPaths *wxStandardPaths_Get(){
3159 return (wxStandardPaths*) &wxStandardPaths::Get();
3160 }
3161 #ifdef __cplusplus
3162 extern "C" {
3163 #endif
3164 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
3165 PyObject *resultobj = NULL;
3166 wxSystemColour arg1 ;
3167 wxColour result;
3168 PyObject * obj0 = 0 ;
3169 char *kwnames[] = {
3170 (char *) "index", NULL
3171 };
3172
3173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3174 {
3175 arg1 = static_cast<wxSystemColour >(SWIG_As_int(obj0));
3176 if (SWIG_arg_fail(1)) SWIG_fail;
3177 }
3178 {
3179 if (!wxPyCheckForApp()) SWIG_fail;
3180 PyThreadState* __tstate = wxPyBeginAllowThreads();
3181 result = wxSystemSettings::GetColour(arg1);
3182
3183 wxPyEndAllowThreads(__tstate);
3184 if (PyErr_Occurred()) SWIG_fail;
3185 }
3186 {
3187 wxColour * resultptr;
3188 resultptr = new wxColour(static_cast<wxColour & >(result));
3189 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3190 }
3191 return resultobj;
3192 fail:
3193 return NULL;
3194 }
3195
3196
3197 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3198 PyObject *resultobj = NULL;
3199 wxSystemFont arg1 ;
3200 wxFont result;
3201 PyObject * obj0 = 0 ;
3202 char *kwnames[] = {
3203 (char *) "index", NULL
3204 };
3205
3206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3207 {
3208 arg1 = static_cast<wxSystemFont >(SWIG_As_int(obj0));
3209 if (SWIG_arg_fail(1)) SWIG_fail;
3210 }
3211 {
3212 if (!wxPyCheckForApp()) SWIG_fail;
3213 PyThreadState* __tstate = wxPyBeginAllowThreads();
3214 result = wxSystemSettings::GetFont(arg1);
3215
3216 wxPyEndAllowThreads(__tstate);
3217 if (PyErr_Occurred()) SWIG_fail;
3218 }
3219 {
3220 wxFont * resultptr;
3221 resultptr = new wxFont(static_cast<wxFont & >(result));
3222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3223 }
3224 return resultobj;
3225 fail:
3226 return NULL;
3227 }
3228
3229
3230 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3231 PyObject *resultobj = NULL;
3232 wxSystemMetric arg1 ;
3233 wxWindow *arg2 = (wxWindow *) NULL ;
3234 int result;
3235 PyObject * obj0 = 0 ;
3236 PyObject * obj1 = 0 ;
3237 char *kwnames[] = {
3238 (char *) "index",(char *) "win", NULL
3239 };
3240
3241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) goto fail;
3242 {
3243 arg1 = static_cast<wxSystemMetric >(SWIG_As_int(obj0));
3244 if (SWIG_arg_fail(1)) SWIG_fail;
3245 }
3246 if (obj1) {
3247 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
3248 if (SWIG_arg_fail(2)) SWIG_fail;
3249 }
3250 {
3251 if (!wxPyCheckForApp()) SWIG_fail;
3252 PyThreadState* __tstate = wxPyBeginAllowThreads();
3253 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
3254
3255 wxPyEndAllowThreads(__tstate);
3256 if (PyErr_Occurred()) SWIG_fail;
3257 }
3258 {
3259 resultobj = SWIG_From_int(static_cast<int >(result));
3260 }
3261 return resultobj;
3262 fail:
3263 return NULL;
3264 }
3265
3266
3267 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3268 PyObject *resultobj = NULL;
3269 wxSystemFeature arg1 ;
3270 bool result;
3271 PyObject * obj0 = 0 ;
3272 char *kwnames[] = {
3273 (char *) "index", NULL
3274 };
3275
3276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3277 {
3278 arg1 = static_cast<wxSystemFeature >(SWIG_As_int(obj0));
3279 if (SWIG_arg_fail(1)) SWIG_fail;
3280 }
3281 {
3282 if (!wxPyCheckForApp()) SWIG_fail;
3283 PyThreadState* __tstate = wxPyBeginAllowThreads();
3284 result = (bool)wxSystemSettings::HasFeature(arg1);
3285
3286 wxPyEndAllowThreads(__tstate);
3287 if (PyErr_Occurred()) SWIG_fail;
3288 }
3289 {
3290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3291 }
3292 return resultobj;
3293 fail:
3294 return NULL;
3295 }
3296
3297
3298 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3299 PyObject *resultobj = NULL;
3300 wxSystemScreenType result;
3301 char *kwnames[] = {
3302 NULL
3303 };
3304
3305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3306 {
3307 if (!wxPyCheckForApp()) SWIG_fail;
3308 PyThreadState* __tstate = wxPyBeginAllowThreads();
3309 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3310
3311 wxPyEndAllowThreads(__tstate);
3312 if (PyErr_Occurred()) SWIG_fail;
3313 }
3314 resultobj = SWIG_From_int((result));
3315 return resultobj;
3316 fail:
3317 return NULL;
3318 }
3319
3320
3321 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3322 PyObject *resultobj = NULL;
3323 wxSystemScreenType arg1 ;
3324 PyObject * obj0 = 0 ;
3325 char *kwnames[] = {
3326 (char *) "screen", NULL
3327 };
3328
3329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3330 {
3331 arg1 = static_cast<wxSystemScreenType >(SWIG_As_int(obj0));
3332 if (SWIG_arg_fail(1)) SWIG_fail;
3333 }
3334 {
3335 if (!wxPyCheckForApp()) SWIG_fail;
3336 PyThreadState* __tstate = wxPyBeginAllowThreads();
3337 wxSystemSettings::SetScreenType(arg1);
3338
3339 wxPyEndAllowThreads(__tstate);
3340 if (PyErr_Occurred()) SWIG_fail;
3341 }
3342 Py_INCREF(Py_None); resultobj = Py_None;
3343 return resultobj;
3344 fail:
3345 return NULL;
3346 }
3347
3348
3349 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3350 PyObject *obj;
3351 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3352 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3353 Py_INCREF(obj);
3354 return Py_BuildValue((char *)"");
3355 }
3356 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3357 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3358 return 1;
3359 }
3360
3361
3362 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3363 PyObject *pyobj = NULL;
3364
3365 {
3366 #if wxUSE_UNICODE
3367 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3368 #else
3369 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3370 #endif
3371 }
3372 return pyobj;
3373 }
3374
3375
3376 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3377 PyObject *resultobj = NULL;
3378 wxSystemOptions *result;
3379 char *kwnames[] = {
3380 NULL
3381 };
3382
3383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3384 {
3385 PyThreadState* __tstate = wxPyBeginAllowThreads();
3386 result = (wxSystemOptions *)new wxSystemOptions();
3387
3388 wxPyEndAllowThreads(__tstate);
3389 if (PyErr_Occurred()) SWIG_fail;
3390 }
3391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3392 return resultobj;
3393 fail:
3394 return NULL;
3395 }
3396
3397
3398 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3399 PyObject *resultobj = NULL;
3400 wxString *arg1 = 0 ;
3401 wxString *arg2 = 0 ;
3402 bool temp1 = false ;
3403 bool temp2 = false ;
3404 PyObject * obj0 = 0 ;
3405 PyObject * obj1 = 0 ;
3406 char *kwnames[] = {
3407 (char *) "name",(char *) "value", NULL
3408 };
3409
3410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3411 {
3412 arg1 = wxString_in_helper(obj0);
3413 if (arg1 == NULL) SWIG_fail;
3414 temp1 = true;
3415 }
3416 {
3417 arg2 = wxString_in_helper(obj1);
3418 if (arg2 == NULL) SWIG_fail;
3419 temp2 = true;
3420 }
3421 {
3422 PyThreadState* __tstate = wxPyBeginAllowThreads();
3423 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3424
3425 wxPyEndAllowThreads(__tstate);
3426 if (PyErr_Occurred()) SWIG_fail;
3427 }
3428 Py_INCREF(Py_None); resultobj = Py_None;
3429 {
3430 if (temp1)
3431 delete arg1;
3432 }
3433 {
3434 if (temp2)
3435 delete arg2;
3436 }
3437 return resultobj;
3438 fail:
3439 {
3440 if (temp1)
3441 delete arg1;
3442 }
3443 {
3444 if (temp2)
3445 delete arg2;
3446 }
3447 return NULL;
3448 }
3449
3450
3451 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3452 PyObject *resultobj = NULL;
3453 wxString *arg1 = 0 ;
3454 int arg2 ;
3455 bool temp1 = false ;
3456 PyObject * obj0 = 0 ;
3457 PyObject * obj1 = 0 ;
3458 char *kwnames[] = {
3459 (char *) "name",(char *) "value", NULL
3460 };
3461
3462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3463 {
3464 arg1 = wxString_in_helper(obj0);
3465 if (arg1 == NULL) SWIG_fail;
3466 temp1 = true;
3467 }
3468 {
3469 arg2 = static_cast<int >(SWIG_As_int(obj1));
3470 if (SWIG_arg_fail(2)) SWIG_fail;
3471 }
3472 {
3473 PyThreadState* __tstate = wxPyBeginAllowThreads();
3474 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3475
3476 wxPyEndAllowThreads(__tstate);
3477 if (PyErr_Occurred()) SWIG_fail;
3478 }
3479 Py_INCREF(Py_None); resultobj = Py_None;
3480 {
3481 if (temp1)
3482 delete arg1;
3483 }
3484 return resultobj;
3485 fail:
3486 {
3487 if (temp1)
3488 delete arg1;
3489 }
3490 return NULL;
3491 }
3492
3493
3494 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3495 PyObject *resultobj = NULL;
3496 wxString *arg1 = 0 ;
3497 wxString result;
3498 bool temp1 = false ;
3499 PyObject * obj0 = 0 ;
3500 char *kwnames[] = {
3501 (char *) "name", NULL
3502 };
3503
3504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3505 {
3506 arg1 = wxString_in_helper(obj0);
3507 if (arg1 == NULL) SWIG_fail;
3508 temp1 = true;
3509 }
3510 {
3511 PyThreadState* __tstate = wxPyBeginAllowThreads();
3512 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3513
3514 wxPyEndAllowThreads(__tstate);
3515 if (PyErr_Occurred()) SWIG_fail;
3516 }
3517 {
3518 #if wxUSE_UNICODE
3519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3520 #else
3521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3522 #endif
3523 }
3524 {
3525 if (temp1)
3526 delete arg1;
3527 }
3528 return resultobj;
3529 fail:
3530 {
3531 if (temp1)
3532 delete arg1;
3533 }
3534 return NULL;
3535 }
3536
3537
3538 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3539 PyObject *resultobj = NULL;
3540 wxString *arg1 = 0 ;
3541 int result;
3542 bool temp1 = false ;
3543 PyObject * obj0 = 0 ;
3544 char *kwnames[] = {
3545 (char *) "name", NULL
3546 };
3547
3548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3549 {
3550 arg1 = wxString_in_helper(obj0);
3551 if (arg1 == NULL) SWIG_fail;
3552 temp1 = true;
3553 }
3554 {
3555 PyThreadState* __tstate = wxPyBeginAllowThreads();
3556 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3557
3558 wxPyEndAllowThreads(__tstate);
3559 if (PyErr_Occurred()) SWIG_fail;
3560 }
3561 {
3562 resultobj = SWIG_From_int(static_cast<int >(result));
3563 }
3564 {
3565 if (temp1)
3566 delete arg1;
3567 }
3568 return resultobj;
3569 fail:
3570 {
3571 if (temp1)
3572 delete arg1;
3573 }
3574 return NULL;
3575 }
3576
3577
3578 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3579 PyObject *resultobj = NULL;
3580 wxString *arg1 = 0 ;
3581 bool result;
3582 bool temp1 = false ;
3583 PyObject * obj0 = 0 ;
3584 char *kwnames[] = {
3585 (char *) "name", NULL
3586 };
3587
3588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3589 {
3590 arg1 = wxString_in_helper(obj0);
3591 if (arg1 == NULL) SWIG_fail;
3592 temp1 = true;
3593 }
3594 {
3595 PyThreadState* __tstate = wxPyBeginAllowThreads();
3596 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3597
3598 wxPyEndAllowThreads(__tstate);
3599 if (PyErr_Occurred()) SWIG_fail;
3600 }
3601 {
3602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3603 }
3604 {
3605 if (temp1)
3606 delete arg1;
3607 }
3608 return resultobj;
3609 fail:
3610 {
3611 if (temp1)
3612 delete arg1;
3613 }
3614 return NULL;
3615 }
3616
3617
3618 static PyObject *_wrap_SystemOptions_IsFalse(PyObject *, PyObject *args, PyObject *kwargs) {
3619 PyObject *resultobj = NULL;
3620 wxString *arg1 = 0 ;
3621 bool result;
3622 bool temp1 = false ;
3623 PyObject * obj0 = 0 ;
3624 char *kwnames[] = {
3625 (char *) "name", NULL
3626 };
3627
3628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) goto fail;
3629 {
3630 arg1 = wxString_in_helper(obj0);
3631 if (arg1 == NULL) SWIG_fail;
3632 temp1 = true;
3633 }
3634 {
3635 PyThreadState* __tstate = wxPyBeginAllowThreads();
3636 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
3637
3638 wxPyEndAllowThreads(__tstate);
3639 if (PyErr_Occurred()) SWIG_fail;
3640 }
3641 {
3642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3643 }
3644 {
3645 if (temp1)
3646 delete arg1;
3647 }
3648 return resultobj;
3649 fail:
3650 {
3651 if (temp1)
3652 delete arg1;
3653 }
3654 return NULL;
3655 }
3656
3657
3658 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3659 PyObject *obj;
3660 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3661 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3662 Py_INCREF(obj);
3663 return Py_BuildValue((char *)"");
3664 }
3665 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3666 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3667 return 1;
3668 }
3669
3670
3671 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3672 PyObject *pyobj = NULL;
3673
3674 {
3675 #if wxUSE_UNICODE
3676 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3677 #else
3678 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3679 #endif
3680 }
3681 return pyobj;
3682 }
3683
3684
3685 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3686 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3687 return 1;
3688 }
3689
3690
3691 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3692 PyObject *pyobj = NULL;
3693
3694 {
3695 #if wxUSE_UNICODE
3696 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3697 #else
3698 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3699 #endif
3700 }
3701 return pyobj;
3702 }
3703
3704
3705 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3706 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3707 return 1;
3708 }
3709
3710
3711 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3712 PyObject *pyobj = NULL;
3713
3714 {
3715 #if wxUSE_UNICODE
3716 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3717 #else
3718 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3719 #endif
3720 }
3721 return pyobj;
3722 }
3723
3724
3725 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3726 PyObject *resultobj = NULL;
3727 long result;
3728 char *kwnames[] = {
3729 NULL
3730 };
3731
3732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3733 {
3734 PyThreadState* __tstate = wxPyBeginAllowThreads();
3735 result = (long)wxNewId();
3736
3737 wxPyEndAllowThreads(__tstate);
3738 if (PyErr_Occurred()) SWIG_fail;
3739 }
3740 {
3741 resultobj = SWIG_From_long(static_cast<long >(result));
3742 }
3743 return resultobj;
3744 fail:
3745 return NULL;
3746 }
3747
3748
3749 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3750 PyObject *resultobj = NULL;
3751 long arg1 ;
3752 PyObject * obj0 = 0 ;
3753 char *kwnames[] = {
3754 (char *) "id", NULL
3755 };
3756
3757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3758 {
3759 arg1 = static_cast<long >(SWIG_As_long(obj0));
3760 if (SWIG_arg_fail(1)) SWIG_fail;
3761 }
3762 {
3763 PyThreadState* __tstate = wxPyBeginAllowThreads();
3764 wxRegisterId(arg1);
3765
3766 wxPyEndAllowThreads(__tstate);
3767 if (PyErr_Occurred()) SWIG_fail;
3768 }
3769 Py_INCREF(Py_None); resultobj = Py_None;
3770 return resultobj;
3771 fail:
3772 return NULL;
3773 }
3774
3775
3776 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3777 PyObject *resultobj = NULL;
3778 long result;
3779 char *kwnames[] = {
3780 NULL
3781 };
3782
3783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3784 {
3785 PyThreadState* __tstate = wxPyBeginAllowThreads();
3786 result = (long)wxGetCurrentId();
3787
3788 wxPyEndAllowThreads(__tstate);
3789 if (PyErr_Occurred()) SWIG_fail;
3790 }
3791 {
3792 resultobj = SWIG_From_long(static_cast<long >(result));
3793 }
3794 return resultobj;
3795 fail:
3796 return NULL;
3797 }
3798
3799
3800 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3801 PyObject *resultobj = NULL;
3802 int arg1 ;
3803 bool result;
3804 PyObject * obj0 = 0 ;
3805 char *kwnames[] = {
3806 (char *) "id", NULL
3807 };
3808
3809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3810 {
3811 arg1 = static_cast<int >(SWIG_As_int(obj0));
3812 if (SWIG_arg_fail(1)) SWIG_fail;
3813 }
3814 {
3815 PyThreadState* __tstate = wxPyBeginAllowThreads();
3816 result = (bool)wxIsStockID(arg1);
3817
3818 wxPyEndAllowThreads(__tstate);
3819 if (PyErr_Occurred()) SWIG_fail;
3820 }
3821 {
3822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3823 }
3824 return resultobj;
3825 fail:
3826 return NULL;
3827 }
3828
3829
3830 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3831 PyObject *resultobj = NULL;
3832 int arg1 ;
3833 wxString *arg2 = 0 ;
3834 bool result;
3835 bool temp2 = false ;
3836 PyObject * obj0 = 0 ;
3837 PyObject * obj1 = 0 ;
3838 char *kwnames[] = {
3839 (char *) "id",(char *) "label", NULL
3840 };
3841
3842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3843 {
3844 arg1 = static_cast<int >(SWIG_As_int(obj0));
3845 if (SWIG_arg_fail(1)) SWIG_fail;
3846 }
3847 {
3848 arg2 = wxString_in_helper(obj1);
3849 if (arg2 == NULL) SWIG_fail;
3850 temp2 = true;
3851 }
3852 {
3853 PyThreadState* __tstate = wxPyBeginAllowThreads();
3854 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3855
3856 wxPyEndAllowThreads(__tstate);
3857 if (PyErr_Occurred()) SWIG_fail;
3858 }
3859 {
3860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3861 }
3862 {
3863 if (temp2)
3864 delete arg2;
3865 }
3866 return resultobj;
3867 fail:
3868 {
3869 if (temp2)
3870 delete arg2;
3871 }
3872 return NULL;
3873 }
3874
3875
3876 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3877 PyObject *resultobj = NULL;
3878 int arg1 ;
3879 bool arg2 = (bool) true ;
3880 wxString arg3 = (wxString) wxPyEmptyString ;
3881 wxString result;
3882 PyObject * obj0 = 0 ;
3883 PyObject * obj1 = 0 ;
3884 PyObject * obj2 = 0 ;
3885 char *kwnames[] = {
3886 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3887 };
3888
3889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3890 {
3891 arg1 = static_cast<int >(SWIG_As_int(obj0));
3892 if (SWIG_arg_fail(1)) SWIG_fail;
3893 }
3894 if (obj1) {
3895 {
3896 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
3897 if (SWIG_arg_fail(2)) SWIG_fail;
3898 }
3899 }
3900 if (obj2) {
3901 {
3902 wxString* sptr = wxString_in_helper(obj2);
3903 if (sptr == NULL) SWIG_fail;
3904 arg3 = *sptr;
3905 delete sptr;
3906 }
3907 }
3908 {
3909 PyThreadState* __tstate = wxPyBeginAllowThreads();
3910 result = wxGetStockLabel(arg1,arg2,arg3);
3911
3912 wxPyEndAllowThreads(__tstate);
3913 if (PyErr_Occurred()) SWIG_fail;
3914 }
3915 {
3916 #if wxUSE_UNICODE
3917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3918 #else
3919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3920 #endif
3921 }
3922 return resultobj;
3923 fail:
3924 return NULL;
3925 }
3926
3927
3928 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3929 PyObject *resultobj = NULL;
3930 char *kwnames[] = {
3931 NULL
3932 };
3933
3934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3935 {
3936 if (!wxPyCheckForApp()) SWIG_fail;
3937 PyThreadState* __tstate = wxPyBeginAllowThreads();
3938 wxBell();
3939
3940 wxPyEndAllowThreads(__tstate);
3941 if (PyErr_Occurred()) SWIG_fail;
3942 }
3943 Py_INCREF(Py_None); resultobj = Py_None;
3944 return resultobj;
3945 fail:
3946 return NULL;
3947 }
3948
3949
3950 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3951 PyObject *resultobj = NULL;
3952 char *kwnames[] = {
3953 NULL
3954 };
3955
3956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3957 {
3958 if (!wxPyCheckForApp()) SWIG_fail;
3959 PyThreadState* __tstate = wxPyBeginAllowThreads();
3960 wxEndBusyCursor();
3961
3962 wxPyEndAllowThreads(__tstate);
3963 if (PyErr_Occurred()) SWIG_fail;
3964 }
3965 Py_INCREF(Py_None); resultobj = Py_None;
3966 return resultobj;
3967 fail:
3968 return NULL;
3969 }
3970
3971
3972 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3973 PyObject *resultobj = NULL;
3974 bool arg1 = (bool) true ;
3975 long result;
3976 PyObject * obj0 = 0 ;
3977 char *kwnames[] = {
3978 (char *) "resetTimer", NULL
3979 };
3980
3981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3982 if (obj0) {
3983 {
3984 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
3985 if (SWIG_arg_fail(1)) SWIG_fail;
3986 }
3987 }
3988 {
3989 PyThreadState* __tstate = wxPyBeginAllowThreads();
3990 result = (long)wxGetElapsedTime(arg1);
3991
3992 wxPyEndAllowThreads(__tstate);
3993 if (PyErr_Occurred()) SWIG_fail;
3994 }
3995 {
3996 resultobj = SWIG_From_long(static_cast<long >(result));
3997 }
3998 return resultobj;
3999 fail:
4000 return NULL;
4001 }
4002
4003
4004 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
4005 PyObject *resultobj = NULL;
4006 bool result;
4007 char *kwnames[] = {
4008 NULL
4009 };
4010
4011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
4012 {
4013 PyThreadState* __tstate = wxPyBeginAllowThreads();
4014 result = (bool)wxIsBusy();
4015
4016 wxPyEndAllowThreads(__tstate);
4017 if (PyErr_Occurred()) SWIG_fail;
4018 }
4019 {
4020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4021 }
4022 return resultobj;
4023 fail:
4024 return NULL;
4025 }
4026
4027
4028 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
4029 PyObject *resultobj = NULL;
4030 wxString result;
4031 char *kwnames[] = {
4032 NULL
4033 };
4034
4035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
4036 {
4037 PyThreadState* __tstate = wxPyBeginAllowThreads();
4038 result = wxNow();
4039
4040 wxPyEndAllowThreads(__tstate);
4041 if (PyErr_Occurred()) SWIG_fail;
4042 }
4043 {
4044 #if wxUSE_UNICODE
4045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4046 #else
4047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4048 #endif
4049 }
4050 return resultobj;
4051 fail:
4052 return NULL;
4053 }
4054
4055
4056 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
4057 PyObject *resultobj = NULL;
4058 wxString const &arg1_defvalue = wxPyEmptyString ;
4059 wxString *arg1 = (wxString *) &arg1_defvalue ;
4060 bool result;
4061 bool temp1 = false ;
4062 PyObject * obj0 = 0 ;
4063 char *kwnames[] = {
4064 (char *) "command", NULL
4065 };
4066
4067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
4068 if (obj0) {
4069 {
4070 arg1 = wxString_in_helper(obj0);
4071 if (arg1 == NULL) SWIG_fail;
4072 temp1 = true;
4073 }
4074 }
4075 {
4076 PyThreadState* __tstate = wxPyBeginAllowThreads();
4077 result = (bool)wxShell((wxString const &)*arg1);
4078
4079 wxPyEndAllowThreads(__tstate);
4080 if (PyErr_Occurred()) SWIG_fail;
4081 }
4082 {
4083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4084 }
4085 {
4086 if (temp1)
4087 delete arg1;
4088 }
4089 return resultobj;
4090 fail:
4091 {
4092 if (temp1)
4093 delete arg1;
4094 }
4095 return NULL;
4096 }
4097
4098
4099 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
4100 PyObject *resultobj = NULL;
4101 char *kwnames[] = {
4102 NULL
4103 };
4104
4105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
4106 {
4107 PyThreadState* __tstate = wxPyBeginAllowThreads();
4108 wxStartTimer();
4109
4110 wxPyEndAllowThreads(__tstate);
4111 if (PyErr_Occurred()) SWIG_fail;
4112 }
4113 Py_INCREF(Py_None); resultobj = Py_None;
4114 return resultobj;
4115 fail:
4116 return NULL;
4117 }
4118
4119
4120 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
4121 PyObject *resultobj = NULL;
4122 int *arg1 = (int *) 0 ;
4123 int *arg2 = (int *) 0 ;
4124 int result;
4125 int temp1 ;
4126 int res1 = 0 ;
4127 int temp2 ;
4128 int res2 = 0 ;
4129 char *kwnames[] = {
4130 NULL
4131 };
4132
4133 arg1 = &temp1; res1 = SWIG_NEWOBJ;
4134 arg2 = &temp2; res2 = SWIG_NEWOBJ;
4135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
4136 {
4137 PyThreadState* __tstate = wxPyBeginAllowThreads();
4138 result = (int)wxGetOsVersion(arg1,arg2);
4139
4140 wxPyEndAllowThreads(__tstate);
4141 if (PyErr_Occurred()) SWIG_fail;
4142 }
4143 {
4144 resultobj = SWIG_From_int(static_cast<int >(result));
4145 }
4146 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
4147 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
4148 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
4149 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
4150 return resultobj;
4151 fail:
4152 return NULL;
4153 }
4154
4155
4156 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
4157 PyObject *resultobj = NULL;
4158 wxString result;
4159 char *kwnames[] = {
4160 NULL
4161 };
4162
4163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
4164 {
4165 PyThreadState* __tstate = wxPyBeginAllowThreads();
4166 result = wxGetOsDescription();
4167
4168 wxPyEndAllowThreads(__tstate);
4169 if (PyErr_Occurred()) SWIG_fail;
4170 }
4171 {
4172 #if wxUSE_UNICODE
4173 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4174 #else
4175 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4176 #endif
4177 }
4178 return resultobj;
4179 fail:
4180 return NULL;
4181 }
4182
4183
4184 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4185 PyObject *resultobj = NULL;
4186 wxMemorySize result;
4187 char *kwnames[] = {
4188 NULL
4189 };
4190
4191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4192 {
4193 PyThreadState* __tstate = wxPyBeginAllowThreads();
4194 result = wxGetFreeMemory();
4195
4196 wxPyEndAllowThreads(__tstate);
4197 if (PyErr_Occurred()) SWIG_fail;
4198 }
4199 {
4200 wxMemorySize * resultptr;
4201 resultptr = new wxMemorySize(static_cast<wxMemorySize & >(result));
4202 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMemorySize, 1);
4203 }
4204 return resultobj;
4205 fail:
4206 return NULL;
4207 }
4208
4209
4210 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4211 PyObject *resultobj = NULL;
4212 wxShutdownFlags arg1 ;
4213 bool result;
4214 PyObject * obj0 = 0 ;
4215 char *kwnames[] = {
4216 (char *) "wFlags", NULL
4217 };
4218
4219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4220 {
4221 arg1 = static_cast<wxShutdownFlags >(SWIG_As_int(obj0));
4222 if (SWIG_arg_fail(1)) SWIG_fail;
4223 }
4224 {
4225 if (!wxPyCheckForApp()) SWIG_fail;
4226 PyThreadState* __tstate = wxPyBeginAllowThreads();
4227 result = (bool)wxShutdown(arg1);
4228
4229 wxPyEndAllowThreads(__tstate);
4230 if (PyErr_Occurred()) SWIG_fail;
4231 }
4232 {
4233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4234 }
4235 return resultobj;
4236 fail:
4237 return NULL;
4238 }
4239
4240
4241 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4242 PyObject *resultobj = NULL;
4243 int arg1 ;
4244 PyObject * obj0 = 0 ;
4245 char *kwnames[] = {
4246 (char *) "secs", NULL
4247 };
4248
4249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4250 {
4251 arg1 = static_cast<int >(SWIG_As_int(obj0));
4252 if (SWIG_arg_fail(1)) SWIG_fail;
4253 }
4254 {
4255 PyThreadState* __tstate = wxPyBeginAllowThreads();
4256 wxSleep(arg1);
4257
4258 wxPyEndAllowThreads(__tstate);
4259 if (PyErr_Occurred()) SWIG_fail;
4260 }
4261 Py_INCREF(Py_None); resultobj = Py_None;
4262 return resultobj;
4263 fail:
4264 return NULL;
4265 }
4266
4267
4268 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4269 PyObject *resultobj = NULL;
4270 unsigned long arg1 ;
4271 PyObject * obj0 = 0 ;
4272 char *kwnames[] = {
4273 (char *) "milliseconds", NULL
4274 };
4275
4276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4277 {
4278 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
4279 if (SWIG_arg_fail(1)) SWIG_fail;
4280 }
4281 {
4282 PyThreadState* __tstate = wxPyBeginAllowThreads();
4283 wxMilliSleep(arg1);
4284
4285 wxPyEndAllowThreads(__tstate);
4286 if (PyErr_Occurred()) SWIG_fail;
4287 }
4288 Py_INCREF(Py_None); resultobj = Py_None;
4289 return resultobj;
4290 fail:
4291 return NULL;
4292 }
4293
4294
4295 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4296 PyObject *resultobj = NULL;
4297 unsigned long arg1 ;
4298 PyObject * obj0 = 0 ;
4299 char *kwnames[] = {
4300 (char *) "microseconds", NULL
4301 };
4302
4303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4304 {
4305 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
4306 if (SWIG_arg_fail(1)) SWIG_fail;
4307 }
4308 {
4309 PyThreadState* __tstate = wxPyBeginAllowThreads();
4310 wxMicroSleep(arg1);
4311
4312 wxPyEndAllowThreads(__tstate);
4313 if (PyErr_Occurred()) SWIG_fail;
4314 }
4315 Py_INCREF(Py_None); resultobj = Py_None;
4316 return resultobj;
4317 fail:
4318 return NULL;
4319 }
4320
4321
4322 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4323 PyObject *resultobj = NULL;
4324 bool arg1 ;
4325 PyObject * obj0 = 0 ;
4326 char *kwnames[] = {
4327 (char *) "enable", NULL
4328 };
4329
4330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4331 {
4332 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
4333 if (SWIG_arg_fail(1)) SWIG_fail;
4334 }
4335 {
4336 PyThreadState* __tstate = wxPyBeginAllowThreads();
4337 wxEnableTopLevelWindows(arg1);
4338
4339 wxPyEndAllowThreads(__tstate);
4340 if (PyErr_Occurred()) SWIG_fail;
4341 }
4342 Py_INCREF(Py_None); resultobj = Py_None;
4343 return resultobj;
4344 fail:
4345 return NULL;
4346 }
4347
4348
4349 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4350 PyObject *resultobj = NULL;
4351 wxString *arg1 = 0 ;
4352 wxString result;
4353 bool temp1 = false ;
4354 PyObject * obj0 = 0 ;
4355 char *kwnames[] = {
4356 (char *) "in", NULL
4357 };
4358
4359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4360 {
4361 arg1 = wxString_in_helper(obj0);
4362 if (arg1 == NULL) SWIG_fail;
4363 temp1 = true;
4364 }
4365 {
4366 PyThreadState* __tstate = wxPyBeginAllowThreads();
4367 result = wxStripMenuCodes((wxString const &)*arg1);
4368
4369 wxPyEndAllowThreads(__tstate);
4370 if (PyErr_Occurred()) SWIG_fail;
4371 }
4372 {
4373 #if wxUSE_UNICODE
4374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4375 #else
4376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4377 #endif
4378 }
4379 {
4380 if (temp1)
4381 delete arg1;
4382 }
4383 return resultobj;
4384 fail:
4385 {
4386 if (temp1)
4387 delete arg1;
4388 }
4389 return NULL;
4390 }
4391
4392
4393 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4394 PyObject *resultobj = NULL;
4395 wxString result;
4396 char *kwnames[] = {
4397 NULL
4398 };
4399
4400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4401 {
4402 PyThreadState* __tstate = wxPyBeginAllowThreads();
4403 result = wxGetEmailAddress();
4404
4405 wxPyEndAllowThreads(__tstate);
4406 if (PyErr_Occurred()) SWIG_fail;
4407 }
4408 {
4409 #if wxUSE_UNICODE
4410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4411 #else
4412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4413 #endif
4414 }
4415 return resultobj;
4416 fail:
4417 return NULL;
4418 }
4419
4420
4421 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4422 PyObject *resultobj = NULL;
4423 wxString result;
4424 char *kwnames[] = {
4425 NULL
4426 };
4427
4428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4429 {
4430 PyThreadState* __tstate = wxPyBeginAllowThreads();
4431 result = wxGetHostName();
4432
4433 wxPyEndAllowThreads(__tstate);
4434 if (PyErr_Occurred()) SWIG_fail;
4435 }
4436 {
4437 #if wxUSE_UNICODE
4438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4439 #else
4440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4441 #endif
4442 }
4443 return resultobj;
4444 fail:
4445 return NULL;
4446 }
4447
4448
4449 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4450 PyObject *resultobj = NULL;
4451 wxString result;
4452 char *kwnames[] = {
4453 NULL
4454 };
4455
4456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4457 {
4458 PyThreadState* __tstate = wxPyBeginAllowThreads();
4459 result = wxGetFullHostName();
4460
4461 wxPyEndAllowThreads(__tstate);
4462 if (PyErr_Occurred()) SWIG_fail;
4463 }
4464 {
4465 #if wxUSE_UNICODE
4466 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4467 #else
4468 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4469 #endif
4470 }
4471 return resultobj;
4472 fail:
4473 return NULL;
4474 }
4475
4476
4477 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4478 PyObject *resultobj = NULL;
4479 wxString result;
4480 char *kwnames[] = {
4481 NULL
4482 };
4483
4484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4485 {
4486 PyThreadState* __tstate = wxPyBeginAllowThreads();
4487 result = wxGetUserId();
4488
4489 wxPyEndAllowThreads(__tstate);
4490 if (PyErr_Occurred()) SWIG_fail;
4491 }
4492 {
4493 #if wxUSE_UNICODE
4494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4495 #else
4496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4497 #endif
4498 }
4499 return resultobj;
4500 fail:
4501 return NULL;
4502 }
4503
4504
4505 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4506 PyObject *resultobj = NULL;
4507 wxString result;
4508 char *kwnames[] = {
4509 NULL
4510 };
4511
4512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4513 {
4514 PyThreadState* __tstate = wxPyBeginAllowThreads();
4515 result = wxGetUserName();
4516
4517 wxPyEndAllowThreads(__tstate);
4518 if (PyErr_Occurred()) SWIG_fail;
4519 }
4520 {
4521 #if wxUSE_UNICODE
4522 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4523 #else
4524 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4525 #endif
4526 }
4527 return resultobj;
4528 fail:
4529 return NULL;
4530 }
4531
4532
4533 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4534 PyObject *resultobj = NULL;
4535 wxString result;
4536 char *kwnames[] = {
4537 NULL
4538 };
4539
4540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4541 {
4542 PyThreadState* __tstate = wxPyBeginAllowThreads();
4543 result = wxGetHomeDir();
4544
4545 wxPyEndAllowThreads(__tstate);
4546 if (PyErr_Occurred()) SWIG_fail;
4547 }
4548 {
4549 #if wxUSE_UNICODE
4550 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4551 #else
4552 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4553 #endif
4554 }
4555 return resultobj;
4556 fail:
4557 return NULL;
4558 }
4559
4560
4561 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4562 PyObject *resultobj = NULL;
4563 wxString const &arg1_defvalue = wxPyEmptyString ;
4564 wxString *arg1 = (wxString *) &arg1_defvalue ;
4565 wxString result;
4566 bool temp1 = false ;
4567 PyObject * obj0 = 0 ;
4568 char *kwnames[] = {
4569 (char *) "user", NULL
4570 };
4571
4572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4573 if (obj0) {
4574 {
4575 arg1 = wxString_in_helper(obj0);
4576 if (arg1 == NULL) SWIG_fail;
4577 temp1 = true;
4578 }
4579 }
4580 {
4581 PyThreadState* __tstate = wxPyBeginAllowThreads();
4582 result = wxGetUserHome((wxString const &)*arg1);
4583
4584 wxPyEndAllowThreads(__tstate);
4585 if (PyErr_Occurred()) SWIG_fail;
4586 }
4587 {
4588 #if wxUSE_UNICODE
4589 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4590 #else
4591 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4592 #endif
4593 }
4594 {
4595 if (temp1)
4596 delete arg1;
4597 }
4598 return resultobj;
4599 fail:
4600 {
4601 if (temp1)
4602 delete arg1;
4603 }
4604 return NULL;
4605 }
4606
4607
4608 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4609 PyObject *resultobj = NULL;
4610 unsigned long result;
4611 char *kwnames[] = {
4612 NULL
4613 };
4614
4615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4616 {
4617 PyThreadState* __tstate = wxPyBeginAllowThreads();
4618 result = (unsigned long)wxGetProcessId();
4619
4620 wxPyEndAllowThreads(__tstate);
4621 if (PyErr_Occurred()) SWIG_fail;
4622 }
4623 {
4624 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
4625 }
4626 return resultobj;
4627 fail:
4628 return NULL;
4629 }
4630
4631
4632 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4633 PyObject *resultobj = NULL;
4634 char *kwnames[] = {
4635 NULL
4636 };
4637
4638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4639 {
4640 PyThreadState* __tstate = wxPyBeginAllowThreads();
4641 wxTrap();
4642
4643 wxPyEndAllowThreads(__tstate);
4644 if (PyErr_Occurred()) SWIG_fail;
4645 }
4646 Py_INCREF(Py_None); resultobj = Py_None;
4647 return resultobj;
4648 fail:
4649 return NULL;
4650 }
4651
4652
4653 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4654 PyObject *resultobj = NULL;
4655 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4656 wxString *arg1 = (wxString *) &arg1_defvalue ;
4657 wxString const &arg2_defvalue = wxPyEmptyString ;
4658 wxString *arg2 = (wxString *) &arg2_defvalue ;
4659 wxString const &arg3_defvalue = wxPyEmptyString ;
4660 wxString *arg3 = (wxString *) &arg3_defvalue ;
4661 wxString const &arg4_defvalue = wxPyEmptyString ;
4662 wxString *arg4 = (wxString *) &arg4_defvalue ;
4663 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4664 wxString *arg5 = (wxString *) &arg5_defvalue ;
4665 int arg6 = (int) 0 ;
4666 wxWindow *arg7 = (wxWindow *) NULL ;
4667 int arg8 = (int) -1 ;
4668 int arg9 = (int) -1 ;
4669 wxString result;
4670 bool temp1 = false ;
4671 bool temp2 = false ;
4672 bool temp3 = false ;
4673 bool temp4 = false ;
4674 bool temp5 = false ;
4675 PyObject * obj0 = 0 ;
4676 PyObject * obj1 = 0 ;
4677 PyObject * obj2 = 0 ;
4678 PyObject * obj3 = 0 ;
4679 PyObject * obj4 = 0 ;
4680 PyObject * obj5 = 0 ;
4681 PyObject * obj6 = 0 ;
4682 PyObject * obj7 = 0 ;
4683 PyObject * obj8 = 0 ;
4684 char *kwnames[] = {
4685 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4686 };
4687
4688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4689 if (obj0) {
4690 {
4691 arg1 = wxString_in_helper(obj0);
4692 if (arg1 == NULL) SWIG_fail;
4693 temp1 = true;
4694 }
4695 }
4696 if (obj1) {
4697 {
4698 arg2 = wxString_in_helper(obj1);
4699 if (arg2 == NULL) SWIG_fail;
4700 temp2 = true;
4701 }
4702 }
4703 if (obj2) {
4704 {
4705 arg3 = wxString_in_helper(obj2);
4706 if (arg3 == NULL) SWIG_fail;
4707 temp3 = true;
4708 }
4709 }
4710 if (obj3) {
4711 {
4712 arg4 = wxString_in_helper(obj3);
4713 if (arg4 == NULL) SWIG_fail;
4714 temp4 = true;
4715 }
4716 }
4717 if (obj4) {
4718 {
4719 arg5 = wxString_in_helper(obj4);
4720 if (arg5 == NULL) SWIG_fail;
4721 temp5 = true;
4722 }
4723 }
4724 if (obj5) {
4725 {
4726 arg6 = static_cast<int >(SWIG_As_int(obj5));
4727 if (SWIG_arg_fail(6)) SWIG_fail;
4728 }
4729 }
4730 if (obj6) {
4731 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4732 if (SWIG_arg_fail(7)) SWIG_fail;
4733 }
4734 if (obj7) {
4735 {
4736 arg8 = static_cast<int >(SWIG_As_int(obj7));
4737 if (SWIG_arg_fail(8)) SWIG_fail;
4738 }
4739 }
4740 if (obj8) {
4741 {
4742 arg9 = static_cast<int >(SWIG_As_int(obj8));
4743 if (SWIG_arg_fail(9)) SWIG_fail;
4744 }
4745 }
4746 {
4747 if (!wxPyCheckForApp()) SWIG_fail;
4748 PyThreadState* __tstate = wxPyBeginAllowThreads();
4749 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4750
4751 wxPyEndAllowThreads(__tstate);
4752 if (PyErr_Occurred()) SWIG_fail;
4753 }
4754 {
4755 #if wxUSE_UNICODE
4756 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4757 #else
4758 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4759 #endif
4760 }
4761 {
4762 if (temp1)
4763 delete arg1;
4764 }
4765 {
4766 if (temp2)
4767 delete arg2;
4768 }
4769 {
4770 if (temp3)
4771 delete arg3;
4772 }
4773 {
4774 if (temp4)
4775 delete arg4;
4776 }
4777 {
4778 if (temp5)
4779 delete arg5;
4780 }
4781 return resultobj;
4782 fail:
4783 {
4784 if (temp1)
4785 delete arg1;
4786 }
4787 {
4788 if (temp2)
4789 delete arg2;
4790 }
4791 {
4792 if (temp3)
4793 delete arg3;
4794 }
4795 {
4796 if (temp4)
4797 delete arg4;
4798 }
4799 {
4800 if (temp5)
4801 delete arg5;
4802 }
4803 return NULL;
4804 }
4805
4806
4807 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4808 PyObject *resultobj = NULL;
4809 wxString *arg1 = 0 ;
4810 wxString *arg2 = 0 ;
4811 wxString const &arg3_defvalue = wxPyEmptyString ;
4812 wxString *arg3 = (wxString *) &arg3_defvalue ;
4813 wxWindow *arg4 = (wxWindow *) NULL ;
4814 wxString result;
4815 bool temp1 = false ;
4816 bool temp2 = false ;
4817 bool temp3 = false ;
4818 PyObject * obj0 = 0 ;
4819 PyObject * obj1 = 0 ;
4820 PyObject * obj2 = 0 ;
4821 PyObject * obj3 = 0 ;
4822 char *kwnames[] = {
4823 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4824 };
4825
4826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4827 {
4828 arg1 = wxString_in_helper(obj0);
4829 if (arg1 == NULL) SWIG_fail;
4830 temp1 = true;
4831 }
4832 {
4833 arg2 = wxString_in_helper(obj1);
4834 if (arg2 == NULL) SWIG_fail;
4835 temp2 = true;
4836 }
4837 if (obj2) {
4838 {
4839 arg3 = wxString_in_helper(obj2);
4840 if (arg3 == NULL) SWIG_fail;
4841 temp3 = true;
4842 }
4843 }
4844 if (obj3) {
4845 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4846 if (SWIG_arg_fail(4)) SWIG_fail;
4847 }
4848 {
4849 if (!wxPyCheckForApp()) SWIG_fail;
4850 PyThreadState* __tstate = wxPyBeginAllowThreads();
4851 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4852
4853 wxPyEndAllowThreads(__tstate);
4854 if (PyErr_Occurred()) SWIG_fail;
4855 }
4856 {
4857 #if wxUSE_UNICODE
4858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4859 #else
4860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4861 #endif
4862 }
4863 {
4864 if (temp1)
4865 delete arg1;
4866 }
4867 {
4868 if (temp2)
4869 delete arg2;
4870 }
4871 {
4872 if (temp3)
4873 delete arg3;
4874 }
4875 return resultobj;
4876 fail:
4877 {
4878 if (temp1)
4879 delete arg1;
4880 }
4881 {
4882 if (temp2)
4883 delete arg2;
4884 }
4885 {
4886 if (temp3)
4887 delete arg3;
4888 }
4889 return NULL;
4890 }
4891
4892
4893 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4894 PyObject *resultobj = NULL;
4895 wxString *arg1 = 0 ;
4896 wxString *arg2 = 0 ;
4897 wxString const &arg3_defvalue = wxPyEmptyString ;
4898 wxString *arg3 = (wxString *) &arg3_defvalue ;
4899 wxWindow *arg4 = (wxWindow *) NULL ;
4900 wxString result;
4901 bool temp1 = false ;
4902 bool temp2 = false ;
4903 bool temp3 = false ;
4904 PyObject * obj0 = 0 ;
4905 PyObject * obj1 = 0 ;
4906 PyObject * obj2 = 0 ;
4907 PyObject * obj3 = 0 ;
4908 char *kwnames[] = {
4909 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4910 };
4911
4912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4913 {
4914 arg1 = wxString_in_helper(obj0);
4915 if (arg1 == NULL) SWIG_fail;
4916 temp1 = true;
4917 }
4918 {
4919 arg2 = wxString_in_helper(obj1);
4920 if (arg2 == NULL) SWIG_fail;
4921 temp2 = true;
4922 }
4923 if (obj2) {
4924 {
4925 arg3 = wxString_in_helper(obj2);
4926 if (arg3 == NULL) SWIG_fail;
4927 temp3 = true;
4928 }
4929 }
4930 if (obj3) {
4931 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4932 if (SWIG_arg_fail(4)) SWIG_fail;
4933 }
4934 {
4935 if (!wxPyCheckForApp()) SWIG_fail;
4936 PyThreadState* __tstate = wxPyBeginAllowThreads();
4937 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4938
4939 wxPyEndAllowThreads(__tstate);
4940 if (PyErr_Occurred()) SWIG_fail;
4941 }
4942 {
4943 #if wxUSE_UNICODE
4944 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4945 #else
4946 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4947 #endif
4948 }
4949 {
4950 if (temp1)
4951 delete arg1;
4952 }
4953 {
4954 if (temp2)
4955 delete arg2;
4956 }
4957 {
4958 if (temp3)
4959 delete arg3;
4960 }
4961 return resultobj;
4962 fail:
4963 {
4964 if (temp1)
4965 delete arg1;
4966 }
4967 {
4968 if (temp2)
4969 delete arg2;
4970 }
4971 {
4972 if (temp3)
4973 delete arg3;
4974 }
4975 return NULL;
4976 }
4977
4978
4979 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4980 PyObject *resultobj = NULL;
4981 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4982 wxString *arg1 = (wxString *) &arg1_defvalue ;
4983 wxString const &arg2_defvalue = wxPyEmptyString ;
4984 wxString *arg2 = (wxString *) &arg2_defvalue ;
4985 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4986 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4987 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4988 wxWindow *arg5 = (wxWindow *) NULL ;
4989 wxString result;
4990 bool temp1 = false ;
4991 bool temp2 = false ;
4992 wxPoint temp4 ;
4993 PyObject * obj0 = 0 ;
4994 PyObject * obj1 = 0 ;
4995 PyObject * obj2 = 0 ;
4996 PyObject * obj3 = 0 ;
4997 PyObject * obj4 = 0 ;
4998 char *kwnames[] = {
4999 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5000 };
5001
5002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
5003 if (obj0) {
5004 {
5005 arg1 = wxString_in_helper(obj0);
5006 if (arg1 == NULL) SWIG_fail;
5007 temp1 = true;
5008 }
5009 }
5010 if (obj1) {
5011 {
5012 arg2 = wxString_in_helper(obj1);
5013 if (arg2 == NULL) SWIG_fail;
5014 temp2 = true;
5015 }
5016 }
5017 if (obj2) {
5018 {
5019 arg3 = static_cast<long >(SWIG_As_long(obj2));
5020 if (SWIG_arg_fail(3)) SWIG_fail;
5021 }
5022 }
5023 if (obj3) {
5024 {
5025 arg4 = &temp4;
5026 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5027 }
5028 }
5029 if (obj4) {
5030 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5031 if (SWIG_arg_fail(5)) SWIG_fail;
5032 }
5033 {
5034 if (!wxPyCheckForApp()) SWIG_fail;
5035 PyThreadState* __tstate = wxPyBeginAllowThreads();
5036 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5037
5038 wxPyEndAllowThreads(__tstate);
5039 if (PyErr_Occurred()) SWIG_fail;
5040 }
5041 {
5042 #if wxUSE_UNICODE
5043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5044 #else
5045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5046 #endif
5047 }
5048 {
5049 if (temp1)
5050 delete arg1;
5051 }
5052 {
5053 if (temp2)
5054 delete arg2;
5055 }
5056 return resultobj;
5057 fail:
5058 {
5059 if (temp1)
5060 delete arg1;
5061 }
5062 {
5063 if (temp2)
5064 delete arg2;
5065 }
5066 return NULL;
5067 }
5068
5069
5070 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5071 PyObject *resultobj = NULL;
5072 wxString *arg1 = 0 ;
5073 wxString const &arg2_defvalue = wxPyEmptyString ;
5074 wxString *arg2 = (wxString *) &arg2_defvalue ;
5075 wxString const &arg3_defvalue = wxPyEmptyString ;
5076 wxString *arg3 = (wxString *) &arg3_defvalue ;
5077 wxWindow *arg4 = (wxWindow *) NULL ;
5078 int arg5 = (int) -1 ;
5079 int arg6 = (int) -1 ;
5080 bool arg7 = (bool) true ;
5081 wxString result;
5082 bool temp1 = false ;
5083 bool temp2 = false ;
5084 bool temp3 = false ;
5085 PyObject * obj0 = 0 ;
5086 PyObject * obj1 = 0 ;
5087 PyObject * obj2 = 0 ;
5088 PyObject * obj3 = 0 ;
5089 PyObject * obj4 = 0 ;
5090 PyObject * obj5 = 0 ;
5091 PyObject * obj6 = 0 ;
5092 char *kwnames[] = {
5093 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5094 };
5095
5096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
5097 {
5098 arg1 = wxString_in_helper(obj0);
5099 if (arg1 == NULL) SWIG_fail;
5100 temp1 = true;
5101 }
5102 if (obj1) {
5103 {
5104 arg2 = wxString_in_helper(obj1);
5105 if (arg2 == NULL) SWIG_fail;
5106 temp2 = true;
5107 }
5108 }
5109 if (obj2) {
5110 {
5111 arg3 = wxString_in_helper(obj2);
5112 if (arg3 == NULL) SWIG_fail;
5113 temp3 = true;
5114 }
5115 }
5116 if (obj3) {
5117 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5118 if (SWIG_arg_fail(4)) SWIG_fail;
5119 }
5120 if (obj4) {
5121 {
5122 arg5 = static_cast<int >(SWIG_As_int(obj4));
5123 if (SWIG_arg_fail(5)) SWIG_fail;
5124 }
5125 }
5126 if (obj5) {
5127 {
5128 arg6 = static_cast<int >(SWIG_As_int(obj5));
5129 if (SWIG_arg_fail(6)) SWIG_fail;
5130 }
5131 }
5132 if (obj6) {
5133 {
5134 arg7 = static_cast<bool >(SWIG_As_bool(obj6));
5135 if (SWIG_arg_fail(7)) SWIG_fail;
5136 }
5137 }
5138 {
5139 if (!wxPyCheckForApp()) SWIG_fail;
5140 PyThreadState* __tstate = wxPyBeginAllowThreads();
5141 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
5142
5143 wxPyEndAllowThreads(__tstate);
5144 if (PyErr_Occurred()) SWIG_fail;
5145 }
5146 {
5147 #if wxUSE_UNICODE
5148 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5149 #else
5150 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5151 #endif
5152 }
5153 {
5154 if (temp1)
5155 delete arg1;
5156 }
5157 {
5158 if (temp2)
5159 delete arg2;
5160 }
5161 {
5162 if (temp3)
5163 delete arg3;
5164 }
5165 return resultobj;
5166 fail:
5167 {
5168 if (temp1)
5169 delete arg1;
5170 }
5171 {
5172 if (temp2)
5173 delete arg2;
5174 }
5175 {
5176 if (temp3)
5177 delete arg3;
5178 }
5179 return NULL;
5180 }
5181
5182
5183 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5184 PyObject *resultobj = NULL;
5185 wxString *arg1 = 0 ;
5186 wxString const &arg2_defvalue = wxPyEmptyString ;
5187 wxString *arg2 = (wxString *) &arg2_defvalue ;
5188 wxString const &arg3_defvalue = wxPyEmptyString ;
5189 wxString *arg3 = (wxString *) &arg3_defvalue ;
5190 wxWindow *arg4 = (wxWindow *) NULL ;
5191 wxString result;
5192 bool temp1 = false ;
5193 bool temp2 = false ;
5194 bool temp3 = false ;
5195 PyObject * obj0 = 0 ;
5196 PyObject * obj1 = 0 ;
5197 PyObject * obj2 = 0 ;
5198 PyObject * obj3 = 0 ;
5199 char *kwnames[] = {
5200 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5201 };
5202
5203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5204 {
5205 arg1 = wxString_in_helper(obj0);
5206 if (arg1 == NULL) SWIG_fail;
5207 temp1 = true;
5208 }
5209 if (obj1) {
5210 {
5211 arg2 = wxString_in_helper(obj1);
5212 if (arg2 == NULL) SWIG_fail;
5213 temp2 = true;
5214 }
5215 }
5216 if (obj2) {
5217 {
5218 arg3 = wxString_in_helper(obj2);
5219 if (arg3 == NULL) SWIG_fail;
5220 temp3 = true;
5221 }
5222 }
5223 if (obj3) {
5224 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5225 if (SWIG_arg_fail(4)) SWIG_fail;
5226 }
5227 {
5228 if (!wxPyCheckForApp()) SWIG_fail;
5229 PyThreadState* __tstate = wxPyBeginAllowThreads();
5230 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5231
5232 wxPyEndAllowThreads(__tstate);
5233 if (PyErr_Occurred()) SWIG_fail;
5234 }
5235 {
5236 #if wxUSE_UNICODE
5237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5238 #else
5239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5240 #endif
5241 }
5242 {
5243 if (temp1)
5244 delete arg1;
5245 }
5246 {
5247 if (temp2)
5248 delete arg2;
5249 }
5250 {
5251 if (temp3)
5252 delete arg3;
5253 }
5254 return resultobj;
5255 fail:
5256 {
5257 if (temp1)
5258 delete arg1;
5259 }
5260 {
5261 if (temp2)
5262 delete arg2;
5263 }
5264 {
5265 if (temp3)
5266 delete arg3;
5267 }
5268 return NULL;
5269 }
5270
5271
5272 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5273 PyObject *resultobj = NULL;
5274 wxString *arg1 = 0 ;
5275 wxString *arg2 = 0 ;
5276 int arg3 ;
5277 wxString *arg4 = (wxString *) 0 ;
5278 wxWindow *arg5 = (wxWindow *) NULL ;
5279 int arg6 = (int) -1 ;
5280 int arg7 = (int) -1 ;
5281 bool arg8 = (bool) true ;
5282 int arg9 = (int) 150 ;
5283 int arg10 = (int) 200 ;
5284 wxString result;
5285 bool temp1 = false ;
5286 bool temp2 = false ;
5287 PyObject * obj0 = 0 ;
5288 PyObject * obj1 = 0 ;
5289 PyObject * obj2 = 0 ;
5290 PyObject * obj3 = 0 ;
5291 PyObject * obj4 = 0 ;
5292 PyObject * obj5 = 0 ;
5293 PyObject * obj6 = 0 ;
5294 PyObject * obj7 = 0 ;
5295 PyObject * obj8 = 0 ;
5296 char *kwnames[] = {
5297 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5298 };
5299
5300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5301 {
5302 arg1 = wxString_in_helper(obj0);
5303 if (arg1 == NULL) SWIG_fail;
5304 temp1 = true;
5305 }
5306 {
5307 arg2 = wxString_in_helper(obj1);
5308 if (arg2 == NULL) SWIG_fail;
5309 temp2 = true;
5310 }
5311 {
5312 arg3 = PyList_Size(obj2);
5313 arg4 = wxString_LIST_helper(obj2);
5314 if (arg4 == NULL) SWIG_fail;
5315 }
5316 if (obj3) {
5317 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5318 if (SWIG_arg_fail(5)) SWIG_fail;
5319 }
5320 if (obj4) {
5321 {
5322 arg6 = static_cast<int >(SWIG_As_int(obj4));
5323 if (SWIG_arg_fail(6)) SWIG_fail;
5324 }
5325 }
5326 if (obj5) {
5327 {
5328 arg7 = static_cast<int >(SWIG_As_int(obj5));
5329 if (SWIG_arg_fail(7)) SWIG_fail;
5330 }
5331 }
5332 if (obj6) {
5333 {
5334 arg8 = static_cast<bool >(SWIG_As_bool(obj6));
5335 if (SWIG_arg_fail(8)) SWIG_fail;
5336 }
5337 }
5338 if (obj7) {
5339 {
5340 arg9 = static_cast<int >(SWIG_As_int(obj7));
5341 if (SWIG_arg_fail(9)) SWIG_fail;
5342 }
5343 }
5344 if (obj8) {
5345 {
5346 arg10 = static_cast<int >(SWIG_As_int(obj8));
5347 if (SWIG_arg_fail(10)) SWIG_fail;
5348 }
5349 }
5350 {
5351 if (!wxPyCheckForApp()) SWIG_fail;
5352 PyThreadState* __tstate = wxPyBeginAllowThreads();
5353 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5354
5355 wxPyEndAllowThreads(__tstate);
5356 if (PyErr_Occurred()) SWIG_fail;
5357 }
5358 {
5359 #if wxUSE_UNICODE
5360 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5361 #else
5362 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5363 #endif
5364 }
5365 {
5366 if (temp1)
5367 delete arg1;
5368 }
5369 {
5370 if (temp2)
5371 delete arg2;
5372 }
5373 {
5374 if (arg4) delete [] arg4;
5375 }
5376 return resultobj;
5377 fail:
5378 {
5379 if (temp1)
5380 delete arg1;
5381 }
5382 {
5383 if (temp2)
5384 delete arg2;
5385 }
5386 {
5387 if (arg4) delete [] arg4;
5388 }
5389 return NULL;
5390 }
5391
5392
5393 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5394 PyObject *resultobj = NULL;
5395 wxString *arg1 = 0 ;
5396 wxString *arg2 = 0 ;
5397 int arg3 ;
5398 wxString *arg4 = (wxString *) 0 ;
5399 wxWindow *arg5 = (wxWindow *) NULL ;
5400 int arg6 = (int) -1 ;
5401 int arg7 = (int) -1 ;
5402 bool arg8 = (bool) true ;
5403 int arg9 = (int) 150 ;
5404 int arg10 = (int) 200 ;
5405 int result;
5406 bool temp1 = false ;
5407 bool temp2 = false ;
5408 PyObject * obj0 = 0 ;
5409 PyObject * obj1 = 0 ;
5410 PyObject * obj2 = 0 ;
5411 PyObject * obj3 = 0 ;
5412 PyObject * obj4 = 0 ;
5413 PyObject * obj5 = 0 ;
5414 PyObject * obj6 = 0 ;
5415 PyObject * obj7 = 0 ;
5416 PyObject * obj8 = 0 ;
5417 char *kwnames[] = {
5418 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5419 };
5420
5421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5422 {
5423 arg1 = wxString_in_helper(obj0);
5424 if (arg1 == NULL) SWIG_fail;
5425 temp1 = true;
5426 }
5427 {
5428 arg2 = wxString_in_helper(obj1);
5429 if (arg2 == NULL) SWIG_fail;
5430 temp2 = true;
5431 }
5432 {
5433 arg3 = PyList_Size(obj2);
5434 arg4 = wxString_LIST_helper(obj2);
5435 if (arg4 == NULL) SWIG_fail;
5436 }
5437 if (obj3) {
5438 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5439 if (SWIG_arg_fail(5)) SWIG_fail;
5440 }
5441 if (obj4) {
5442 {
5443 arg6 = static_cast<int >(SWIG_As_int(obj4));
5444 if (SWIG_arg_fail(6)) SWIG_fail;
5445 }
5446 }
5447 if (obj5) {
5448 {
5449 arg7 = static_cast<int >(SWIG_As_int(obj5));
5450 if (SWIG_arg_fail(7)) SWIG_fail;
5451 }
5452 }
5453 if (obj6) {
5454 {
5455 arg8 = static_cast<bool >(SWIG_As_bool(obj6));
5456 if (SWIG_arg_fail(8)) SWIG_fail;
5457 }
5458 }
5459 if (obj7) {
5460 {
5461 arg9 = static_cast<int >(SWIG_As_int(obj7));
5462 if (SWIG_arg_fail(9)) SWIG_fail;
5463 }
5464 }
5465 if (obj8) {
5466 {
5467 arg10 = static_cast<int >(SWIG_As_int(obj8));
5468 if (SWIG_arg_fail(10)) SWIG_fail;
5469 }
5470 }
5471 {
5472 if (!wxPyCheckForApp()) SWIG_fail;
5473 PyThreadState* __tstate = wxPyBeginAllowThreads();
5474 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5475
5476 wxPyEndAllowThreads(__tstate);
5477 if (PyErr_Occurred()) SWIG_fail;
5478 }
5479 {
5480 resultobj = SWIG_From_int(static_cast<int >(result));
5481 }
5482 {
5483 if (temp1)
5484 delete arg1;
5485 }
5486 {
5487 if (temp2)
5488 delete arg2;
5489 }
5490 {
5491 if (arg4) delete [] arg4;
5492 }
5493 return resultobj;
5494 fail:
5495 {
5496 if (temp1)
5497 delete arg1;
5498 }
5499 {
5500 if (temp2)
5501 delete arg2;
5502 }
5503 {
5504 if (arg4) delete [] arg4;
5505 }
5506 return NULL;
5507 }
5508
5509
5510 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5511 PyObject *resultobj = NULL;
5512 wxString *arg1 = 0 ;
5513 wxString const &arg2_defvalue = wxPyEmptyString ;
5514 wxString *arg2 = (wxString *) &arg2_defvalue ;
5515 int arg3 = (int) wxOK|wxCENTRE ;
5516 wxWindow *arg4 = (wxWindow *) NULL ;
5517 int arg5 = (int) -1 ;
5518 int arg6 = (int) -1 ;
5519 int result;
5520 bool temp1 = false ;
5521 bool temp2 = false ;
5522 PyObject * obj0 = 0 ;
5523 PyObject * obj1 = 0 ;
5524 PyObject * obj2 = 0 ;
5525 PyObject * obj3 = 0 ;
5526 PyObject * obj4 = 0 ;
5527 PyObject * obj5 = 0 ;
5528 char *kwnames[] = {
5529 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5530 };
5531
5532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5533 {
5534 arg1 = wxString_in_helper(obj0);
5535 if (arg1 == NULL) SWIG_fail;
5536 temp1 = true;
5537 }
5538 if (obj1) {
5539 {
5540 arg2 = wxString_in_helper(obj1);
5541 if (arg2 == NULL) SWIG_fail;
5542 temp2 = true;
5543 }
5544 }
5545 if (obj2) {
5546 {
5547 arg3 = static_cast<int >(SWIG_As_int(obj2));
5548 if (SWIG_arg_fail(3)) SWIG_fail;
5549 }
5550 }
5551 if (obj3) {
5552 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5553 if (SWIG_arg_fail(4)) SWIG_fail;
5554 }
5555 if (obj4) {
5556 {
5557 arg5 = static_cast<int >(SWIG_As_int(obj4));
5558 if (SWIG_arg_fail(5)) SWIG_fail;
5559 }
5560 }
5561 if (obj5) {
5562 {
5563 arg6 = static_cast<int >(SWIG_As_int(obj5));
5564 if (SWIG_arg_fail(6)) SWIG_fail;
5565 }
5566 }
5567 {
5568 if (!wxPyCheckForApp()) SWIG_fail;
5569 PyThreadState* __tstate = wxPyBeginAllowThreads();
5570 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5571
5572 wxPyEndAllowThreads(__tstate);
5573 if (PyErr_Occurred()) SWIG_fail;
5574 }
5575 {
5576 resultobj = SWIG_From_int(static_cast<int >(result));
5577 }
5578 {
5579 if (temp1)
5580 delete arg1;
5581 }
5582 {
5583 if (temp2)
5584 delete arg2;
5585 }
5586 return resultobj;
5587 fail:
5588 {
5589 if (temp1)
5590 delete arg1;
5591 }
5592 {
5593 if (temp2)
5594 delete arg2;
5595 }
5596 return NULL;
5597 }
5598
5599
5600 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5601 PyObject *resultobj = NULL;
5602 bool result;
5603 char *kwnames[] = {
5604 NULL
5605 };
5606
5607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5608 {
5609 if (!wxPyCheckForApp()) SWIG_fail;
5610 PyThreadState* __tstate = wxPyBeginAllowThreads();
5611 result = (bool)wxColourDisplay();
5612
5613 wxPyEndAllowThreads(__tstate);
5614 if (PyErr_Occurred()) SWIG_fail;
5615 }
5616 {
5617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5618 }
5619 return resultobj;
5620 fail:
5621 return NULL;
5622 }
5623
5624
5625 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5626 PyObject *resultobj = NULL;
5627 int result;
5628 char *kwnames[] = {
5629 NULL
5630 };
5631
5632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5633 {
5634 if (!wxPyCheckForApp()) SWIG_fail;
5635 PyThreadState* __tstate = wxPyBeginAllowThreads();
5636 result = (int)wxDisplayDepth();
5637
5638 wxPyEndAllowThreads(__tstate);
5639 if (PyErr_Occurred()) SWIG_fail;
5640 }
5641 {
5642 resultobj = SWIG_From_int(static_cast<int >(result));
5643 }
5644 return resultobj;
5645 fail:
5646 return NULL;
5647 }
5648
5649
5650 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5651 PyObject *resultobj = NULL;
5652 int result;
5653 char *kwnames[] = {
5654 NULL
5655 };
5656
5657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5658 {
5659 if (!wxPyCheckForApp()) SWIG_fail;
5660 PyThreadState* __tstate = wxPyBeginAllowThreads();
5661 result = (int)wxGetDisplayDepth();
5662
5663 wxPyEndAllowThreads(__tstate);
5664 if (PyErr_Occurred()) SWIG_fail;
5665 }
5666 {
5667 resultobj = SWIG_From_int(static_cast<int >(result));
5668 }
5669 return resultobj;
5670 fail:
5671 return NULL;
5672 }
5673
5674
5675 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5676 PyObject *resultobj = NULL;
5677 int *arg1 = (int *) 0 ;
5678 int *arg2 = (int *) 0 ;
5679 int temp1 ;
5680 int res1 = 0 ;
5681 int temp2 ;
5682 int res2 = 0 ;
5683 char *kwnames[] = {
5684 NULL
5685 };
5686
5687 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5688 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5690 {
5691 if (!wxPyCheckForApp()) SWIG_fail;
5692 PyThreadState* __tstate = wxPyBeginAllowThreads();
5693 wxDisplaySize(arg1,arg2);
5694
5695 wxPyEndAllowThreads(__tstate);
5696 if (PyErr_Occurred()) SWIG_fail;
5697 }
5698 Py_INCREF(Py_None); resultobj = Py_None;
5699 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5700 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5701 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5702 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5703 return resultobj;
5704 fail:
5705 return NULL;
5706 }
5707
5708
5709 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5710 PyObject *resultobj = NULL;
5711 wxSize result;
5712 char *kwnames[] = {
5713 NULL
5714 };
5715
5716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5717 {
5718 if (!wxPyCheckForApp()) SWIG_fail;
5719 PyThreadState* __tstate = wxPyBeginAllowThreads();
5720 result = wxGetDisplaySize();
5721
5722 wxPyEndAllowThreads(__tstate);
5723 if (PyErr_Occurred()) SWIG_fail;
5724 }
5725 {
5726 wxSize * resultptr;
5727 resultptr = new wxSize(static_cast<wxSize & >(result));
5728 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5729 }
5730 return resultobj;
5731 fail:
5732 return NULL;
5733 }
5734
5735
5736 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5737 PyObject *resultobj = NULL;
5738 int *arg1 = (int *) 0 ;
5739 int *arg2 = (int *) 0 ;
5740 int temp1 ;
5741 int res1 = 0 ;
5742 int temp2 ;
5743 int res2 = 0 ;
5744 char *kwnames[] = {
5745 NULL
5746 };
5747
5748 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5749 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5751 {
5752 if (!wxPyCheckForApp()) SWIG_fail;
5753 PyThreadState* __tstate = wxPyBeginAllowThreads();
5754 wxDisplaySizeMM(arg1,arg2);
5755
5756 wxPyEndAllowThreads(__tstate);
5757 if (PyErr_Occurred()) SWIG_fail;
5758 }
5759 Py_INCREF(Py_None); resultobj = Py_None;
5760 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5761 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5762 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5763 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5764 return resultobj;
5765 fail:
5766 return NULL;
5767 }
5768
5769
5770 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5771 PyObject *resultobj = NULL;
5772 wxSize result;
5773 char *kwnames[] = {
5774 NULL
5775 };
5776
5777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5778 {
5779 if (!wxPyCheckForApp()) SWIG_fail;
5780 PyThreadState* __tstate = wxPyBeginAllowThreads();
5781 result = wxGetDisplaySizeMM();
5782
5783 wxPyEndAllowThreads(__tstate);
5784 if (PyErr_Occurred()) SWIG_fail;
5785 }
5786 {
5787 wxSize * resultptr;
5788 resultptr = new wxSize(static_cast<wxSize & >(result));
5789 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5790 }
5791 return resultobj;
5792 fail:
5793 return NULL;
5794 }
5795
5796
5797 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5798 PyObject *resultobj = NULL;
5799 int *arg1 = (int *) 0 ;
5800 int *arg2 = (int *) 0 ;
5801 int *arg3 = (int *) 0 ;
5802 int *arg4 = (int *) 0 ;
5803 int temp1 ;
5804 int res1 = 0 ;
5805 int temp2 ;
5806 int res2 = 0 ;
5807 int temp3 ;
5808 int res3 = 0 ;
5809 int temp4 ;
5810 int res4 = 0 ;
5811 char *kwnames[] = {
5812 NULL
5813 };
5814
5815 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5816 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5817 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5818 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5820 {
5821 if (!wxPyCheckForApp()) SWIG_fail;
5822 PyThreadState* __tstate = wxPyBeginAllowThreads();
5823 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5824
5825 wxPyEndAllowThreads(__tstate);
5826 if (PyErr_Occurred()) SWIG_fail;
5827 }
5828 Py_INCREF(Py_None); resultobj = Py_None;
5829 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5830 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5831 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5832 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5833 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5834 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5835 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5836 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5837 return resultobj;
5838 fail:
5839 return NULL;
5840 }
5841
5842
5843 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5844 PyObject *resultobj = NULL;
5845 wxRect result;
5846 char *kwnames[] = {
5847 NULL
5848 };
5849
5850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5851 {
5852 if (!wxPyCheckForApp()) SWIG_fail;
5853 PyThreadState* __tstate = wxPyBeginAllowThreads();
5854 result = wxGetClientDisplayRect();
5855
5856 wxPyEndAllowThreads(__tstate);
5857 if (PyErr_Occurred()) SWIG_fail;
5858 }
5859 {
5860 wxRect * resultptr;
5861 resultptr = new wxRect(static_cast<wxRect & >(result));
5862 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5863 }
5864 return resultobj;
5865 fail:
5866 return NULL;
5867 }
5868
5869
5870 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5871 PyObject *resultobj = NULL;
5872 wxCursor *arg1 = 0 ;
5873 PyObject * obj0 = 0 ;
5874 char *kwnames[] = {
5875 (char *) "cursor", NULL
5876 };
5877
5878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5879 {
5880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5881 if (SWIG_arg_fail(1)) SWIG_fail;
5882 if (arg1 == NULL) {
5883 SWIG_null_ref("wxCursor");
5884 }
5885 if (SWIG_arg_fail(1)) SWIG_fail;
5886 }
5887 {
5888 if (!wxPyCheckForApp()) SWIG_fail;
5889 PyThreadState* __tstate = wxPyBeginAllowThreads();
5890 wxSetCursor(*arg1);
5891
5892 wxPyEndAllowThreads(__tstate);
5893 if (PyErr_Occurred()) SWIG_fail;
5894 }
5895 Py_INCREF(Py_None); resultobj = Py_None;
5896 return resultobj;
5897 fail:
5898 return NULL;
5899 }
5900
5901
5902 static PyObject *_wrap_GetXDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5903 PyObject *resultobj = NULL;
5904 void *result;
5905 char *kwnames[] = {
5906 NULL
5907 };
5908
5909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetXDisplay",kwnames)) goto fail;
5910 {
5911 if (!wxPyCheckForApp()) SWIG_fail;
5912 PyThreadState* __tstate = wxPyBeginAllowThreads();
5913 result = (void *)wxGetXDisplay();
5914
5915 wxPyEndAllowThreads(__tstate);
5916 if (PyErr_Occurred()) SWIG_fail;
5917 }
5918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_void, 0);
5919 return resultobj;
5920 fail:
5921 return NULL;
5922 }
5923
5924
5925 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5926 PyObject *resultobj = NULL;
5927 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5928 PyObject * obj0 = 0 ;
5929 char *kwnames[] = {
5930 (char *) "cursor", NULL
5931 };
5932
5933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5934 if (obj0) {
5935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5936 if (SWIG_arg_fail(1)) SWIG_fail;
5937 }
5938 {
5939 if (!wxPyCheckForApp()) SWIG_fail;
5940 PyThreadState* __tstate = wxPyBeginAllowThreads();
5941 wxBeginBusyCursor(arg1);
5942
5943 wxPyEndAllowThreads(__tstate);
5944 if (PyErr_Occurred()) SWIG_fail;
5945 }
5946 Py_INCREF(Py_None); resultobj = Py_None;
5947 return resultobj;
5948 fail:
5949 return NULL;
5950 }
5951
5952
5953 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
5954 PyObject *resultobj = NULL;
5955 wxPoint result;
5956 char *kwnames[] = {
5957 NULL
5958 };
5959
5960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
5961 {
5962 if (!wxPyCheckForApp()) SWIG_fail;
5963 PyThreadState* __tstate = wxPyBeginAllowThreads();
5964 result = wxGetMousePosition();
5965
5966 wxPyEndAllowThreads(__tstate);
5967 if (PyErr_Occurred()) SWIG_fail;
5968 }
5969 {
5970 wxPoint * resultptr;
5971 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5972 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5973 }
5974 return resultobj;
5975 fail:
5976 return NULL;
5977 }
5978
5979
5980 static PyObject *_wrap_FindWindowAtPointer(PyObject *, PyObject *args, PyObject *kwargs) {
5981 PyObject *resultobj = NULL;
5982 wxWindow *result;
5983 char *kwnames[] = {
5984 NULL
5985 };
5986
5987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FindWindowAtPointer",kwnames)) goto fail;
5988 {
5989 if (!wxPyCheckForApp()) SWIG_fail;
5990 PyThreadState* __tstate = wxPyBeginAllowThreads();
5991 result = (wxWindow *)FindWindowAtPointer();
5992
5993 wxPyEndAllowThreads(__tstate);
5994 if (PyErr_Occurred()) SWIG_fail;
5995 }
5996 {
5997 resultobj = wxPyMake_wxObject(result, 0);
5998 }
5999 return resultobj;
6000 fail:
6001 return NULL;
6002 }
6003
6004
6005 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6006 PyObject *resultobj = NULL;
6007 wxWindow *result;
6008 char *kwnames[] = {
6009 NULL
6010 };
6011
6012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
6013 {
6014 if (!wxPyCheckForApp()) SWIG_fail;
6015 PyThreadState* __tstate = wxPyBeginAllowThreads();
6016 result = (wxWindow *)wxGetActiveWindow();
6017
6018 wxPyEndAllowThreads(__tstate);
6019 if (PyErr_Occurred()) SWIG_fail;
6020 }
6021 {
6022 resultobj = wxPyMake_wxObject(result, 0);
6023 }
6024 return resultobj;
6025 fail:
6026 return NULL;
6027 }
6028
6029
6030 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6031 PyObject *resultobj = NULL;
6032 wxPoint *arg1 = 0 ;
6033 wxWindow *result;
6034 wxPoint temp1 ;
6035 PyObject * obj0 = 0 ;
6036 char *kwnames[] = {
6037 (char *) "pt", NULL
6038 };
6039
6040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
6041 {
6042 arg1 = &temp1;
6043 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6044 }
6045 {
6046 if (!wxPyCheckForApp()) SWIG_fail;
6047 PyThreadState* __tstate = wxPyBeginAllowThreads();
6048 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6049
6050 wxPyEndAllowThreads(__tstate);
6051 if (PyErr_Occurred()) SWIG_fail;
6052 }
6053 {
6054 resultobj = wxPyMake_wxObject(result, 0);
6055 }
6056 return resultobj;
6057 fail:
6058 return NULL;
6059 }
6060
6061
6062 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6063 PyObject *resultobj = NULL;
6064 wxPoint *arg1 = 0 ;
6065 wxWindow *result;
6066 wxPoint temp1 ;
6067 PyObject * obj0 = 0 ;
6068 char *kwnames[] = {
6069 (char *) "pt", NULL
6070 };
6071
6072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
6073 {
6074 arg1 = &temp1;
6075 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6076 }
6077 {
6078 if (!wxPyCheckForApp()) SWIG_fail;
6079 PyThreadState* __tstate = wxPyBeginAllowThreads();
6080 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6081
6082 wxPyEndAllowThreads(__tstate);
6083 if (PyErr_Occurred()) SWIG_fail;
6084 }
6085 {
6086 resultobj = wxPyMake_wxObject(result, 0);
6087 }
6088 return resultobj;
6089 fail:
6090 return NULL;
6091 }
6092
6093
6094 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
6095 PyObject *resultobj = NULL;
6096 wxWindow *arg1 = (wxWindow *) 0 ;
6097 wxWindow *result;
6098 PyObject * obj0 = 0 ;
6099 char *kwnames[] = {
6100 (char *) "win", NULL
6101 };
6102
6103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
6104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6105 if (SWIG_arg_fail(1)) SWIG_fail;
6106 {
6107 if (!wxPyCheckForApp()) SWIG_fail;
6108 PyThreadState* __tstate = wxPyBeginAllowThreads();
6109 result = (wxWindow *)wxGetTopLevelParent(arg1);
6110
6111 wxPyEndAllowThreads(__tstate);
6112 if (PyErr_Occurred()) SWIG_fail;
6113 }
6114 {
6115 resultobj = wxPyMake_wxObject(result, 0);
6116 }
6117 return resultobj;
6118 fail:
6119 return NULL;
6120 }
6121
6122
6123 static PyObject *_wrap_LaunchDefaultBrowser(PyObject *, PyObject *args, PyObject *kwargs) {
6124 PyObject *resultobj = NULL;
6125 wxString *arg1 = 0 ;
6126 bool result;
6127 bool temp1 = false ;
6128 PyObject * obj0 = 0 ;
6129 char *kwnames[] = {
6130 (char *) "url", NULL
6131 };
6132
6133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) goto fail;
6134 {
6135 arg1 = wxString_in_helper(obj0);
6136 if (arg1 == NULL) SWIG_fail;
6137 temp1 = true;
6138 }
6139 {
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
6142
6143 wxPyEndAllowThreads(__tstate);
6144 if (PyErr_Occurred()) SWIG_fail;
6145 }
6146 {
6147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6148 }
6149 {
6150 if (temp1)
6151 delete arg1;
6152 }
6153 return resultobj;
6154 fail:
6155 {
6156 if (temp1)
6157 delete arg1;
6158 }
6159 return NULL;
6160 }
6161
6162
6163 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6164 PyObject *resultobj = NULL;
6165 wxKeyCode arg1 ;
6166 bool result;
6167 PyObject * obj0 = 0 ;
6168 char *kwnames[] = {
6169 (char *) "key", NULL
6170 };
6171
6172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6173 {
6174 arg1 = static_cast<wxKeyCode >(SWIG_As_int(obj0));
6175 if (SWIG_arg_fail(1)) SWIG_fail;
6176 }
6177 {
6178 if (!wxPyCheckForApp()) SWIG_fail;
6179 PyThreadState* __tstate = wxPyBeginAllowThreads();
6180 result = (bool)wxGetKeyState(arg1);
6181
6182 wxPyEndAllowThreads(__tstate);
6183 if (PyErr_Occurred()) SWIG_fail;
6184 }
6185 {
6186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6187 }
6188 return resultobj;
6189 fail:
6190 return NULL;
6191 }
6192
6193
6194 static PyObject *_wrap_new_MouseState(PyObject *, PyObject *args, PyObject *kwargs) {
6195 PyObject *resultobj = NULL;
6196 wxMouseState *result;
6197 char *kwnames[] = {
6198 NULL
6199 };
6200
6201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MouseState",kwnames)) goto fail;
6202 {
6203 PyThreadState* __tstate = wxPyBeginAllowThreads();
6204 result = (wxMouseState *)new wxMouseState();
6205
6206 wxPyEndAllowThreads(__tstate);
6207 if (PyErr_Occurred()) SWIG_fail;
6208 }
6209 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseState, 1);
6210 return resultobj;
6211 fail:
6212 return NULL;
6213 }
6214
6215
6216 static PyObject *_wrap_delete_MouseState(PyObject *, PyObject *args, PyObject *kwargs) {
6217 PyObject *resultobj = NULL;
6218 wxMouseState *arg1 = (wxMouseState *) 0 ;
6219 PyObject * obj0 = 0 ;
6220 char *kwnames[] = {
6221 (char *) "self", NULL
6222 };
6223
6224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MouseState",kwnames,&obj0)) goto fail;
6225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6226 if (SWIG_arg_fail(1)) SWIG_fail;
6227 {
6228 PyThreadState* __tstate = wxPyBeginAllowThreads();
6229 delete arg1;
6230
6231 wxPyEndAllowThreads(__tstate);
6232 if (PyErr_Occurred()) SWIG_fail;
6233 }
6234 Py_INCREF(Py_None); resultobj = Py_None;
6235 return resultobj;
6236 fail:
6237 return NULL;
6238 }
6239
6240
6241 static PyObject *_wrap_MouseState_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
6242 PyObject *resultobj = NULL;
6243 wxMouseState *arg1 = (wxMouseState *) 0 ;
6244 int result;
6245 PyObject * obj0 = 0 ;
6246 char *kwnames[] = {
6247 (char *) "self", NULL
6248 };
6249
6250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_GetX",kwnames,&obj0)) goto fail;
6251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6252 if (SWIG_arg_fail(1)) SWIG_fail;
6253 {
6254 PyThreadState* __tstate = wxPyBeginAllowThreads();
6255 result = (int)(arg1)->GetX();
6256
6257 wxPyEndAllowThreads(__tstate);
6258 if (PyErr_Occurred()) SWIG_fail;
6259 }
6260 {
6261 resultobj = SWIG_From_int(static_cast<int >(result));
6262 }
6263 return resultobj;
6264 fail:
6265 return NULL;
6266 }
6267
6268
6269 static PyObject *_wrap_MouseState_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
6270 PyObject *resultobj = NULL;
6271 wxMouseState *arg1 = (wxMouseState *) 0 ;
6272 int result;
6273 PyObject * obj0 = 0 ;
6274 char *kwnames[] = {
6275 (char *) "self", NULL
6276 };
6277
6278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_GetY",kwnames,&obj0)) goto fail;
6279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6280 if (SWIG_arg_fail(1)) SWIG_fail;
6281 {
6282 PyThreadState* __tstate = wxPyBeginAllowThreads();
6283 result = (int)(arg1)->GetY();
6284
6285 wxPyEndAllowThreads(__tstate);
6286 if (PyErr_Occurred()) SWIG_fail;
6287 }
6288 {
6289 resultobj = SWIG_From_int(static_cast<int >(result));
6290 }
6291 return resultobj;
6292 fail:
6293 return NULL;
6294 }
6295
6296
6297 static PyObject *_wrap_MouseState_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
6298 PyObject *resultobj = NULL;
6299 wxMouseState *arg1 = (wxMouseState *) 0 ;
6300 bool result;
6301 PyObject * obj0 = 0 ;
6302 char *kwnames[] = {
6303 (char *) "self", NULL
6304 };
6305
6306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_LeftDown",kwnames,&obj0)) goto fail;
6307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6308 if (SWIG_arg_fail(1)) SWIG_fail;
6309 {
6310 PyThreadState* __tstate = wxPyBeginAllowThreads();
6311 result = (bool)(arg1)->LeftDown();
6312
6313 wxPyEndAllowThreads(__tstate);
6314 if (PyErr_Occurred()) SWIG_fail;
6315 }
6316 {
6317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6318 }
6319 return resultobj;
6320 fail:
6321 return NULL;
6322 }
6323
6324
6325 static PyObject *_wrap_MouseState_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
6326 PyObject *resultobj = NULL;
6327 wxMouseState *arg1 = (wxMouseState *) 0 ;
6328 bool result;
6329 PyObject * obj0 = 0 ;
6330 char *kwnames[] = {
6331 (char *) "self", NULL
6332 };
6333
6334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_MiddleDown",kwnames,&obj0)) goto fail;
6335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6336 if (SWIG_arg_fail(1)) SWIG_fail;
6337 {
6338 PyThreadState* __tstate = wxPyBeginAllowThreads();
6339 result = (bool)(arg1)->MiddleDown();
6340
6341 wxPyEndAllowThreads(__tstate);
6342 if (PyErr_Occurred()) SWIG_fail;
6343 }
6344 {
6345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6346 }
6347 return resultobj;
6348 fail:
6349 return NULL;
6350 }
6351
6352
6353 static PyObject *_wrap_MouseState_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
6354 PyObject *resultobj = NULL;
6355 wxMouseState *arg1 = (wxMouseState *) 0 ;
6356 bool result;
6357 PyObject * obj0 = 0 ;
6358 char *kwnames[] = {
6359 (char *) "self", NULL
6360 };
6361
6362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_RightDown",kwnames,&obj0)) goto fail;
6363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6364 if (SWIG_arg_fail(1)) SWIG_fail;
6365 {
6366 PyThreadState* __tstate = wxPyBeginAllowThreads();
6367 result = (bool)(arg1)->RightDown();
6368
6369 wxPyEndAllowThreads(__tstate);
6370 if (PyErr_Occurred()) SWIG_fail;
6371 }
6372 {
6373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6374 }
6375 return resultobj;
6376 fail:
6377 return NULL;
6378 }
6379
6380
6381 static PyObject *_wrap_MouseState_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
6382 PyObject *resultobj = NULL;
6383 wxMouseState *arg1 = (wxMouseState *) 0 ;
6384 bool result;
6385 PyObject * obj0 = 0 ;
6386 char *kwnames[] = {
6387 (char *) "self", NULL
6388 };
6389
6390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_ControlDown",kwnames,&obj0)) goto fail;
6391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6392 if (SWIG_arg_fail(1)) SWIG_fail;
6393 {
6394 PyThreadState* __tstate = wxPyBeginAllowThreads();
6395 result = (bool)(arg1)->ControlDown();
6396
6397 wxPyEndAllowThreads(__tstate);
6398 if (PyErr_Occurred()) SWIG_fail;
6399 }
6400 {
6401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6402 }
6403 return resultobj;
6404 fail:
6405 return NULL;
6406 }
6407
6408
6409 static PyObject *_wrap_MouseState_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
6410 PyObject *resultobj = NULL;
6411 wxMouseState *arg1 = (wxMouseState *) 0 ;
6412 bool result;
6413 PyObject * obj0 = 0 ;
6414 char *kwnames[] = {
6415 (char *) "self", NULL
6416 };
6417
6418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_ShiftDown",kwnames,&obj0)) goto fail;
6419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6420 if (SWIG_arg_fail(1)) SWIG_fail;
6421 {
6422 PyThreadState* __tstate = wxPyBeginAllowThreads();
6423 result = (bool)(arg1)->ShiftDown();
6424
6425 wxPyEndAllowThreads(__tstate);
6426 if (PyErr_Occurred()) SWIG_fail;
6427 }
6428 {
6429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6430 }
6431 return resultobj;
6432 fail:
6433 return NULL;
6434 }
6435
6436
6437 static PyObject *_wrap_MouseState_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
6438 PyObject *resultobj = NULL;
6439 wxMouseState *arg1 = (wxMouseState *) 0 ;
6440 bool result;
6441 PyObject * obj0 = 0 ;
6442 char *kwnames[] = {
6443 (char *) "self", NULL
6444 };
6445
6446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_AltDown",kwnames,&obj0)) goto fail;
6447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6448 if (SWIG_arg_fail(1)) SWIG_fail;
6449 {
6450 PyThreadState* __tstate = wxPyBeginAllowThreads();
6451 result = (bool)(arg1)->AltDown();
6452
6453 wxPyEndAllowThreads(__tstate);
6454 if (PyErr_Occurred()) SWIG_fail;
6455 }
6456 {
6457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6458 }
6459 return resultobj;
6460 fail:
6461 return NULL;
6462 }
6463
6464
6465 static PyObject *_wrap_MouseState_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
6466 PyObject *resultobj = NULL;
6467 wxMouseState *arg1 = (wxMouseState *) 0 ;
6468 bool result;
6469 PyObject * obj0 = 0 ;
6470 char *kwnames[] = {
6471 (char *) "self", NULL
6472 };
6473
6474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_MetaDown",kwnames,&obj0)) goto fail;
6475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6476 if (SWIG_arg_fail(1)) SWIG_fail;
6477 {
6478 PyThreadState* __tstate = wxPyBeginAllowThreads();
6479 result = (bool)(arg1)->MetaDown();
6480
6481 wxPyEndAllowThreads(__tstate);
6482 if (PyErr_Occurred()) SWIG_fail;
6483 }
6484 {
6485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6486 }
6487 return resultobj;
6488 fail:
6489 return NULL;
6490 }
6491
6492
6493 static PyObject *_wrap_MouseState_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
6494 PyObject *resultobj = NULL;
6495 wxMouseState *arg1 = (wxMouseState *) 0 ;
6496 bool result;
6497 PyObject * obj0 = 0 ;
6498 char *kwnames[] = {
6499 (char *) "self", NULL
6500 };
6501
6502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseState_CmdDown",kwnames,&obj0)) goto fail;
6503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6504 if (SWIG_arg_fail(1)) SWIG_fail;
6505 {
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (bool)(arg1)->CmdDown();
6508
6509 wxPyEndAllowThreads(__tstate);
6510 if (PyErr_Occurred()) SWIG_fail;
6511 }
6512 {
6513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6514 }
6515 return resultobj;
6516 fail:
6517 return NULL;
6518 }
6519
6520
6521 static PyObject *_wrap_MouseState_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
6522 PyObject *resultobj = NULL;
6523 wxMouseState *arg1 = (wxMouseState *) 0 ;
6524 int arg2 ;
6525 PyObject * obj0 = 0 ;
6526 PyObject * obj1 = 0 ;
6527 char *kwnames[] = {
6528 (char *) "self",(char *) "x", NULL
6529 };
6530
6531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) goto fail;
6532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6533 if (SWIG_arg_fail(1)) SWIG_fail;
6534 {
6535 arg2 = static_cast<int >(SWIG_As_int(obj1));
6536 if (SWIG_arg_fail(2)) SWIG_fail;
6537 }
6538 {
6539 PyThreadState* __tstate = wxPyBeginAllowThreads();
6540 (arg1)->SetX(arg2);
6541
6542 wxPyEndAllowThreads(__tstate);
6543 if (PyErr_Occurred()) SWIG_fail;
6544 }
6545 Py_INCREF(Py_None); resultobj = Py_None;
6546 return resultobj;
6547 fail:
6548 return NULL;
6549 }
6550
6551
6552 static PyObject *_wrap_MouseState_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
6553 PyObject *resultobj = NULL;
6554 wxMouseState *arg1 = (wxMouseState *) 0 ;
6555 int arg2 ;
6556 PyObject * obj0 = 0 ;
6557 PyObject * obj1 = 0 ;
6558 char *kwnames[] = {
6559 (char *) "self",(char *) "y", NULL
6560 };
6561
6562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) goto fail;
6563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6564 if (SWIG_arg_fail(1)) SWIG_fail;
6565 {
6566 arg2 = static_cast<int >(SWIG_As_int(obj1));
6567 if (SWIG_arg_fail(2)) SWIG_fail;
6568 }
6569 {
6570 PyThreadState* __tstate = wxPyBeginAllowThreads();
6571 (arg1)->SetY(arg2);
6572
6573 wxPyEndAllowThreads(__tstate);
6574 if (PyErr_Occurred()) SWIG_fail;
6575 }
6576 Py_INCREF(Py_None); resultobj = Py_None;
6577 return resultobj;
6578 fail:
6579 return NULL;
6580 }
6581
6582
6583 static PyObject *_wrap_MouseState_SetLeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
6584 PyObject *resultobj = NULL;
6585 wxMouseState *arg1 = (wxMouseState *) 0 ;
6586 bool arg2 ;
6587 PyObject * obj0 = 0 ;
6588 PyObject * obj1 = 0 ;
6589 char *kwnames[] = {
6590 (char *) "self",(char *) "down", NULL
6591 };
6592
6593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) goto fail;
6594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6595 if (SWIG_arg_fail(1)) SWIG_fail;
6596 {
6597 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6598 if (SWIG_arg_fail(2)) SWIG_fail;
6599 }
6600 {
6601 PyThreadState* __tstate = wxPyBeginAllowThreads();
6602 (arg1)->SetLeftDown(arg2);
6603
6604 wxPyEndAllowThreads(__tstate);
6605 if (PyErr_Occurred()) SWIG_fail;
6606 }
6607 Py_INCREF(Py_None); resultobj = Py_None;
6608 return resultobj;
6609 fail:
6610 return NULL;
6611 }
6612
6613
6614 static PyObject *_wrap_MouseState_SetMiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
6615 PyObject *resultobj = NULL;
6616 wxMouseState *arg1 = (wxMouseState *) 0 ;
6617 bool arg2 ;
6618 PyObject * obj0 = 0 ;
6619 PyObject * obj1 = 0 ;
6620 char *kwnames[] = {
6621 (char *) "self",(char *) "down", NULL
6622 };
6623
6624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) goto fail;
6625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6626 if (SWIG_arg_fail(1)) SWIG_fail;
6627 {
6628 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6629 if (SWIG_arg_fail(2)) SWIG_fail;
6630 }
6631 {
6632 PyThreadState* __tstate = wxPyBeginAllowThreads();
6633 (arg1)->SetMiddleDown(arg2);
6634
6635 wxPyEndAllowThreads(__tstate);
6636 if (PyErr_Occurred()) SWIG_fail;
6637 }
6638 Py_INCREF(Py_None); resultobj = Py_None;
6639 return resultobj;
6640 fail:
6641 return NULL;
6642 }
6643
6644
6645 static PyObject *_wrap_MouseState_SetRightDown(PyObject *, PyObject *args, PyObject *kwargs) {
6646 PyObject *resultobj = NULL;
6647 wxMouseState *arg1 = (wxMouseState *) 0 ;
6648 bool arg2 ;
6649 PyObject * obj0 = 0 ;
6650 PyObject * obj1 = 0 ;
6651 char *kwnames[] = {
6652 (char *) "self",(char *) "down", NULL
6653 };
6654
6655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) goto fail;
6656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6657 if (SWIG_arg_fail(1)) SWIG_fail;
6658 {
6659 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6660 if (SWIG_arg_fail(2)) SWIG_fail;
6661 }
6662 {
6663 PyThreadState* __tstate = wxPyBeginAllowThreads();
6664 (arg1)->SetRightDown(arg2);
6665
6666 wxPyEndAllowThreads(__tstate);
6667 if (PyErr_Occurred()) SWIG_fail;
6668 }
6669 Py_INCREF(Py_None); resultobj = Py_None;
6670 return resultobj;
6671 fail:
6672 return NULL;
6673 }
6674
6675
6676 static PyObject *_wrap_MouseState_SetControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
6677 PyObject *resultobj = NULL;
6678 wxMouseState *arg1 = (wxMouseState *) 0 ;
6679 bool arg2 ;
6680 PyObject * obj0 = 0 ;
6681 PyObject * obj1 = 0 ;
6682 char *kwnames[] = {
6683 (char *) "self",(char *) "down", NULL
6684 };
6685
6686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) goto fail;
6687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6688 if (SWIG_arg_fail(1)) SWIG_fail;
6689 {
6690 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6691 if (SWIG_arg_fail(2)) SWIG_fail;
6692 }
6693 {
6694 PyThreadState* __tstate = wxPyBeginAllowThreads();
6695 (arg1)->SetControlDown(arg2);
6696
6697 wxPyEndAllowThreads(__tstate);
6698 if (PyErr_Occurred()) SWIG_fail;
6699 }
6700 Py_INCREF(Py_None); resultobj = Py_None;
6701 return resultobj;
6702 fail:
6703 return NULL;
6704 }
6705
6706
6707 static PyObject *_wrap_MouseState_SetShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
6708 PyObject *resultobj = NULL;
6709 wxMouseState *arg1 = (wxMouseState *) 0 ;
6710 bool arg2 ;
6711 PyObject * obj0 = 0 ;
6712 PyObject * obj1 = 0 ;
6713 char *kwnames[] = {
6714 (char *) "self",(char *) "down", NULL
6715 };
6716
6717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) goto fail;
6718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6719 if (SWIG_arg_fail(1)) SWIG_fail;
6720 {
6721 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6722 if (SWIG_arg_fail(2)) SWIG_fail;
6723 }
6724 {
6725 PyThreadState* __tstate = wxPyBeginAllowThreads();
6726 (arg1)->SetShiftDown(arg2);
6727
6728 wxPyEndAllowThreads(__tstate);
6729 if (PyErr_Occurred()) SWIG_fail;
6730 }
6731 Py_INCREF(Py_None); resultobj = Py_None;
6732 return resultobj;
6733 fail:
6734 return NULL;
6735 }
6736
6737
6738 static PyObject *_wrap_MouseState_SetAltDown(PyObject *, PyObject *args, PyObject *kwargs) {
6739 PyObject *resultobj = NULL;
6740 wxMouseState *arg1 = (wxMouseState *) 0 ;
6741 bool arg2 ;
6742 PyObject * obj0 = 0 ;
6743 PyObject * obj1 = 0 ;
6744 char *kwnames[] = {
6745 (char *) "self",(char *) "down", NULL
6746 };
6747
6748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) goto fail;
6749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6750 if (SWIG_arg_fail(1)) SWIG_fail;
6751 {
6752 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6753 if (SWIG_arg_fail(2)) SWIG_fail;
6754 }
6755 {
6756 PyThreadState* __tstate = wxPyBeginAllowThreads();
6757 (arg1)->SetAltDown(arg2);
6758
6759 wxPyEndAllowThreads(__tstate);
6760 if (PyErr_Occurred()) SWIG_fail;
6761 }
6762 Py_INCREF(Py_None); resultobj = Py_None;
6763 return resultobj;
6764 fail:
6765 return NULL;
6766 }
6767
6768
6769 static PyObject *_wrap_MouseState_SetMetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
6770 PyObject *resultobj = NULL;
6771 wxMouseState *arg1 = (wxMouseState *) 0 ;
6772 bool arg2 ;
6773 PyObject * obj0 = 0 ;
6774 PyObject * obj1 = 0 ;
6775 char *kwnames[] = {
6776 (char *) "self",(char *) "down", NULL
6777 };
6778
6779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) goto fail;
6780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseState, SWIG_POINTER_EXCEPTION | 0);
6781 if (SWIG_arg_fail(1)) SWIG_fail;
6782 {
6783 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
6784 if (SWIG_arg_fail(2)) SWIG_fail;
6785 }
6786 {
6787 PyThreadState* __tstate = wxPyBeginAllowThreads();
6788 (arg1)->SetMetaDown(arg2);
6789
6790 wxPyEndAllowThreads(__tstate);
6791 if (PyErr_Occurred()) SWIG_fail;
6792 }
6793 Py_INCREF(Py_None); resultobj = Py_None;
6794 return resultobj;
6795 fail:
6796 return NULL;
6797 }
6798
6799
6800 static PyObject * MouseState_swigregister(PyObject *, PyObject *args) {
6801 PyObject *obj;
6802 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6803 SWIG_TypeClientData(SWIGTYPE_p_wxMouseState, obj);
6804 Py_INCREF(obj);
6805 return Py_BuildValue((char *)"");
6806 }
6807 static PyObject *_wrap_GetMouseState(PyObject *, PyObject *args, PyObject *kwargs) {
6808 PyObject *resultobj = NULL;
6809 wxMouseState result;
6810 char *kwnames[] = {
6811 NULL
6812 };
6813
6814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMouseState",kwnames)) goto fail;
6815 {
6816 PyThreadState* __tstate = wxPyBeginAllowThreads();
6817 result = wxGetMouseState();
6818
6819 wxPyEndAllowThreads(__tstate);
6820 if (PyErr_Occurred()) SWIG_fail;
6821 }
6822 {
6823 wxMouseState * resultptr;
6824 resultptr = new wxMouseState(static_cast<wxMouseState & >(result));
6825 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMouseState, 1);
6826 }
6827 return resultobj;
6828 fail:
6829 return NULL;
6830 }
6831
6832
6833 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6834 PyObject *resultobj = NULL;
6835 char *kwnames[] = {
6836 NULL
6837 };
6838
6839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6840 {
6841 if (!wxPyCheckForApp()) SWIG_fail;
6842 PyThreadState* __tstate = wxPyBeginAllowThreads();
6843 wxWakeUpMainThread();
6844
6845 wxPyEndAllowThreads(__tstate);
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 Py_INCREF(Py_None); resultobj = Py_None;
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6856 PyObject *resultobj = NULL;
6857 char *kwnames[] = {
6858 NULL
6859 };
6860
6861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6862 {
6863 if (!wxPyCheckForApp()) SWIG_fail;
6864 PyThreadState* __tstate = wxPyBeginAllowThreads();
6865 wxMutexGuiEnter();
6866
6867 wxPyEndAllowThreads(__tstate);
6868 if (PyErr_Occurred()) SWIG_fail;
6869 }
6870 Py_INCREF(Py_None); resultobj = Py_None;
6871 return resultobj;
6872 fail:
6873 return NULL;
6874 }
6875
6876
6877 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6878 PyObject *resultobj = NULL;
6879 char *kwnames[] = {
6880 NULL
6881 };
6882
6883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6884 {
6885 if (!wxPyCheckForApp()) SWIG_fail;
6886 PyThreadState* __tstate = wxPyBeginAllowThreads();
6887 wxMutexGuiLeave();
6888
6889 wxPyEndAllowThreads(__tstate);
6890 if (PyErr_Occurred()) SWIG_fail;
6891 }
6892 Py_INCREF(Py_None); resultobj = Py_None;
6893 return resultobj;
6894 fail:
6895 return NULL;
6896 }
6897
6898
6899 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6900 PyObject *resultobj = NULL;
6901 wxMutexGuiLocker *result;
6902 char *kwnames[] = {
6903 NULL
6904 };
6905
6906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6907 {
6908 if (!wxPyCheckForApp()) SWIG_fail;
6909 PyThreadState* __tstate = wxPyBeginAllowThreads();
6910 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6911
6912 wxPyEndAllowThreads(__tstate);
6913 if (PyErr_Occurred()) SWIG_fail;
6914 }
6915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6916 return resultobj;
6917 fail:
6918 return NULL;
6919 }
6920
6921
6922 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6923 PyObject *resultobj = NULL;
6924 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6925 PyObject * obj0 = 0 ;
6926 char *kwnames[] = {
6927 (char *) "self", NULL
6928 };
6929
6930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6932 if (SWIG_arg_fail(1)) SWIG_fail;
6933 {
6934 PyThreadState* __tstate = wxPyBeginAllowThreads();
6935 delete arg1;
6936
6937 wxPyEndAllowThreads(__tstate);
6938 if (PyErr_Occurred()) SWIG_fail;
6939 }
6940 Py_INCREF(Py_None); resultobj = Py_None;
6941 return resultobj;
6942 fail:
6943 return NULL;
6944 }
6945
6946
6947 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6948 PyObject *obj;
6949 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6950 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6951 Py_INCREF(obj);
6952 return Py_BuildValue((char *)"");
6953 }
6954 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6955 PyObject *resultobj = NULL;
6956 bool result;
6957 char *kwnames[] = {
6958 NULL
6959 };
6960
6961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6962 {
6963 PyThreadState* __tstate = wxPyBeginAllowThreads();
6964 result = (bool)wxThread_IsMain();
6965
6966 wxPyEndAllowThreads(__tstate);
6967 if (PyErr_Occurred()) SWIG_fail;
6968 }
6969 {
6970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6971 }
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6979 PyObject *resultobj = NULL;
6980 wxString *arg1 = 0 ;
6981 wxToolTip *result;
6982 bool temp1 = false ;
6983 PyObject * obj0 = 0 ;
6984 char *kwnames[] = {
6985 (char *) "tip", NULL
6986 };
6987
6988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6989 {
6990 arg1 = wxString_in_helper(obj0);
6991 if (arg1 == NULL) SWIG_fail;
6992 temp1 = true;
6993 }
6994 {
6995 if (!wxPyCheckForApp()) SWIG_fail;
6996 PyThreadState* __tstate = wxPyBeginAllowThreads();
6997 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6998
6999 wxPyEndAllowThreads(__tstate);
7000 if (PyErr_Occurred()) SWIG_fail;
7001 }
7002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxToolTip, 1);
7003 {
7004 if (temp1)
7005 delete arg1;
7006 }
7007 return resultobj;
7008 fail:
7009 {
7010 if (temp1)
7011 delete arg1;
7012 }
7013 return NULL;
7014 }
7015
7016
7017 static PyObject *_wrap_delete_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
7018 PyObject *resultobj = NULL;
7019 wxToolTip *arg1 = (wxToolTip *) 0 ;
7020 PyObject * obj0 = 0 ;
7021 char *kwnames[] = {
7022 (char *) "self", NULL
7023 };
7024
7025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ToolTip",kwnames,&obj0)) goto fail;
7026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
7027 if (SWIG_arg_fail(1)) SWIG_fail;
7028 {
7029 PyThreadState* __tstate = wxPyBeginAllowThreads();
7030 delete arg1;
7031
7032 wxPyEndAllowThreads(__tstate);
7033 if (PyErr_Occurred()) SWIG_fail;
7034 }
7035 Py_INCREF(Py_None); resultobj = Py_None;
7036 return resultobj;
7037 fail:
7038 return NULL;
7039 }
7040
7041
7042 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7043 PyObject *resultobj = NULL;
7044 wxToolTip *arg1 = (wxToolTip *) 0 ;
7045 wxString *arg2 = 0 ;
7046 bool temp2 = false ;
7047 PyObject * obj0 = 0 ;
7048 PyObject * obj1 = 0 ;
7049 char *kwnames[] = {
7050 (char *) "self",(char *) "tip", NULL
7051 };
7052
7053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
7054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
7055 if (SWIG_arg_fail(1)) SWIG_fail;
7056 {
7057 arg2 = wxString_in_helper(obj1);
7058 if (arg2 == NULL) SWIG_fail;
7059 temp2 = true;
7060 }
7061 {
7062 PyThreadState* __tstate = wxPyBeginAllowThreads();
7063 (arg1)->SetTip((wxString const &)*arg2);
7064
7065 wxPyEndAllowThreads(__tstate);
7066 if (PyErr_Occurred()) SWIG_fail;
7067 }
7068 Py_INCREF(Py_None); resultobj = Py_None;
7069 {
7070 if (temp2)
7071 delete arg2;
7072 }
7073 return resultobj;
7074 fail:
7075 {
7076 if (temp2)
7077 delete arg2;
7078 }
7079 return NULL;
7080 }
7081
7082
7083 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7084 PyObject *resultobj = NULL;
7085 wxToolTip *arg1 = (wxToolTip *) 0 ;
7086 wxString result;
7087 PyObject * obj0 = 0 ;
7088 char *kwnames[] = {
7089 (char *) "self", NULL
7090 };
7091
7092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
7093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
7094 if (SWIG_arg_fail(1)) SWIG_fail;
7095 {
7096 PyThreadState* __tstate = wxPyBeginAllowThreads();
7097 result = (arg1)->GetTip();
7098
7099 wxPyEndAllowThreads(__tstate);
7100 if (PyErr_Occurred()) SWIG_fail;
7101 }
7102 {
7103 #if wxUSE_UNICODE
7104 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7105 #else
7106 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7107 #endif
7108 }
7109 return resultobj;
7110 fail:
7111 return NULL;
7112 }
7113
7114
7115 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7116 PyObject *resultobj = NULL;
7117 wxToolTip *arg1 = (wxToolTip *) 0 ;
7118 wxWindow *result;
7119 PyObject * obj0 = 0 ;
7120 char *kwnames[] = {
7121 (char *) "self", NULL
7122 };
7123
7124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
7125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
7126 if (SWIG_arg_fail(1)) SWIG_fail;
7127 {
7128 PyThreadState* __tstate = wxPyBeginAllowThreads();
7129 result = (wxWindow *)(arg1)->GetWindow();
7130
7131 wxPyEndAllowThreads(__tstate);
7132 if (PyErr_Occurred()) SWIG_fail;
7133 }
7134 {
7135 resultobj = wxPyMake_wxObject(result, 0);
7136 }
7137 return resultobj;
7138 fail:
7139 return NULL;
7140 }
7141
7142
7143 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
7144 PyObject *resultobj = NULL;
7145 bool arg1 ;
7146 PyObject * obj0 = 0 ;
7147 char *kwnames[] = {
7148 (char *) "flag", NULL
7149 };
7150
7151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
7152 {
7153 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
7154 if (SWIG_arg_fail(1)) SWIG_fail;
7155 }
7156 {
7157 PyThreadState* __tstate = wxPyBeginAllowThreads();
7158 wxToolTip::Enable(arg1);
7159
7160 wxPyEndAllowThreads(__tstate);
7161 if (PyErr_Occurred()) SWIG_fail;
7162 }
7163 Py_INCREF(Py_None); resultobj = Py_None;
7164 return resultobj;
7165 fail:
7166 return NULL;
7167 }
7168
7169
7170 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
7171 PyObject *resultobj = NULL;
7172 long arg1 ;
7173 PyObject * obj0 = 0 ;
7174 char *kwnames[] = {
7175 (char *) "milliseconds", NULL
7176 };
7177
7178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
7179 {
7180 arg1 = static_cast<long >(SWIG_As_long(obj0));
7181 if (SWIG_arg_fail(1)) SWIG_fail;
7182 }
7183 {
7184 PyThreadState* __tstate = wxPyBeginAllowThreads();
7185 wxToolTip::SetDelay(arg1);
7186
7187 wxPyEndAllowThreads(__tstate);
7188 if (PyErr_Occurred()) SWIG_fail;
7189 }
7190 Py_INCREF(Py_None); resultobj = Py_None;
7191 return resultobj;
7192 fail:
7193 return NULL;
7194 }
7195
7196
7197 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
7198 PyObject *obj;
7199 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7200 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
7201 Py_INCREF(obj);
7202 return Py_BuildValue((char *)"");
7203 }
7204 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
7205 PyObject *resultobj = NULL;
7206 wxWindow *arg1 = (wxWindow *) 0 ;
7207 wxSize *arg2 = 0 ;
7208 wxCaret *result;
7209 wxSize temp2 ;
7210 PyObject * obj0 = 0 ;
7211 PyObject * obj1 = 0 ;
7212 char *kwnames[] = {
7213 (char *) "window",(char *) "size", NULL
7214 };
7215
7216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
7217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7218 if (SWIG_arg_fail(1)) SWIG_fail;
7219 {
7220 arg2 = &temp2;
7221 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
7222 }
7223 {
7224 if (!wxPyCheckForApp()) SWIG_fail;
7225 PyThreadState* __tstate = wxPyBeginAllowThreads();
7226 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
7227
7228 wxPyEndAllowThreads(__tstate);
7229 if (PyErr_Occurred()) SWIG_fail;
7230 }
7231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
7232 return resultobj;
7233 fail:
7234 return NULL;
7235 }
7236
7237
7238 static PyObject *_wrap_delete_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
7239 PyObject *resultobj = NULL;
7240 wxCaret *arg1 = (wxCaret *) 0 ;
7241 PyObject * obj0 = 0 ;
7242 char *kwnames[] = {
7243 (char *) "self", NULL
7244 };
7245
7246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Caret",kwnames,&obj0)) goto fail;
7247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7248 if (SWIG_arg_fail(1)) SWIG_fail;
7249 {
7250 PyThreadState* __tstate = wxPyBeginAllowThreads();
7251 delete arg1;
7252
7253 wxPyEndAllowThreads(__tstate);
7254 if (PyErr_Occurred()) SWIG_fail;
7255 }
7256 Py_INCREF(Py_None); resultobj = Py_None;
7257 return resultobj;
7258 fail:
7259 return NULL;
7260 }
7261
7262
7263 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
7264 PyObject *resultobj = NULL;
7265 wxCaret *arg1 = (wxCaret *) 0 ;
7266 PyObject * obj0 = 0 ;
7267 char *kwnames[] = {
7268 (char *) "self", NULL
7269 };
7270
7271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
7272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7273 if (SWIG_arg_fail(1)) SWIG_fail;
7274 {
7275 PyThreadState* __tstate = wxPyBeginAllowThreads();
7276 wxCaret_Destroy(arg1);
7277
7278 wxPyEndAllowThreads(__tstate);
7279 if (PyErr_Occurred()) SWIG_fail;
7280 }
7281 Py_INCREF(Py_None); resultobj = Py_None;
7282 return resultobj;
7283 fail:
7284 return NULL;
7285 }
7286
7287
7288 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
7289 PyObject *resultobj = NULL;
7290 wxCaret *arg1 = (wxCaret *) 0 ;
7291 bool result;
7292 PyObject * obj0 = 0 ;
7293 char *kwnames[] = {
7294 (char *) "self", NULL
7295 };
7296
7297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
7298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7299 if (SWIG_arg_fail(1)) SWIG_fail;
7300 {
7301 PyThreadState* __tstate = wxPyBeginAllowThreads();
7302 result = (bool)(arg1)->IsOk();
7303
7304 wxPyEndAllowThreads(__tstate);
7305 if (PyErr_Occurred()) SWIG_fail;
7306 }
7307 {
7308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7309 }
7310 return resultobj;
7311 fail:
7312 return NULL;
7313 }
7314
7315
7316 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
7317 PyObject *resultobj = NULL;
7318 wxCaret *arg1 = (wxCaret *) 0 ;
7319 bool result;
7320 PyObject * obj0 = 0 ;
7321 char *kwnames[] = {
7322 (char *) "self", NULL
7323 };
7324
7325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
7326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7327 if (SWIG_arg_fail(1)) SWIG_fail;
7328 {
7329 PyThreadState* __tstate = wxPyBeginAllowThreads();
7330 result = (bool)(arg1)->IsVisible();
7331
7332 wxPyEndAllowThreads(__tstate);
7333 if (PyErr_Occurred()) SWIG_fail;
7334 }
7335 {
7336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7337 }
7338 return resultobj;
7339 fail:
7340 return NULL;
7341 }
7342
7343
7344 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
7345 PyObject *resultobj = NULL;
7346 wxCaret *arg1 = (wxCaret *) 0 ;
7347 wxPoint result;
7348 PyObject * obj0 = 0 ;
7349 char *kwnames[] = {
7350 (char *) "self", NULL
7351 };
7352
7353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
7354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7355 if (SWIG_arg_fail(1)) SWIG_fail;
7356 {
7357 PyThreadState* __tstate = wxPyBeginAllowThreads();
7358 result = (arg1)->GetPosition();
7359
7360 wxPyEndAllowThreads(__tstate);
7361 if (PyErr_Occurred()) SWIG_fail;
7362 }
7363 {
7364 wxPoint * resultptr;
7365 resultptr = new wxPoint(static_cast<wxPoint & >(result));
7366 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
7367 }
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
7375 PyObject *resultobj = NULL;
7376 wxCaret *arg1 = (wxCaret *) 0 ;
7377 int *arg2 = (int *) 0 ;
7378 int *arg3 = (int *) 0 ;
7379 int temp2 ;
7380 int res2 = 0 ;
7381 int temp3 ;
7382 int res3 = 0 ;
7383 PyObject * obj0 = 0 ;
7384 char *kwnames[] = {
7385 (char *) "self", NULL
7386 };
7387
7388 arg2 = &temp2; res2 = SWIG_NEWOBJ;
7389 arg3 = &temp3; res3 = SWIG_NEWOBJ;
7390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
7391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7392 if (SWIG_arg_fail(1)) SWIG_fail;
7393 {
7394 PyThreadState* __tstate = wxPyBeginAllowThreads();
7395 (arg1)->GetPosition(arg2,arg3);
7396
7397 wxPyEndAllowThreads(__tstate);
7398 if (PyErr_Occurred()) SWIG_fail;
7399 }
7400 Py_INCREF(Py_None); resultobj = Py_None;
7401 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
7402 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
7403 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
7404 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
7405 return resultobj;
7406 fail:
7407 return NULL;
7408 }
7409
7410
7411 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
7412 PyObject *resultobj = NULL;
7413 wxCaret *arg1 = (wxCaret *) 0 ;
7414 wxSize result;
7415 PyObject * obj0 = 0 ;
7416 char *kwnames[] = {
7417 (char *) "self", NULL
7418 };
7419
7420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
7421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7422 if (SWIG_arg_fail(1)) SWIG_fail;
7423 {
7424 PyThreadState* __tstate = wxPyBeginAllowThreads();
7425 result = (arg1)->GetSize();
7426
7427 wxPyEndAllowThreads(__tstate);
7428 if (PyErr_Occurred()) SWIG_fail;
7429 }
7430 {
7431 wxSize * resultptr;
7432 resultptr = new wxSize(static_cast<wxSize & >(result));
7433 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
7434 }
7435 return resultobj;
7436 fail:
7437 return NULL;
7438 }
7439
7440
7441 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
7442 PyObject *resultobj = NULL;
7443 wxCaret *arg1 = (wxCaret *) 0 ;
7444 int *arg2 = (int *) 0 ;
7445 int *arg3 = (int *) 0 ;
7446 int temp2 ;
7447 int res2 = 0 ;
7448 int temp3 ;
7449 int res3 = 0 ;
7450 PyObject * obj0 = 0 ;
7451 char *kwnames[] = {
7452 (char *) "self", NULL
7453 };
7454
7455 arg2 = &temp2; res2 = SWIG_NEWOBJ;
7456 arg3 = &temp3; res3 = SWIG_NEWOBJ;
7457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
7458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7459 if (SWIG_arg_fail(1)) SWIG_fail;
7460 {
7461 PyThreadState* __tstate = wxPyBeginAllowThreads();
7462 (arg1)->GetSize(arg2,arg3);
7463
7464 wxPyEndAllowThreads(__tstate);
7465 if (PyErr_Occurred()) SWIG_fail;
7466 }
7467 Py_INCREF(Py_None); resultobj = Py_None;
7468 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
7469 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
7470 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
7471 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
7472 return resultobj;
7473 fail:
7474 return NULL;
7475 }
7476
7477
7478 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
7479 PyObject *resultobj = NULL;
7480 wxCaret *arg1 = (wxCaret *) 0 ;
7481 wxWindow *result;
7482 PyObject * obj0 = 0 ;
7483 char *kwnames[] = {
7484 (char *) "self", NULL
7485 };
7486
7487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
7488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7489 if (SWIG_arg_fail(1)) SWIG_fail;
7490 {
7491 PyThreadState* __tstate = wxPyBeginAllowThreads();
7492 result = (wxWindow *)(arg1)->GetWindow();
7493
7494 wxPyEndAllowThreads(__tstate);
7495 if (PyErr_Occurred()) SWIG_fail;
7496 }
7497 {
7498 resultobj = wxPyMake_wxObject(result, 0);
7499 }
7500 return resultobj;
7501 fail:
7502 return NULL;
7503 }
7504
7505
7506 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
7507 PyObject *resultobj = NULL;
7508 wxCaret *arg1 = (wxCaret *) 0 ;
7509 int arg2 ;
7510 int arg3 ;
7511 PyObject * obj0 = 0 ;
7512 PyObject * obj1 = 0 ;
7513 PyObject * obj2 = 0 ;
7514 char *kwnames[] = {
7515 (char *) "self",(char *) "x",(char *) "y", NULL
7516 };
7517
7518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
7519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7520 if (SWIG_arg_fail(1)) SWIG_fail;
7521 {
7522 arg2 = static_cast<int >(SWIG_As_int(obj1));
7523 if (SWIG_arg_fail(2)) SWIG_fail;
7524 }
7525 {
7526 arg3 = static_cast<int >(SWIG_As_int(obj2));
7527 if (SWIG_arg_fail(3)) SWIG_fail;
7528 }
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 (arg1)->Move(arg2,arg3);
7532
7533 wxPyEndAllowThreads(__tstate);
7534 if (PyErr_Occurred()) SWIG_fail;
7535 }
7536 Py_INCREF(Py_None); resultobj = Py_None;
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
7544 PyObject *resultobj = NULL;
7545 wxCaret *arg1 = (wxCaret *) 0 ;
7546 wxPoint *arg2 = 0 ;
7547 wxPoint temp2 ;
7548 PyObject * obj0 = 0 ;
7549 PyObject * obj1 = 0 ;
7550 char *kwnames[] = {
7551 (char *) "self",(char *) "pt", NULL
7552 };
7553
7554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) 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 = &temp2;
7559 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7560 }
7561 {
7562 PyThreadState* __tstate = wxPyBeginAllowThreads();
7563 (arg1)->Move((wxPoint const &)*arg2);
7564
7565 wxPyEndAllowThreads(__tstate);
7566 if (PyErr_Occurred()) SWIG_fail;
7567 }
7568 Py_INCREF(Py_None); resultobj = Py_None;
7569 return resultobj;
7570 fail:
7571 return NULL;
7572 }
7573
7574
7575 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
7576 PyObject *resultobj = NULL;
7577 wxCaret *arg1 = (wxCaret *) 0 ;
7578 int arg2 ;
7579 int arg3 ;
7580 PyObject * obj0 = 0 ;
7581 PyObject * obj1 = 0 ;
7582 PyObject * obj2 = 0 ;
7583 char *kwnames[] = {
7584 (char *) "self",(char *) "width",(char *) "height", NULL
7585 };
7586
7587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
7588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7589 if (SWIG_arg_fail(1)) SWIG_fail;
7590 {
7591 arg2 = static_cast<int >(SWIG_As_int(obj1));
7592 if (SWIG_arg_fail(2)) SWIG_fail;
7593 }
7594 {
7595 arg3 = static_cast<int >(SWIG_As_int(obj2));
7596 if (SWIG_arg_fail(3)) SWIG_fail;
7597 }
7598 {
7599 PyThreadState* __tstate = wxPyBeginAllowThreads();
7600 (arg1)->SetSize(arg2,arg3);
7601
7602 wxPyEndAllowThreads(__tstate);
7603 if (PyErr_Occurred()) SWIG_fail;
7604 }
7605 Py_INCREF(Py_None); resultobj = Py_None;
7606 return resultobj;
7607 fail:
7608 return NULL;
7609 }
7610
7611
7612 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
7613 PyObject *resultobj = NULL;
7614 wxCaret *arg1 = (wxCaret *) 0 ;
7615 wxSize *arg2 = 0 ;
7616 wxSize temp2 ;
7617 PyObject * obj0 = 0 ;
7618 PyObject * obj1 = 0 ;
7619 char *kwnames[] = {
7620 (char *) "self",(char *) "size", NULL
7621 };
7622
7623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
7624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7625 if (SWIG_arg_fail(1)) SWIG_fail;
7626 {
7627 arg2 = &temp2;
7628 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
7629 }
7630 {
7631 PyThreadState* __tstate = wxPyBeginAllowThreads();
7632 (arg1)->SetSize((wxSize const &)*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_Show(PyObject *, PyObject *args, PyObject *kwargs) {
7645 PyObject *resultobj = NULL;
7646 wxCaret *arg1 = (wxCaret *) 0 ;
7647 int arg2 = (int) true ;
7648 PyObject * obj0 = 0 ;
7649 PyObject * obj1 = 0 ;
7650 char *kwnames[] = {
7651 (char *) "self",(char *) "show", NULL
7652 };
7653
7654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
7655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7656 if (SWIG_arg_fail(1)) SWIG_fail;
7657 if (obj1) {
7658 {
7659 arg2 = static_cast<int >(SWIG_As_int(obj1));
7660 if (SWIG_arg_fail(2)) SWIG_fail;
7661 }
7662 }
7663 {
7664 PyThreadState* __tstate = wxPyBeginAllowThreads();
7665 (arg1)->Show(arg2);
7666
7667 wxPyEndAllowThreads(__tstate);
7668 if (PyErr_Occurred()) SWIG_fail;
7669 }
7670 Py_INCREF(Py_None); resultobj = Py_None;
7671 return resultobj;
7672 fail:
7673 return NULL;
7674 }
7675
7676
7677 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
7678 PyObject *resultobj = NULL;
7679 wxCaret *arg1 = (wxCaret *) 0 ;
7680 PyObject * obj0 = 0 ;
7681 char *kwnames[] = {
7682 (char *) "self", NULL
7683 };
7684
7685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
7686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
7687 if (SWIG_arg_fail(1)) SWIG_fail;
7688 {
7689 PyThreadState* __tstate = wxPyBeginAllowThreads();
7690 (arg1)->Hide();
7691
7692 wxPyEndAllowThreads(__tstate);
7693 if (PyErr_Occurred()) SWIG_fail;
7694 }
7695 Py_INCREF(Py_None); resultobj = Py_None;
7696 return resultobj;
7697 fail:
7698 return NULL;
7699 }
7700
7701
7702 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
7703 PyObject *resultobj = NULL;
7704 int result;
7705 char *kwnames[] = {
7706 NULL
7707 };
7708
7709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
7710 {
7711 PyThreadState* __tstate = wxPyBeginAllowThreads();
7712 result = (int)wxCaret::GetBlinkTime();
7713
7714 wxPyEndAllowThreads(__tstate);
7715 if (PyErr_Occurred()) SWIG_fail;
7716 }
7717 {
7718 resultobj = SWIG_From_int(static_cast<int >(result));
7719 }
7720 return resultobj;
7721 fail:
7722 return NULL;
7723 }
7724
7725
7726 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
7727 PyObject *resultobj = NULL;
7728 int arg1 ;
7729 PyObject * obj0 = 0 ;
7730 char *kwnames[] = {
7731 (char *) "milliseconds", NULL
7732 };
7733
7734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
7735 {
7736 arg1 = static_cast<int >(SWIG_As_int(obj0));
7737 if (SWIG_arg_fail(1)) SWIG_fail;
7738 }
7739 {
7740 PyThreadState* __tstate = wxPyBeginAllowThreads();
7741 wxCaret::SetBlinkTime(arg1);
7742
7743 wxPyEndAllowThreads(__tstate);
7744 if (PyErr_Occurred()) SWIG_fail;
7745 }
7746 Py_INCREF(Py_None); resultobj = Py_None;
7747 return resultobj;
7748 fail:
7749 return NULL;
7750 }
7751
7752
7753 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
7754 PyObject *obj;
7755 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7756 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
7757 Py_INCREF(obj);
7758 return Py_BuildValue((char *)"");
7759 }
7760 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7761 PyObject *resultobj = NULL;
7762 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7763 wxBusyCursor *result;
7764 PyObject * obj0 = 0 ;
7765 char *kwnames[] = {
7766 (char *) "cursor", NULL
7767 };
7768
7769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
7770 if (obj0) {
7771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
7772 if (SWIG_arg_fail(1)) SWIG_fail;
7773 }
7774 {
7775 if (!wxPyCheckForApp()) SWIG_fail;
7776 PyThreadState* __tstate = wxPyBeginAllowThreads();
7777 result = (wxBusyCursor *)new wxBusyCursor(arg1);
7778
7779 wxPyEndAllowThreads(__tstate);
7780 if (PyErr_Occurred()) SWIG_fail;
7781 }
7782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
7783 return resultobj;
7784 fail:
7785 return NULL;
7786 }
7787
7788
7789 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
7790 PyObject *resultobj = NULL;
7791 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
7792 PyObject * obj0 = 0 ;
7793 char *kwnames[] = {
7794 (char *) "self", NULL
7795 };
7796
7797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
7798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
7799 if (SWIG_arg_fail(1)) SWIG_fail;
7800 {
7801 PyThreadState* __tstate = wxPyBeginAllowThreads();
7802 delete arg1;
7803
7804 wxPyEndAllowThreads(__tstate);
7805 if (PyErr_Occurred()) SWIG_fail;
7806 }
7807 Py_INCREF(Py_None); resultobj = Py_None;
7808 return resultobj;
7809 fail:
7810 return NULL;
7811 }
7812
7813
7814 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
7815 PyObject *obj;
7816 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7817 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
7818 Py_INCREF(obj);
7819 return Py_BuildValue((char *)"");
7820 }
7821 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7822 PyObject *resultobj = NULL;
7823 wxWindow *arg1 = (wxWindow *) NULL ;
7824 wxWindowDisabler *result;
7825 PyObject * obj0 = 0 ;
7826 char *kwnames[] = {
7827 (char *) "winToSkip", NULL
7828 };
7829
7830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7831 if (obj0) {
7832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7833 if (SWIG_arg_fail(1)) SWIG_fail;
7834 }
7835 {
7836 if (!wxPyCheckForApp()) SWIG_fail;
7837 PyThreadState* __tstate = wxPyBeginAllowThreads();
7838 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7839
7840 wxPyEndAllowThreads(__tstate);
7841 if (PyErr_Occurred()) SWIG_fail;
7842 }
7843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7851 PyObject *resultobj = NULL;
7852 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7853 PyObject * obj0 = 0 ;
7854 char *kwnames[] = {
7855 (char *) "self", NULL
7856 };
7857
7858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7860 if (SWIG_arg_fail(1)) SWIG_fail;
7861 {
7862 PyThreadState* __tstate = wxPyBeginAllowThreads();
7863 delete arg1;
7864
7865 wxPyEndAllowThreads(__tstate);
7866 if (PyErr_Occurred()) SWIG_fail;
7867 }
7868 Py_INCREF(Py_None); resultobj = Py_None;
7869 return resultobj;
7870 fail:
7871 return NULL;
7872 }
7873
7874
7875 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7876 PyObject *obj;
7877 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7878 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7879 Py_INCREF(obj);
7880 return Py_BuildValue((char *)"");
7881 }
7882 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7883 PyObject *resultobj = NULL;
7884 wxString *arg1 = 0 ;
7885 wxBusyInfo *result;
7886 bool temp1 = false ;
7887 PyObject * obj0 = 0 ;
7888 char *kwnames[] = {
7889 (char *) "message", NULL
7890 };
7891
7892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7893 {
7894 arg1 = wxString_in_helper(obj0);
7895 if (arg1 == NULL) SWIG_fail;
7896 temp1 = true;
7897 }
7898 {
7899 if (!wxPyCheckForApp()) SWIG_fail;
7900 PyThreadState* __tstate = wxPyBeginAllowThreads();
7901 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7902
7903 wxPyEndAllowThreads(__tstate);
7904 if (PyErr_Occurred()) SWIG_fail;
7905 }
7906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7907 {
7908 if (temp1)
7909 delete arg1;
7910 }
7911 return resultobj;
7912 fail:
7913 {
7914 if (temp1)
7915 delete arg1;
7916 }
7917 return NULL;
7918 }
7919
7920
7921 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7922 PyObject *resultobj = NULL;
7923 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7924 PyObject * obj0 = 0 ;
7925 char *kwnames[] = {
7926 (char *) "self", NULL
7927 };
7928
7929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7931 if (SWIG_arg_fail(1)) SWIG_fail;
7932 {
7933 PyThreadState* __tstate = wxPyBeginAllowThreads();
7934 delete arg1;
7935
7936 wxPyEndAllowThreads(__tstate);
7937 if (PyErr_Occurred()) SWIG_fail;
7938 }
7939 Py_INCREF(Py_None); resultobj = Py_None;
7940 return resultobj;
7941 fail:
7942 return NULL;
7943 }
7944
7945
7946 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7947 PyObject *obj;
7948 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7949 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7950 Py_INCREF(obj);
7951 return Py_BuildValue((char *)"");
7952 }
7953 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7954 PyObject *resultobj = NULL;
7955 wxStopWatch *result;
7956 char *kwnames[] = {
7957 NULL
7958 };
7959
7960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7961 {
7962 PyThreadState* __tstate = wxPyBeginAllowThreads();
7963 result = (wxStopWatch *)new wxStopWatch();
7964
7965 wxPyEndAllowThreads(__tstate);
7966 if (PyErr_Occurred()) SWIG_fail;
7967 }
7968 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7969 return resultobj;
7970 fail:
7971 return NULL;
7972 }
7973
7974
7975 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7976 PyObject *resultobj = NULL;
7977 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7978 long arg2 = (long) 0 ;
7979 PyObject * obj0 = 0 ;
7980 PyObject * obj1 = 0 ;
7981 char *kwnames[] = {
7982 (char *) "self",(char *) "t0", NULL
7983 };
7984
7985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7987 if (SWIG_arg_fail(1)) SWIG_fail;
7988 if (obj1) {
7989 {
7990 arg2 = static_cast<long >(SWIG_As_long(obj1));
7991 if (SWIG_arg_fail(2)) SWIG_fail;
7992 }
7993 }
7994 {
7995 PyThreadState* __tstate = wxPyBeginAllowThreads();
7996 (arg1)->Start(arg2);
7997
7998 wxPyEndAllowThreads(__tstate);
7999 if (PyErr_Occurred()) SWIG_fail;
8000 }
8001 Py_INCREF(Py_None); resultobj = Py_None;
8002 return resultobj;
8003 fail:
8004 return NULL;
8005 }
8006
8007
8008 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
8009 PyObject *resultobj = NULL;
8010 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
8011 PyObject * obj0 = 0 ;
8012 char *kwnames[] = {
8013 (char *) "self", NULL
8014 };
8015
8016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
8017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
8018 if (SWIG_arg_fail(1)) SWIG_fail;
8019 {
8020 PyThreadState* __tstate = wxPyBeginAllowThreads();
8021 (arg1)->Pause();
8022
8023 wxPyEndAllowThreads(__tstate);
8024 if (PyErr_Occurred()) SWIG_fail;
8025 }
8026 Py_INCREF(Py_None); resultobj = Py_None;
8027 return resultobj;
8028 fail:
8029 return NULL;
8030 }
8031
8032
8033 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8034 PyObject *resultobj = NULL;
8035 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
8036 PyObject * obj0 = 0 ;
8037 char *kwnames[] = {
8038 (char *) "self", NULL
8039 };
8040
8041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
8042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
8043 if (SWIG_arg_fail(1)) SWIG_fail;
8044 {
8045 PyThreadState* __tstate = wxPyBeginAllowThreads();
8046 (arg1)->Resume();
8047
8048 wxPyEndAllowThreads(__tstate);
8049 if (PyErr_Occurred()) SWIG_fail;
8050 }
8051 Py_INCREF(Py_None); resultobj = Py_None;
8052 return resultobj;
8053 fail:
8054 return NULL;
8055 }
8056
8057
8058 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
8059 PyObject *resultobj = NULL;
8060 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
8061 long result;
8062 PyObject * obj0 = 0 ;
8063 char *kwnames[] = {
8064 (char *) "self", NULL
8065 };
8066
8067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
8068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
8069 if (SWIG_arg_fail(1)) SWIG_fail;
8070 {
8071 PyThreadState* __tstate = wxPyBeginAllowThreads();
8072 result = (long)((wxStopWatch const *)arg1)->Time();
8073
8074 wxPyEndAllowThreads(__tstate);
8075 if (PyErr_Occurred()) SWIG_fail;
8076 }
8077 {
8078 resultobj = SWIG_From_long(static_cast<long >(result));
8079 }
8080 return resultobj;
8081 fail:
8082 return NULL;
8083 }
8084
8085
8086 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
8087 PyObject *obj;
8088 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8089 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
8090 Py_INCREF(obj);
8091 return Py_BuildValue((char *)"");
8092 }
8093 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
8094 PyObject *resultobj = NULL;
8095 int arg1 = (int) 9 ;
8096 int arg2 = (int) wxID_FILE1 ;
8097 wxFileHistory *result;
8098 PyObject * obj0 = 0 ;
8099 PyObject * obj1 = 0 ;
8100 char *kwnames[] = {
8101 (char *) "maxFiles",(char *) "idBase", NULL
8102 };
8103
8104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
8105 if (obj0) {
8106 {
8107 arg1 = static_cast<int >(SWIG_As_int(obj0));
8108 if (SWIG_arg_fail(1)) SWIG_fail;
8109 }
8110 }
8111 if (obj1) {
8112 {
8113 arg2 = static_cast<int >(SWIG_As_int(obj1));
8114 if (SWIG_arg_fail(2)) SWIG_fail;
8115 }
8116 }
8117 {
8118 PyThreadState* __tstate = wxPyBeginAllowThreads();
8119 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
8120
8121 wxPyEndAllowThreads(__tstate);
8122 if (PyErr_Occurred()) SWIG_fail;
8123 }
8124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
8125 return resultobj;
8126 fail:
8127 return NULL;
8128 }
8129
8130
8131 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
8132 PyObject *resultobj = NULL;
8133 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8134 PyObject * obj0 = 0 ;
8135 char *kwnames[] = {
8136 (char *) "self", NULL
8137 };
8138
8139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
8140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8141 if (SWIG_arg_fail(1)) SWIG_fail;
8142 {
8143 PyThreadState* __tstate = wxPyBeginAllowThreads();
8144 delete arg1;
8145
8146 wxPyEndAllowThreads(__tstate);
8147 if (PyErr_Occurred()) SWIG_fail;
8148 }
8149 Py_INCREF(Py_None); resultobj = Py_None;
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
8157 PyObject *resultobj = NULL;
8158 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8159 wxString *arg2 = 0 ;
8160 bool temp2 = false ;
8161 PyObject * obj0 = 0 ;
8162 PyObject * obj1 = 0 ;
8163 char *kwnames[] = {
8164 (char *) "self",(char *) "file", NULL
8165 };
8166
8167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
8168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8169 if (SWIG_arg_fail(1)) SWIG_fail;
8170 {
8171 arg2 = wxString_in_helper(obj1);
8172 if (arg2 == NULL) SWIG_fail;
8173 temp2 = true;
8174 }
8175 {
8176 PyThreadState* __tstate = wxPyBeginAllowThreads();
8177 (arg1)->AddFileToHistory((wxString const &)*arg2);
8178
8179 wxPyEndAllowThreads(__tstate);
8180 if (PyErr_Occurred()) SWIG_fail;
8181 }
8182 Py_INCREF(Py_None); resultobj = Py_None;
8183 {
8184 if (temp2)
8185 delete arg2;
8186 }
8187 return resultobj;
8188 fail:
8189 {
8190 if (temp2)
8191 delete arg2;
8192 }
8193 return NULL;
8194 }
8195
8196
8197 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
8198 PyObject *resultobj = NULL;
8199 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8200 int arg2 ;
8201 PyObject * obj0 = 0 ;
8202 PyObject * obj1 = 0 ;
8203 char *kwnames[] = {
8204 (char *) "self",(char *) "i", NULL
8205 };
8206
8207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
8208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8209 if (SWIG_arg_fail(1)) SWIG_fail;
8210 {
8211 arg2 = static_cast<int >(SWIG_As_int(obj1));
8212 if (SWIG_arg_fail(2)) SWIG_fail;
8213 }
8214 {
8215 PyThreadState* __tstate = wxPyBeginAllowThreads();
8216 (arg1)->RemoveFileFromHistory(arg2);
8217
8218 wxPyEndAllowThreads(__tstate);
8219 if (PyErr_Occurred()) SWIG_fail;
8220 }
8221 Py_INCREF(Py_None); resultobj = Py_None;
8222 return resultobj;
8223 fail:
8224 return NULL;
8225 }
8226
8227
8228 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
8229 PyObject *resultobj = NULL;
8230 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8231 int result;
8232 PyObject * obj0 = 0 ;
8233 char *kwnames[] = {
8234 (char *) "self", NULL
8235 };
8236
8237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
8238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8239 if (SWIG_arg_fail(1)) SWIG_fail;
8240 {
8241 PyThreadState* __tstate = wxPyBeginAllowThreads();
8242 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
8243
8244 wxPyEndAllowThreads(__tstate);
8245 if (PyErr_Occurred()) SWIG_fail;
8246 }
8247 {
8248 resultobj = SWIG_From_int(static_cast<int >(result));
8249 }
8250 return resultobj;
8251 fail:
8252 return NULL;
8253 }
8254
8255
8256 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
8257 PyObject *resultobj = NULL;
8258 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8259 wxMenu *arg2 = (wxMenu *) 0 ;
8260 PyObject * obj0 = 0 ;
8261 PyObject * obj1 = 0 ;
8262 char *kwnames[] = {
8263 (char *) "self",(char *) "menu", NULL
8264 };
8265
8266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
8267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8268 if (SWIG_arg_fail(1)) SWIG_fail;
8269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
8270 if (SWIG_arg_fail(2)) SWIG_fail;
8271 {
8272 PyThreadState* __tstate = wxPyBeginAllowThreads();
8273 (arg1)->UseMenu(arg2);
8274
8275 wxPyEndAllowThreads(__tstate);
8276 if (PyErr_Occurred()) SWIG_fail;
8277 }
8278 Py_INCREF(Py_None); resultobj = Py_None;
8279 return resultobj;
8280 fail:
8281 return NULL;
8282 }
8283
8284
8285 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
8286 PyObject *resultobj = NULL;
8287 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8288 wxMenu *arg2 = (wxMenu *) 0 ;
8289 PyObject * obj0 = 0 ;
8290 PyObject * obj1 = 0 ;
8291 char *kwnames[] = {
8292 (char *) "self",(char *) "menu", NULL
8293 };
8294
8295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
8296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8297 if (SWIG_arg_fail(1)) SWIG_fail;
8298 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
8299 if (SWIG_arg_fail(2)) SWIG_fail;
8300 {
8301 PyThreadState* __tstate = wxPyBeginAllowThreads();
8302 (arg1)->RemoveMenu(arg2);
8303
8304 wxPyEndAllowThreads(__tstate);
8305 if (PyErr_Occurred()) SWIG_fail;
8306 }
8307 Py_INCREF(Py_None); resultobj = Py_None;
8308 return resultobj;
8309 fail:
8310 return NULL;
8311 }
8312
8313
8314 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
8315 PyObject *resultobj = NULL;
8316 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8317 wxConfigBase *arg2 = 0 ;
8318 PyObject * obj0 = 0 ;
8319 PyObject * obj1 = 0 ;
8320 char *kwnames[] = {
8321 (char *) "self",(char *) "config", NULL
8322 };
8323
8324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
8325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8326 if (SWIG_arg_fail(1)) SWIG_fail;
8327 {
8328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8329 if (SWIG_arg_fail(2)) SWIG_fail;
8330 if (arg2 == NULL) {
8331 SWIG_null_ref("wxConfigBase");
8332 }
8333 if (SWIG_arg_fail(2)) SWIG_fail;
8334 }
8335 {
8336 PyThreadState* __tstate = wxPyBeginAllowThreads();
8337 (arg1)->Load(*arg2);
8338
8339 wxPyEndAllowThreads(__tstate);
8340 if (PyErr_Occurred()) SWIG_fail;
8341 }
8342 Py_INCREF(Py_None); resultobj = Py_None;
8343 return resultobj;
8344 fail:
8345 return NULL;
8346 }
8347
8348
8349 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
8350 PyObject *resultobj = NULL;
8351 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8352 wxConfigBase *arg2 = 0 ;
8353 PyObject * obj0 = 0 ;
8354 PyObject * obj1 = 0 ;
8355 char *kwnames[] = {
8356 (char *) "self",(char *) "config", NULL
8357 };
8358
8359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
8364 if (SWIG_arg_fail(2)) SWIG_fail;
8365 if (arg2 == NULL) {
8366 SWIG_null_ref("wxConfigBase");
8367 }
8368 if (SWIG_arg_fail(2)) SWIG_fail;
8369 }
8370 {
8371 PyThreadState* __tstate = wxPyBeginAllowThreads();
8372 (arg1)->Save(*arg2);
8373
8374 wxPyEndAllowThreads(__tstate);
8375 if (PyErr_Occurred()) SWIG_fail;
8376 }
8377 Py_INCREF(Py_None); resultobj = Py_None;
8378 return resultobj;
8379 fail:
8380 return NULL;
8381 }
8382
8383
8384 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
8385 PyObject *resultobj = NULL;
8386 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8387 PyObject * obj0 = 0 ;
8388 char *kwnames[] = {
8389 (char *) "self", NULL
8390 };
8391
8392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
8393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8394 if (SWIG_arg_fail(1)) SWIG_fail;
8395 {
8396 PyThreadState* __tstate = wxPyBeginAllowThreads();
8397 (arg1)->AddFilesToMenu();
8398
8399 wxPyEndAllowThreads(__tstate);
8400 if (PyErr_Occurred()) SWIG_fail;
8401 }
8402 Py_INCREF(Py_None); resultobj = Py_None;
8403 return resultobj;
8404 fail:
8405 return NULL;
8406 }
8407
8408
8409 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
8410 PyObject *resultobj = NULL;
8411 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8412 wxMenu *arg2 = (wxMenu *) 0 ;
8413 PyObject * obj0 = 0 ;
8414 PyObject * obj1 = 0 ;
8415 char *kwnames[] = {
8416 (char *) "self",(char *) "menu", NULL
8417 };
8418
8419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
8420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8421 if (SWIG_arg_fail(1)) SWIG_fail;
8422 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
8423 if (SWIG_arg_fail(2)) SWIG_fail;
8424 {
8425 PyThreadState* __tstate = wxPyBeginAllowThreads();
8426 (arg1)->AddFilesToMenu(arg2);
8427
8428 wxPyEndAllowThreads(__tstate);
8429 if (PyErr_Occurred()) SWIG_fail;
8430 }
8431 Py_INCREF(Py_None); resultobj = Py_None;
8432 return resultobj;
8433 fail:
8434 return NULL;
8435 }
8436
8437
8438 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
8439 PyObject *resultobj = NULL;
8440 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8441 int arg2 ;
8442 wxString result;
8443 PyObject * obj0 = 0 ;
8444 PyObject * obj1 = 0 ;
8445 char *kwnames[] = {
8446 (char *) "self",(char *) "i", NULL
8447 };
8448
8449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
8450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8451 if (SWIG_arg_fail(1)) SWIG_fail;
8452 {
8453 arg2 = static_cast<int >(SWIG_As_int(obj1));
8454 if (SWIG_arg_fail(2)) SWIG_fail;
8455 }
8456 {
8457 PyThreadState* __tstate = wxPyBeginAllowThreads();
8458 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
8459
8460 wxPyEndAllowThreads(__tstate);
8461 if (PyErr_Occurred()) SWIG_fail;
8462 }
8463 {
8464 #if wxUSE_UNICODE
8465 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8466 #else
8467 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8468 #endif
8469 }
8470 return resultobj;
8471 fail:
8472 return NULL;
8473 }
8474
8475
8476 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
8477 PyObject *resultobj = NULL;
8478 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
8479 int result;
8480 PyObject * obj0 = 0 ;
8481 char *kwnames[] = {
8482 (char *) "self", NULL
8483 };
8484
8485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
8486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
8487 if (SWIG_arg_fail(1)) SWIG_fail;
8488 {
8489 PyThreadState* __tstate = wxPyBeginAllowThreads();
8490 result = (int)((wxFileHistory const *)arg1)->GetCount();
8491
8492 wxPyEndAllowThreads(__tstate);
8493 if (PyErr_Occurred()) SWIG_fail;
8494 }
8495 {
8496 resultobj = SWIG_From_int(static_cast<int >(result));
8497 }
8498 return resultobj;
8499 fail:
8500 return NULL;
8501 }
8502
8503
8504 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
8505 PyObject *obj;
8506 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8507 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
8508 Py_INCREF(obj);
8509 return Py_BuildValue((char *)"");
8510 }
8511 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
8512 PyObject *resultobj = NULL;
8513 wxString *arg1 = 0 ;
8514 wxString const &arg2_defvalue = wxPyEmptyString ;
8515 wxString *arg2 = (wxString *) &arg2_defvalue ;
8516 wxSingleInstanceChecker *result;
8517 bool temp1 = false ;
8518 bool temp2 = false ;
8519 PyObject * obj0 = 0 ;
8520 PyObject * obj1 = 0 ;
8521 char *kwnames[] = {
8522 (char *) "name",(char *) "path", NULL
8523 };
8524
8525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
8526 {
8527 arg1 = wxString_in_helper(obj0);
8528 if (arg1 == NULL) SWIG_fail;
8529 temp1 = true;
8530 }
8531 if (obj1) {
8532 {
8533 arg2 = wxString_in_helper(obj1);
8534 if (arg2 == NULL) SWIG_fail;
8535 temp2 = true;
8536 }
8537 }
8538 {
8539 PyThreadState* __tstate = wxPyBeginAllowThreads();
8540 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
8541
8542 wxPyEndAllowThreads(__tstate);
8543 if (PyErr_Occurred()) SWIG_fail;
8544 }
8545 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
8546 {
8547 if (temp1)
8548 delete arg1;
8549 }
8550 {
8551 if (temp2)
8552 delete arg2;
8553 }
8554 return resultobj;
8555 fail:
8556 {
8557 if (temp1)
8558 delete arg1;
8559 }
8560 {
8561 if (temp2)
8562 delete arg2;
8563 }
8564 return NULL;
8565 }
8566
8567
8568 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
8569 PyObject *resultobj = NULL;
8570 wxSingleInstanceChecker *result;
8571 char *kwnames[] = {
8572 NULL
8573 };
8574
8575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
8576 {
8577 PyThreadState* __tstate = wxPyBeginAllowThreads();
8578 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
8579
8580 wxPyEndAllowThreads(__tstate);
8581 if (PyErr_Occurred()) SWIG_fail;
8582 }
8583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
8584 return resultobj;
8585 fail:
8586 return NULL;
8587 }
8588
8589
8590 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
8591 PyObject *resultobj = NULL;
8592 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
8593 PyObject * obj0 = 0 ;
8594 char *kwnames[] = {
8595 (char *) "self", NULL
8596 };
8597
8598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
8603 delete arg1;
8604
8605 wxPyEndAllowThreads(__tstate);
8606 if (PyErr_Occurred()) SWIG_fail;
8607 }
8608 Py_INCREF(Py_None); resultobj = Py_None;
8609 return resultobj;
8610 fail:
8611 return NULL;
8612 }
8613
8614
8615 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
8616 PyObject *resultobj = NULL;
8617 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
8618 wxString *arg2 = 0 ;
8619 wxString const &arg3_defvalue = wxPyEmptyString ;
8620 wxString *arg3 = (wxString *) &arg3_defvalue ;
8621 bool result;
8622 bool temp2 = false ;
8623 bool temp3 = false ;
8624 PyObject * obj0 = 0 ;
8625 PyObject * obj1 = 0 ;
8626 PyObject * obj2 = 0 ;
8627 char *kwnames[] = {
8628 (char *) "self",(char *) "name",(char *) "path", NULL
8629 };
8630
8631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
8632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
8633 if (SWIG_arg_fail(1)) SWIG_fail;
8634 {
8635 arg2 = wxString_in_helper(obj1);
8636 if (arg2 == NULL) SWIG_fail;
8637 temp2 = true;
8638 }
8639 if (obj2) {
8640 {
8641 arg3 = wxString_in_helper(obj2);
8642 if (arg3 == NULL) SWIG_fail;
8643 temp3 = true;
8644 }
8645 }
8646 {
8647 PyThreadState* __tstate = wxPyBeginAllowThreads();
8648 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
8649
8650 wxPyEndAllowThreads(__tstate);
8651 if (PyErr_Occurred()) SWIG_fail;
8652 }
8653 {
8654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8655 }
8656 {
8657 if (temp2)
8658 delete arg2;
8659 }
8660 {
8661 if (temp3)
8662 delete arg3;
8663 }
8664 return resultobj;
8665 fail:
8666 {
8667 if (temp2)
8668 delete arg2;
8669 }
8670 {
8671 if (temp3)
8672 delete arg3;
8673 }
8674 return NULL;
8675 }
8676
8677
8678 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8679 PyObject *resultobj = NULL;
8680 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
8681 bool result;
8682 PyObject * obj0 = 0 ;
8683 char *kwnames[] = {
8684 (char *) "self", NULL
8685 };
8686
8687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
8688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
8689 if (SWIG_arg_fail(1)) SWIG_fail;
8690 {
8691 PyThreadState* __tstate = wxPyBeginAllowThreads();
8692 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
8693
8694 wxPyEndAllowThreads(__tstate);
8695 if (PyErr_Occurred()) SWIG_fail;
8696 }
8697 {
8698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8699 }
8700 return resultobj;
8701 fail:
8702 return NULL;
8703 }
8704
8705
8706 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
8707 PyObject *obj;
8708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8709 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
8710 Py_INCREF(obj);
8711 return Py_BuildValue((char *)"");
8712 }
8713 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
8714 PyObject *resultobj = NULL;
8715 wxWindow *arg1 = (wxWindow *) 0 ;
8716 wxDC *arg2 = 0 ;
8717 bool result;
8718 PyObject * obj0 = 0 ;
8719 PyObject * obj1 = 0 ;
8720 char *kwnames[] = {
8721 (char *) "window",(char *) "dc", NULL
8722 };
8723
8724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
8725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8726 if (SWIG_arg_fail(1)) SWIG_fail;
8727 {
8728 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
8729 if (SWIG_arg_fail(2)) SWIG_fail;
8730 if (arg2 == NULL) {
8731 SWIG_null_ref("wxDC");
8732 }
8733 if (SWIG_arg_fail(2)) SWIG_fail;
8734 }
8735 {
8736 PyThreadState* __tstate = wxPyBeginAllowThreads();
8737 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
8738
8739 wxPyEndAllowThreads(__tstate);
8740 if (PyErr_Occurred()) SWIG_fail;
8741 }
8742 {
8743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8744 }
8745 return resultobj;
8746 fail:
8747 return NULL;
8748 }
8749
8750
8751 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8752 PyObject *resultobj = NULL;
8753 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8754 PyObject * obj0 = 0 ;
8755 char *kwnames[] = {
8756 (char *) "self", NULL
8757 };
8758
8759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
8760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8761 if (SWIG_arg_fail(1)) SWIG_fail;
8762 {
8763 PyThreadState* __tstate = wxPyBeginAllowThreads();
8764 delete arg1;
8765
8766 wxPyEndAllowThreads(__tstate);
8767 if (PyErr_Occurred()) SWIG_fail;
8768 }
8769 Py_INCREF(Py_None); resultobj = Py_None;
8770 return resultobj;
8771 fail:
8772 return NULL;
8773 }
8774
8775
8776 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
8777 PyObject *resultobj = NULL;
8778 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8779 wxString result;
8780 PyObject * obj0 = 0 ;
8781 char *kwnames[] = {
8782 (char *) "self", NULL
8783 };
8784
8785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
8786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8787 if (SWIG_arg_fail(1)) SWIG_fail;
8788 {
8789 PyThreadState* __tstate = wxPyBeginAllowThreads();
8790 result = (arg1)->GetTip();
8791
8792 wxPyEndAllowThreads(__tstate);
8793 if (PyErr_Occurred()) SWIG_fail;
8794 }
8795 {
8796 #if wxUSE_UNICODE
8797 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8798 #else
8799 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8800 #endif
8801 }
8802 return resultobj;
8803 fail:
8804 return NULL;
8805 }
8806
8807
8808 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
8809 PyObject *resultobj = NULL;
8810 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8811 size_t result;
8812 PyObject * obj0 = 0 ;
8813 char *kwnames[] = {
8814 (char *) "self", NULL
8815 };
8816
8817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
8818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8819 if (SWIG_arg_fail(1)) SWIG_fail;
8820 {
8821 PyThreadState* __tstate = wxPyBeginAllowThreads();
8822 result = (size_t)(arg1)->GetCurrentTip();
8823
8824 wxPyEndAllowThreads(__tstate);
8825 if (PyErr_Occurred()) SWIG_fail;
8826 }
8827 {
8828 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
8829 }
8830 return resultobj;
8831 fail:
8832 return NULL;
8833 }
8834
8835
8836 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8837 PyObject *resultobj = NULL;
8838 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8839 wxString *arg2 = 0 ;
8840 wxString result;
8841 bool temp2 = false ;
8842 PyObject * obj0 = 0 ;
8843 PyObject * obj1 = 0 ;
8844 char *kwnames[] = {
8845 (char *) "self",(char *) "tip", NULL
8846 };
8847
8848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8850 if (SWIG_arg_fail(1)) SWIG_fail;
8851 {
8852 arg2 = wxString_in_helper(obj1);
8853 if (arg2 == NULL) SWIG_fail;
8854 temp2 = true;
8855 }
8856 {
8857 PyThreadState* __tstate = wxPyBeginAllowThreads();
8858 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8859
8860 wxPyEndAllowThreads(__tstate);
8861 if (PyErr_Occurred()) SWIG_fail;
8862 }
8863 {
8864 #if wxUSE_UNICODE
8865 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8866 #else
8867 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8868 #endif
8869 }
8870 {
8871 if (temp2)
8872 delete arg2;
8873 }
8874 return resultobj;
8875 fail:
8876 {
8877 if (temp2)
8878 delete arg2;
8879 }
8880 return NULL;
8881 }
8882
8883
8884 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8885 PyObject *obj;
8886 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8887 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8888 Py_INCREF(obj);
8889 return Py_BuildValue((char *)"");
8890 }
8891 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8892 PyObject *resultobj = NULL;
8893 size_t arg1 ;
8894 wxPyTipProvider *result;
8895 PyObject * obj0 = 0 ;
8896 char *kwnames[] = {
8897 (char *) "currentTip", NULL
8898 };
8899
8900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8901 {
8902 arg1 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj0));
8903 if (SWIG_arg_fail(1)) SWIG_fail;
8904 }
8905 {
8906 PyThreadState* __tstate = wxPyBeginAllowThreads();
8907 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8908
8909 wxPyEndAllowThreads(__tstate);
8910 if (PyErr_Occurred()) SWIG_fail;
8911 }
8912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8913 return resultobj;
8914 fail:
8915 return NULL;
8916 }
8917
8918
8919 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8920 PyObject *resultobj = NULL;
8921 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8922 PyObject *arg2 = (PyObject *) 0 ;
8923 PyObject *arg3 = (PyObject *) 0 ;
8924 PyObject * obj0 = 0 ;
8925 PyObject * obj1 = 0 ;
8926 PyObject * obj2 = 0 ;
8927 char *kwnames[] = {
8928 (char *) "self",(char *) "self",(char *) "_class", NULL
8929 };
8930
8931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8933 if (SWIG_arg_fail(1)) SWIG_fail;
8934 arg2 = obj1;
8935 arg3 = obj2;
8936 {
8937 PyThreadState* __tstate = wxPyBeginAllowThreads();
8938 (arg1)->_setCallbackInfo(arg2,arg3);
8939
8940 wxPyEndAllowThreads(__tstate);
8941 if (PyErr_Occurred()) SWIG_fail;
8942 }
8943 Py_INCREF(Py_None); resultobj = Py_None;
8944 return resultobj;
8945 fail:
8946 return NULL;
8947 }
8948
8949
8950 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8951 PyObject *obj;
8952 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8953 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8954 Py_INCREF(obj);
8955 return Py_BuildValue((char *)"");
8956 }
8957 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8958 PyObject *resultobj = NULL;
8959 wxWindow *arg1 = (wxWindow *) 0 ;
8960 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8961 bool arg3 = (bool) true ;
8962 bool result;
8963 PyObject * obj0 = 0 ;
8964 PyObject * obj1 = 0 ;
8965 PyObject * obj2 = 0 ;
8966 char *kwnames[] = {
8967 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8968 };
8969
8970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8972 if (SWIG_arg_fail(1)) SWIG_fail;
8973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8974 if (SWIG_arg_fail(2)) SWIG_fail;
8975 if (obj2) {
8976 {
8977 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
8978 if (SWIG_arg_fail(3)) SWIG_fail;
8979 }
8980 }
8981 {
8982 if (!wxPyCheckForApp()) SWIG_fail;
8983 PyThreadState* __tstate = wxPyBeginAllowThreads();
8984 result = (bool)wxShowTip(arg1,arg2,arg3);
8985
8986 wxPyEndAllowThreads(__tstate);
8987 if (PyErr_Occurred()) SWIG_fail;
8988 }
8989 {
8990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8991 }
8992 return resultobj;
8993 fail:
8994 return NULL;
8995 }
8996
8997
8998 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8999 PyObject *resultobj = NULL;
9000 wxString *arg1 = 0 ;
9001 size_t arg2 ;
9002 wxTipProvider *result;
9003 bool temp1 = false ;
9004 PyObject * obj0 = 0 ;
9005 PyObject * obj1 = 0 ;
9006 char *kwnames[] = {
9007 (char *) "filename",(char *) "currentTip", NULL
9008 };
9009
9010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
9011 {
9012 arg1 = wxString_in_helper(obj0);
9013 if (arg1 == NULL) SWIG_fail;
9014 temp1 = true;
9015 }
9016 {
9017 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
9018 if (SWIG_arg_fail(2)) SWIG_fail;
9019 }
9020 {
9021 if (!wxPyCheckForApp()) SWIG_fail;
9022 PyThreadState* __tstate = wxPyBeginAllowThreads();
9023 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
9024
9025 wxPyEndAllowThreads(__tstate);
9026 if (PyErr_Occurred()) SWIG_fail;
9027 }
9028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
9029 {
9030 if (temp1)
9031 delete arg1;
9032 }
9033 return resultobj;
9034 fail:
9035 {
9036 if (temp1)
9037 delete arg1;
9038 }
9039 return NULL;
9040 }
9041
9042
9043 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
9044 PyObject *resultobj = NULL;
9045 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
9046 int arg2 = (int) -1 ;
9047 wxPyTimer *result;
9048 PyObject * obj0 = 0 ;
9049 PyObject * obj1 = 0 ;
9050 char *kwnames[] = {
9051 (char *) "owner",(char *) "id", NULL
9052 };
9053
9054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
9055 if (obj0) {
9056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
9057 if (SWIG_arg_fail(1)) SWIG_fail;
9058 }
9059 if (obj1) {
9060 {
9061 arg2 = static_cast<int >(SWIG_As_int(obj1));
9062 if (SWIG_arg_fail(2)) SWIG_fail;
9063 }
9064 }
9065 {
9066 if (!wxPyCheckForApp()) SWIG_fail;
9067 PyThreadState* __tstate = wxPyBeginAllowThreads();
9068 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
9069
9070 wxPyEndAllowThreads(__tstate);
9071 if (PyErr_Occurred()) SWIG_fail;
9072 }
9073 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
9074 return resultobj;
9075 fail:
9076 return NULL;
9077 }
9078
9079
9080 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
9081 PyObject *resultobj = NULL;
9082 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9083 PyObject * obj0 = 0 ;
9084 char *kwnames[] = {
9085 (char *) "self", NULL
9086 };
9087
9088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
9089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9090 if (SWIG_arg_fail(1)) SWIG_fail;
9091 {
9092 PyThreadState* __tstate = wxPyBeginAllowThreads();
9093 delete arg1;
9094
9095 wxPyEndAllowThreads(__tstate);
9096 if (PyErr_Occurred()) SWIG_fail;
9097 }
9098 Py_INCREF(Py_None); resultobj = Py_None;
9099 return resultobj;
9100 fail:
9101 return NULL;
9102 }
9103
9104
9105 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9106 PyObject *resultobj = NULL;
9107 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9108 PyObject *arg2 = (PyObject *) 0 ;
9109 PyObject *arg3 = (PyObject *) 0 ;
9110 int arg4 = (int) 1 ;
9111 PyObject * obj0 = 0 ;
9112 PyObject * obj1 = 0 ;
9113 PyObject * obj2 = 0 ;
9114 PyObject * obj3 = 0 ;
9115 char *kwnames[] = {
9116 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
9117 };
9118
9119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9121 if (SWIG_arg_fail(1)) SWIG_fail;
9122 arg2 = obj1;
9123 arg3 = obj2;
9124 if (obj3) {
9125 {
9126 arg4 = static_cast<int >(SWIG_As_int(obj3));
9127 if (SWIG_arg_fail(4)) SWIG_fail;
9128 }
9129 }
9130 {
9131 PyThreadState* __tstate = wxPyBeginAllowThreads();
9132 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
9133
9134 wxPyEndAllowThreads(__tstate);
9135 if (PyErr_Occurred()) SWIG_fail;
9136 }
9137 Py_INCREF(Py_None); resultobj = Py_None;
9138 return resultobj;
9139 fail:
9140 return NULL;
9141 }
9142
9143
9144 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
9145 PyObject *resultobj = NULL;
9146 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9147 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
9148 int arg3 = (int) -1 ;
9149 PyObject * obj0 = 0 ;
9150 PyObject * obj1 = 0 ;
9151 PyObject * obj2 = 0 ;
9152 char *kwnames[] = {
9153 (char *) "self",(char *) "owner",(char *) "id", NULL
9154 };
9155
9156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
9157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9158 if (SWIG_arg_fail(1)) SWIG_fail;
9159 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
9160 if (SWIG_arg_fail(2)) SWIG_fail;
9161 if (obj2) {
9162 {
9163 arg3 = static_cast<int >(SWIG_As_int(obj2));
9164 if (SWIG_arg_fail(3)) SWIG_fail;
9165 }
9166 }
9167 {
9168 PyThreadState* __tstate = wxPyBeginAllowThreads();
9169 (arg1)->SetOwner(arg2,arg3);
9170
9171 wxPyEndAllowThreads(__tstate);
9172 if (PyErr_Occurred()) SWIG_fail;
9173 }
9174 Py_INCREF(Py_None); resultobj = Py_None;
9175 return resultobj;
9176 fail:
9177 return NULL;
9178 }
9179
9180
9181 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
9182 PyObject *resultobj = NULL;
9183 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9184 wxEvtHandler *result;
9185 PyObject * obj0 = 0 ;
9186 char *kwnames[] = {
9187 (char *) "self", NULL
9188 };
9189
9190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
9191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9192 if (SWIG_arg_fail(1)) SWIG_fail;
9193 {
9194 PyThreadState* __tstate = wxPyBeginAllowThreads();
9195 result = (wxEvtHandler *)(arg1)->GetOwner();
9196
9197 wxPyEndAllowThreads(__tstate);
9198 if (PyErr_Occurred()) SWIG_fail;
9199 }
9200 {
9201 resultobj = wxPyMake_wxObject(result, 0);
9202 }
9203 return resultobj;
9204 fail:
9205 return NULL;
9206 }
9207
9208
9209 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
9210 PyObject *resultobj = NULL;
9211 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9212 int arg2 = (int) -1 ;
9213 bool arg3 = (bool) false ;
9214 bool result;
9215 PyObject * obj0 = 0 ;
9216 PyObject * obj1 = 0 ;
9217 PyObject * obj2 = 0 ;
9218 char *kwnames[] = {
9219 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
9220 };
9221
9222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
9223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9224 if (SWIG_arg_fail(1)) SWIG_fail;
9225 if (obj1) {
9226 {
9227 arg2 = static_cast<int >(SWIG_As_int(obj1));
9228 if (SWIG_arg_fail(2)) SWIG_fail;
9229 }
9230 }
9231 if (obj2) {
9232 {
9233 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
9234 if (SWIG_arg_fail(3)) SWIG_fail;
9235 }
9236 }
9237 {
9238 PyThreadState* __tstate = wxPyBeginAllowThreads();
9239 result = (bool)(arg1)->Start(arg2,arg3);
9240
9241 wxPyEndAllowThreads(__tstate);
9242 if (PyErr_Occurred()) SWIG_fail;
9243 }
9244 {
9245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9246 }
9247 return resultobj;
9248 fail:
9249 return NULL;
9250 }
9251
9252
9253 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
9254 PyObject *resultobj = NULL;
9255 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9256 PyObject * obj0 = 0 ;
9257 char *kwnames[] = {
9258 (char *) "self", NULL
9259 };
9260
9261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
9262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9263 if (SWIG_arg_fail(1)) SWIG_fail;
9264 {
9265 PyThreadState* __tstate = wxPyBeginAllowThreads();
9266 (arg1)->Stop();
9267
9268 wxPyEndAllowThreads(__tstate);
9269 if (PyErr_Occurred()) SWIG_fail;
9270 }
9271 Py_INCREF(Py_None); resultobj = Py_None;
9272 return resultobj;
9273 fail:
9274 return NULL;
9275 }
9276
9277
9278 static PyObject *_wrap_Timer_Notify(PyObject *, PyObject *args, PyObject *kwargs) {
9279 PyObject *resultobj = NULL;
9280 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9281 PyObject * obj0 = 0 ;
9282 char *kwnames[] = {
9283 (char *) "self", NULL
9284 };
9285
9286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Notify",kwnames,&obj0)) goto fail;
9287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9288 if (SWIG_arg_fail(1)) SWIG_fail;
9289 {
9290 PyThreadState* __tstate = wxPyBeginAllowThreads();
9291 (arg1)->Notify();
9292
9293 wxPyEndAllowThreads(__tstate);
9294 if (PyErr_Occurred()) SWIG_fail;
9295 }
9296 Py_INCREF(Py_None); resultobj = Py_None;
9297 return resultobj;
9298 fail:
9299 return NULL;
9300 }
9301
9302
9303 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
9304 PyObject *resultobj = NULL;
9305 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9306 bool result;
9307 PyObject * obj0 = 0 ;
9308 char *kwnames[] = {
9309 (char *) "self", NULL
9310 };
9311
9312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
9313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9314 if (SWIG_arg_fail(1)) SWIG_fail;
9315 {
9316 PyThreadState* __tstate = wxPyBeginAllowThreads();
9317 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
9318
9319 wxPyEndAllowThreads(__tstate);
9320 if (PyErr_Occurred()) SWIG_fail;
9321 }
9322 {
9323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9324 }
9325 return resultobj;
9326 fail:
9327 return NULL;
9328 }
9329
9330
9331 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
9332 PyObject *resultobj = NULL;
9333 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9334 int result;
9335 PyObject * obj0 = 0 ;
9336 char *kwnames[] = {
9337 (char *) "self", NULL
9338 };
9339
9340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
9341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9342 if (SWIG_arg_fail(1)) SWIG_fail;
9343 {
9344 PyThreadState* __tstate = wxPyBeginAllowThreads();
9345 result = (int)((wxPyTimer const *)arg1)->GetInterval();
9346
9347 wxPyEndAllowThreads(__tstate);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 {
9351 resultobj = SWIG_From_int(static_cast<int >(result));
9352 }
9353 return resultobj;
9354 fail:
9355 return NULL;
9356 }
9357
9358
9359 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
9360 PyObject *resultobj = NULL;
9361 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9362 bool result;
9363 PyObject * obj0 = 0 ;
9364 char *kwnames[] = {
9365 (char *) "self", NULL
9366 };
9367
9368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
9369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9370 if (SWIG_arg_fail(1)) SWIG_fail;
9371 {
9372 PyThreadState* __tstate = wxPyBeginAllowThreads();
9373 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
9374
9375 wxPyEndAllowThreads(__tstate);
9376 if (PyErr_Occurred()) SWIG_fail;
9377 }
9378 {
9379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9380 }
9381 return resultobj;
9382 fail:
9383 return NULL;
9384 }
9385
9386
9387 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
9388 PyObject *resultobj = NULL;
9389 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
9390 int result;
9391 PyObject * obj0 = 0 ;
9392 char *kwnames[] = {
9393 (char *) "self", NULL
9394 };
9395
9396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
9397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
9398 if (SWIG_arg_fail(1)) SWIG_fail;
9399 {
9400 PyThreadState* __tstate = wxPyBeginAllowThreads();
9401 result = (int)((wxPyTimer const *)arg1)->GetId();
9402
9403 wxPyEndAllowThreads(__tstate);
9404 if (PyErr_Occurred()) SWIG_fail;
9405 }
9406 {
9407 resultobj = SWIG_From_int(static_cast<int >(result));
9408 }
9409 return resultobj;
9410 fail:
9411 return NULL;
9412 }
9413
9414
9415 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
9416 PyObject *obj;
9417 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9418 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
9419 Py_INCREF(obj);
9420 return Py_BuildValue((char *)"");
9421 }
9422 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
9423 PyObject *resultobj = NULL;
9424 int arg1 = (int) 0 ;
9425 int arg2 = (int) 0 ;
9426 wxTimerEvent *result;
9427 PyObject * obj0 = 0 ;
9428 PyObject * obj1 = 0 ;
9429 char *kwnames[] = {
9430 (char *) "timerid",(char *) "interval", NULL
9431 };
9432
9433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
9434 if (obj0) {
9435 {
9436 arg1 = static_cast<int >(SWIG_As_int(obj0));
9437 if (SWIG_arg_fail(1)) SWIG_fail;
9438 }
9439 }
9440 if (obj1) {
9441 {
9442 arg2 = static_cast<int >(SWIG_As_int(obj1));
9443 if (SWIG_arg_fail(2)) SWIG_fail;
9444 }
9445 }
9446 {
9447 PyThreadState* __tstate = wxPyBeginAllowThreads();
9448 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
9449
9450 wxPyEndAllowThreads(__tstate);
9451 if (PyErr_Occurred()) SWIG_fail;
9452 }
9453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
9454 return resultobj;
9455 fail:
9456 return NULL;
9457 }
9458
9459
9460 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
9461 PyObject *resultobj = NULL;
9462 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
9463 int result;
9464 PyObject * obj0 = 0 ;
9465 char *kwnames[] = {
9466 (char *) "self", NULL
9467 };
9468
9469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
9470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
9471 if (SWIG_arg_fail(1)) SWIG_fail;
9472 {
9473 PyThreadState* __tstate = wxPyBeginAllowThreads();
9474 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
9475
9476 wxPyEndAllowThreads(__tstate);
9477 if (PyErr_Occurred()) SWIG_fail;
9478 }
9479 {
9480 resultobj = SWIG_From_int(static_cast<int >(result));
9481 }
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
9489 PyObject *obj;
9490 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9491 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
9492 Py_INCREF(obj);
9493 return Py_BuildValue((char *)"");
9494 }
9495 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
9496 PyObject *resultobj = NULL;
9497 wxTimer *arg1 = 0 ;
9498 wxTimerRunner *result;
9499 PyObject * obj0 = 0 ;
9500
9501 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
9502 {
9503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
9504 if (SWIG_arg_fail(1)) SWIG_fail;
9505 if (arg1 == NULL) {
9506 SWIG_null_ref("wxTimer");
9507 }
9508 if (SWIG_arg_fail(1)) SWIG_fail;
9509 }
9510 {
9511 if (!wxPyCheckForApp()) SWIG_fail;
9512 PyThreadState* __tstate = wxPyBeginAllowThreads();
9513 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
9514
9515 wxPyEndAllowThreads(__tstate);
9516 if (PyErr_Occurred()) SWIG_fail;
9517 }
9518 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
9519 return resultobj;
9520 fail:
9521 return NULL;
9522 }
9523
9524
9525 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
9526 PyObject *resultobj = NULL;
9527 wxTimer *arg1 = 0 ;
9528 int arg2 ;
9529 bool arg3 = (bool) false ;
9530 wxTimerRunner *result;
9531 PyObject * obj0 = 0 ;
9532 PyObject * obj1 = 0 ;
9533 PyObject * obj2 = 0 ;
9534
9535 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
9536 {
9537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
9538 if (SWIG_arg_fail(1)) SWIG_fail;
9539 if (arg1 == NULL) {
9540 SWIG_null_ref("wxTimer");
9541 }
9542 if (SWIG_arg_fail(1)) SWIG_fail;
9543 }
9544 {
9545 arg2 = static_cast<int >(SWIG_As_int(obj1));
9546 if (SWIG_arg_fail(2)) SWIG_fail;
9547 }
9548 if (obj2) {
9549 {
9550 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
9551 if (SWIG_arg_fail(3)) SWIG_fail;
9552 }
9553 }
9554 {
9555 if (!wxPyCheckForApp()) SWIG_fail;
9556 PyThreadState* __tstate = wxPyBeginAllowThreads();
9557 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
9558
9559 wxPyEndAllowThreads(__tstate);
9560 if (PyErr_Occurred()) SWIG_fail;
9561 }
9562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
9563 return resultobj;
9564 fail:
9565 return NULL;
9566 }
9567
9568
9569 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
9570 int argc;
9571 PyObject *argv[4];
9572 int ii;
9573
9574 argc = PyObject_Length(args);
9575 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
9576 argv[ii] = PyTuple_GetItem(args,ii);
9577 }
9578 if (argc == 1) {
9579 int _v;
9580 {
9581 void *ptr = 0;
9582 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
9583 _v = 0;
9584 PyErr_Clear();
9585 } else {
9586 _v = (ptr != 0);
9587 }
9588 }
9589 if (_v) {
9590 return _wrap_new_TimerRunner__SWIG_0(self,args);
9591 }
9592 }
9593 if ((argc >= 2) && (argc <= 3)) {
9594 int _v;
9595 {
9596 void *ptr = 0;
9597 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
9598 _v = 0;
9599 PyErr_Clear();
9600 } else {
9601 _v = (ptr != 0);
9602 }
9603 }
9604 if (_v) {
9605 _v = SWIG_Check_int(argv[1]);
9606 if (_v) {
9607 if (argc <= 2) {
9608 return _wrap_new_TimerRunner__SWIG_1(self,args);
9609 }
9610 _v = SWIG_Check_bool(argv[2]);
9611 if (_v) {
9612 return _wrap_new_TimerRunner__SWIG_1(self,args);
9613 }
9614 }
9615 }
9616 }
9617
9618 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
9619 return NULL;
9620 }
9621
9622
9623 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
9624 PyObject *resultobj = NULL;
9625 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
9626 PyObject * obj0 = 0 ;
9627 char *kwnames[] = {
9628 (char *) "self", NULL
9629 };
9630
9631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
9632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
9633 if (SWIG_arg_fail(1)) SWIG_fail;
9634 {
9635 PyThreadState* __tstate = wxPyBeginAllowThreads();
9636 delete arg1;
9637
9638 wxPyEndAllowThreads(__tstate);
9639 if (PyErr_Occurred()) SWIG_fail;
9640 }
9641 Py_INCREF(Py_None); resultobj = Py_None;
9642 return resultobj;
9643 fail:
9644 return NULL;
9645 }
9646
9647
9648 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
9649 PyObject *resultobj = NULL;
9650 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
9651 int arg2 ;
9652 bool arg3 = (bool) false ;
9653 PyObject * obj0 = 0 ;
9654 PyObject * obj1 = 0 ;
9655 PyObject * obj2 = 0 ;
9656 char *kwnames[] = {
9657 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
9658 };
9659
9660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
9661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
9662 if (SWIG_arg_fail(1)) SWIG_fail;
9663 {
9664 arg2 = static_cast<int >(SWIG_As_int(obj1));
9665 if (SWIG_arg_fail(2)) SWIG_fail;
9666 }
9667 if (obj2) {
9668 {
9669 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
9670 if (SWIG_arg_fail(3)) SWIG_fail;
9671 }
9672 }
9673 {
9674 PyThreadState* __tstate = wxPyBeginAllowThreads();
9675 (arg1)->Start(arg2,arg3);
9676
9677 wxPyEndAllowThreads(__tstate);
9678 if (PyErr_Occurred()) SWIG_fail;
9679 }
9680 Py_INCREF(Py_None); resultobj = Py_None;
9681 return resultobj;
9682 fail:
9683 return NULL;
9684 }
9685
9686
9687 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
9688 PyObject *obj;
9689 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9690 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
9691 Py_INCREF(obj);
9692 return Py_BuildValue((char *)"");
9693 }
9694 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
9695 PyObject *resultobj = NULL;
9696 wxLog *result;
9697 char *kwnames[] = {
9698 NULL
9699 };
9700
9701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
9702 {
9703 PyThreadState* __tstate = wxPyBeginAllowThreads();
9704 result = (wxLog *)new wxLog();
9705
9706 wxPyEndAllowThreads(__tstate);
9707 if (PyErr_Occurred()) SWIG_fail;
9708 }
9709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
9710 return resultobj;
9711 fail:
9712 return NULL;
9713 }
9714
9715
9716 static PyObject *_wrap_delete_Log(PyObject *, PyObject *args, PyObject *kwargs) {
9717 PyObject *resultobj = NULL;
9718 wxLog *arg1 = (wxLog *) 0 ;
9719 PyObject * obj0 = 0 ;
9720 char *kwnames[] = {
9721 (char *) "self", NULL
9722 };
9723
9724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Log",kwnames,&obj0)) goto fail;
9725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9726 if (SWIG_arg_fail(1)) SWIG_fail;
9727 {
9728 PyThreadState* __tstate = wxPyBeginAllowThreads();
9729 delete arg1;
9730
9731 wxPyEndAllowThreads(__tstate);
9732 if (PyErr_Occurred()) SWIG_fail;
9733 }
9734 Py_INCREF(Py_None); resultobj = Py_None;
9735 return resultobj;
9736 fail:
9737 return NULL;
9738 }
9739
9740
9741 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
9742 PyObject *resultobj = NULL;
9743 bool result;
9744 char *kwnames[] = {
9745 NULL
9746 };
9747
9748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
9749 {
9750 PyThreadState* __tstate = wxPyBeginAllowThreads();
9751 result = (bool)wxLog::IsEnabled();
9752
9753 wxPyEndAllowThreads(__tstate);
9754 if (PyErr_Occurred()) SWIG_fail;
9755 }
9756 {
9757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9758 }
9759 return resultobj;
9760 fail:
9761 return NULL;
9762 }
9763
9764
9765 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
9766 PyObject *resultobj = NULL;
9767 bool arg1 = (bool) true ;
9768 bool result;
9769 PyObject * obj0 = 0 ;
9770 char *kwnames[] = {
9771 (char *) "doIt", NULL
9772 };
9773
9774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
9775 if (obj0) {
9776 {
9777 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
9778 if (SWIG_arg_fail(1)) SWIG_fail;
9779 }
9780 }
9781 {
9782 PyThreadState* __tstate = wxPyBeginAllowThreads();
9783 result = (bool)wxLog::EnableLogging(arg1);
9784
9785 wxPyEndAllowThreads(__tstate);
9786 if (PyErr_Occurred()) SWIG_fail;
9787 }
9788 {
9789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9790 }
9791 return resultobj;
9792 fail:
9793 return NULL;
9794 }
9795
9796
9797 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
9798 PyObject *resultobj = NULL;
9799 wxLogLevel arg1 ;
9800 wxChar *arg2 = (wxChar *) 0 ;
9801 time_t arg3 ;
9802 PyObject * obj0 = 0 ;
9803 PyObject * obj1 = 0 ;
9804 PyObject * obj2 = 0 ;
9805 char *kwnames[] = {
9806 (char *) "level",(char *) "szString",(char *) "t", NULL
9807 };
9808
9809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
9810 {
9811 arg1 = static_cast<wxLogLevel >(SWIG_As_unsigned_SS_long(obj0));
9812 if (SWIG_arg_fail(1)) SWIG_fail;
9813 }
9814 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9815 if (SWIG_arg_fail(2)) SWIG_fail;
9816 {
9817 arg3 = static_cast<time_t >(SWIG_As_unsigned_SS_int(obj2));
9818 if (SWIG_arg_fail(3)) SWIG_fail;
9819 }
9820 {
9821 PyThreadState* __tstate = wxPyBeginAllowThreads();
9822 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
9823
9824 wxPyEndAllowThreads(__tstate);
9825 if (PyErr_Occurred()) SWIG_fail;
9826 }
9827 Py_INCREF(Py_None); resultobj = Py_None;
9828 return resultobj;
9829 fail:
9830 return NULL;
9831 }
9832
9833
9834 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
9835 PyObject *resultobj = NULL;
9836 wxLog *arg1 = (wxLog *) 0 ;
9837 PyObject * obj0 = 0 ;
9838 char *kwnames[] = {
9839 (char *) "self", NULL
9840 };
9841
9842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
9843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9844 if (SWIG_arg_fail(1)) SWIG_fail;
9845 {
9846 PyThreadState* __tstate = wxPyBeginAllowThreads();
9847 (arg1)->Flush();
9848
9849 wxPyEndAllowThreads(__tstate);
9850 if (PyErr_Occurred()) SWIG_fail;
9851 }
9852 Py_INCREF(Py_None); resultobj = Py_None;
9853 return resultobj;
9854 fail:
9855 return NULL;
9856 }
9857
9858
9859 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
9860 PyObject *resultobj = NULL;
9861 char *kwnames[] = {
9862 NULL
9863 };
9864
9865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
9866 {
9867 PyThreadState* __tstate = wxPyBeginAllowThreads();
9868 wxLog::FlushActive();
9869
9870 wxPyEndAllowThreads(__tstate);
9871 if (PyErr_Occurred()) SWIG_fail;
9872 }
9873 Py_INCREF(Py_None); resultobj = Py_None;
9874 return resultobj;
9875 fail:
9876 return NULL;
9877 }
9878
9879
9880 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9881 PyObject *resultobj = NULL;
9882 wxLog *result;
9883 char *kwnames[] = {
9884 NULL
9885 };
9886
9887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9888 {
9889 PyThreadState* __tstate = wxPyBeginAllowThreads();
9890 result = (wxLog *)wxLog::GetActiveTarget();
9891
9892 wxPyEndAllowThreads(__tstate);
9893 if (PyErr_Occurred()) SWIG_fail;
9894 }
9895 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9896 return resultobj;
9897 fail:
9898 return NULL;
9899 }
9900
9901
9902 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9903 PyObject *resultobj = NULL;
9904 wxLog *arg1 = (wxLog *) 0 ;
9905 wxLog *result;
9906 PyObject * obj0 = 0 ;
9907 char *kwnames[] = {
9908 (char *) "pLogger", NULL
9909 };
9910
9911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
9913 if (SWIG_arg_fail(1)) SWIG_fail;
9914 {
9915 PyThreadState* __tstate = wxPyBeginAllowThreads();
9916 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9917
9918 wxPyEndAllowThreads(__tstate);
9919 if (PyErr_Occurred()) SWIG_fail;
9920 }
9921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
9922 return resultobj;
9923 fail:
9924 return NULL;
9925 }
9926
9927
9928 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9929 PyObject *resultobj = NULL;
9930 char *kwnames[] = {
9931 NULL
9932 };
9933
9934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9935 {
9936 PyThreadState* __tstate = wxPyBeginAllowThreads();
9937 wxLog::Suspend();
9938
9939 wxPyEndAllowThreads(__tstate);
9940 if (PyErr_Occurred()) SWIG_fail;
9941 }
9942 Py_INCREF(Py_None); resultobj = Py_None;
9943 return resultobj;
9944 fail:
9945 return NULL;
9946 }
9947
9948
9949 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9950 PyObject *resultobj = NULL;
9951 char *kwnames[] = {
9952 NULL
9953 };
9954
9955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9956 {
9957 PyThreadState* __tstate = wxPyBeginAllowThreads();
9958 wxLog::Resume();
9959
9960 wxPyEndAllowThreads(__tstate);
9961 if (PyErr_Occurred()) SWIG_fail;
9962 }
9963 Py_INCREF(Py_None); resultobj = Py_None;
9964 return resultobj;
9965 fail:
9966 return NULL;
9967 }
9968
9969
9970 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9971 PyObject *resultobj = NULL;
9972 bool arg1 = (bool) true ;
9973 PyObject * obj0 = 0 ;
9974 char *kwnames[] = {
9975 (char *) "bVerbose", NULL
9976 };
9977
9978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9979 if (obj0) {
9980 {
9981 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
9982 if (SWIG_arg_fail(1)) SWIG_fail;
9983 }
9984 }
9985 {
9986 PyThreadState* __tstate = wxPyBeginAllowThreads();
9987 wxLog::SetVerbose(arg1);
9988
9989 wxPyEndAllowThreads(__tstate);
9990 if (PyErr_Occurred()) SWIG_fail;
9991 }
9992 Py_INCREF(Py_None); resultobj = Py_None;
9993 return resultobj;
9994 fail:
9995 return NULL;
9996 }
9997
9998
9999 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
10000 PyObject *resultobj = NULL;
10001 wxLogLevel arg1 ;
10002 PyObject * obj0 = 0 ;
10003 char *kwnames[] = {
10004 (char *) "logLevel", NULL
10005 };
10006
10007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
10008 {
10009 arg1 = static_cast<wxLogLevel >(SWIG_As_unsigned_SS_long(obj0));
10010 if (SWIG_arg_fail(1)) SWIG_fail;
10011 }
10012 {
10013 PyThreadState* __tstate = wxPyBeginAllowThreads();
10014 wxLog::SetLogLevel(arg1);
10015
10016 wxPyEndAllowThreads(__tstate);
10017 if (PyErr_Occurred()) SWIG_fail;
10018 }
10019 Py_INCREF(Py_None); resultobj = Py_None;
10020 return resultobj;
10021 fail:
10022 return NULL;
10023 }
10024
10025
10026 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
10027 PyObject *resultobj = NULL;
10028 char *kwnames[] = {
10029 NULL
10030 };
10031
10032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
10033 {
10034 PyThreadState* __tstate = wxPyBeginAllowThreads();
10035 wxLog::DontCreateOnDemand();
10036
10037 wxPyEndAllowThreads(__tstate);
10038 if (PyErr_Occurred()) SWIG_fail;
10039 }
10040 Py_INCREF(Py_None); resultobj = Py_None;
10041 return resultobj;
10042 fail:
10043 return NULL;
10044 }
10045
10046
10047 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10048 PyObject *resultobj = NULL;
10049 wxTraceMask arg1 ;
10050 PyObject * obj0 = 0 ;
10051 char *kwnames[] = {
10052 (char *) "ulMask", NULL
10053 };
10054
10055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
10056 {
10057 arg1 = static_cast<wxTraceMask >(SWIG_As_unsigned_SS_long(obj0));
10058 if (SWIG_arg_fail(1)) SWIG_fail;
10059 }
10060 {
10061 PyThreadState* __tstate = wxPyBeginAllowThreads();
10062 wxLog::SetTraceMask(arg1);
10063
10064 wxPyEndAllowThreads(__tstate);
10065 if (PyErr_Occurred()) SWIG_fail;
10066 }
10067 Py_INCREF(Py_None); resultobj = Py_None;
10068 return resultobj;
10069 fail:
10070 return NULL;
10071 }
10072
10073
10074 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10075 PyObject *resultobj = NULL;
10076 wxString *arg1 = 0 ;
10077 bool temp1 = false ;
10078 PyObject * obj0 = 0 ;
10079 char *kwnames[] = {
10080 (char *) "str", NULL
10081 };
10082
10083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
10084 {
10085 arg1 = wxString_in_helper(obj0);
10086 if (arg1 == NULL) SWIG_fail;
10087 temp1 = true;
10088 }
10089 {
10090 PyThreadState* __tstate = wxPyBeginAllowThreads();
10091 wxLog::AddTraceMask((wxString const &)*arg1);
10092
10093 wxPyEndAllowThreads(__tstate);
10094 if (PyErr_Occurred()) SWIG_fail;
10095 }
10096 Py_INCREF(Py_None); resultobj = Py_None;
10097 {
10098 if (temp1)
10099 delete arg1;
10100 }
10101 return resultobj;
10102 fail:
10103 {
10104 if (temp1)
10105 delete arg1;
10106 }
10107 return NULL;
10108 }
10109
10110
10111 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10112 PyObject *resultobj = NULL;
10113 wxString *arg1 = 0 ;
10114 bool temp1 = false ;
10115 PyObject * obj0 = 0 ;
10116 char *kwnames[] = {
10117 (char *) "str", NULL
10118 };
10119
10120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
10121 {
10122 arg1 = wxString_in_helper(obj0);
10123 if (arg1 == NULL) SWIG_fail;
10124 temp1 = true;
10125 }
10126 {
10127 PyThreadState* __tstate = wxPyBeginAllowThreads();
10128 wxLog::RemoveTraceMask((wxString const &)*arg1);
10129
10130 wxPyEndAllowThreads(__tstate);
10131 if (PyErr_Occurred()) SWIG_fail;
10132 }
10133 Py_INCREF(Py_None); resultobj = Py_None;
10134 {
10135 if (temp1)
10136 delete arg1;
10137 }
10138 return resultobj;
10139 fail:
10140 {
10141 if (temp1)
10142 delete arg1;
10143 }
10144 return NULL;
10145 }
10146
10147
10148 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
10149 PyObject *resultobj = NULL;
10150 char *kwnames[] = {
10151 NULL
10152 };
10153
10154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
10155 {
10156 PyThreadState* __tstate = wxPyBeginAllowThreads();
10157 wxLog::ClearTraceMasks();
10158
10159 wxPyEndAllowThreads(__tstate);
10160 if (PyErr_Occurred()) SWIG_fail;
10161 }
10162 Py_INCREF(Py_None); resultobj = Py_None;
10163 return resultobj;
10164 fail:
10165 return NULL;
10166 }
10167
10168
10169 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
10170 PyObject *resultobj = NULL;
10171 wxArrayString *result;
10172 char *kwnames[] = {
10173 NULL
10174 };
10175
10176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
10177 {
10178 PyThreadState* __tstate = wxPyBeginAllowThreads();
10179 {
10180 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
10181 result = (wxArrayString *) &_result_ref;
10182 }
10183
10184 wxPyEndAllowThreads(__tstate);
10185 if (PyErr_Occurred()) SWIG_fail;
10186 }
10187 {
10188 resultobj = wxArrayString2PyList_helper(*result);
10189 }
10190 return resultobj;
10191 fail:
10192 return NULL;
10193 }
10194
10195
10196 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
10197 PyObject *resultobj = NULL;
10198 wxChar *arg1 = (wxChar *) 0 ;
10199 PyObject * obj0 = 0 ;
10200 char *kwnames[] = {
10201 (char *) "ts", NULL
10202 };
10203
10204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
10205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
10206 if (SWIG_arg_fail(1)) SWIG_fail;
10207 {
10208 PyThreadState* __tstate = wxPyBeginAllowThreads();
10209 wxLog::SetTimestamp((wxChar const *)arg1);
10210
10211 wxPyEndAllowThreads(__tstate);
10212 if (PyErr_Occurred()) SWIG_fail;
10213 }
10214 Py_INCREF(Py_None); resultobj = Py_None;
10215 return resultobj;
10216 fail:
10217 return NULL;
10218 }
10219
10220
10221 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10222 PyObject *resultobj = NULL;
10223 bool result;
10224 char *kwnames[] = {
10225 NULL
10226 };
10227
10228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
10229 {
10230 PyThreadState* __tstate = wxPyBeginAllowThreads();
10231 result = (bool)wxLog::GetVerbose();
10232
10233 wxPyEndAllowThreads(__tstate);
10234 if (PyErr_Occurred()) SWIG_fail;
10235 }
10236 {
10237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10238 }
10239 return resultobj;
10240 fail:
10241 return NULL;
10242 }
10243
10244
10245 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10246 PyObject *resultobj = NULL;
10247 wxTraceMask result;
10248 char *kwnames[] = {
10249 NULL
10250 };
10251
10252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
10253 {
10254 PyThreadState* __tstate = wxPyBeginAllowThreads();
10255 result = (wxTraceMask)wxLog::GetTraceMask();
10256
10257 wxPyEndAllowThreads(__tstate);
10258 if (PyErr_Occurred()) SWIG_fail;
10259 }
10260 {
10261 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10262 }
10263 return resultobj;
10264 fail:
10265 return NULL;
10266 }
10267
10268
10269 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
10270 PyObject *resultobj = NULL;
10271 wxChar *arg1 = (wxChar *) 0 ;
10272 bool result;
10273 PyObject * obj0 = 0 ;
10274 char *kwnames[] = {
10275 (char *) "mask", NULL
10276 };
10277
10278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
10279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
10280 if (SWIG_arg_fail(1)) SWIG_fail;
10281 {
10282 PyThreadState* __tstate = wxPyBeginAllowThreads();
10283 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
10284
10285 wxPyEndAllowThreads(__tstate);
10286 if (PyErr_Occurred()) SWIG_fail;
10287 }
10288 {
10289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10290 }
10291 return resultobj;
10292 fail:
10293 return NULL;
10294 }
10295
10296
10297 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
10298 PyObject *resultobj = NULL;
10299 wxLogLevel result;
10300 char *kwnames[] = {
10301 NULL
10302 };
10303
10304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
10305 {
10306 PyThreadState* __tstate = wxPyBeginAllowThreads();
10307 result = (wxLogLevel)wxLog::GetLogLevel();
10308
10309 wxPyEndAllowThreads(__tstate);
10310 if (PyErr_Occurred()) SWIG_fail;
10311 }
10312 {
10313 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10314 }
10315 return resultobj;
10316 fail:
10317 return NULL;
10318 }
10319
10320
10321 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
10322 PyObject *resultobj = NULL;
10323 wxChar *result;
10324 char *kwnames[] = {
10325 NULL
10326 };
10327
10328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
10329 {
10330 PyThreadState* __tstate = wxPyBeginAllowThreads();
10331 result = (wxChar *)wxLog::GetTimestamp();
10332
10333 wxPyEndAllowThreads(__tstate);
10334 if (PyErr_Occurred()) SWIG_fail;
10335 }
10336 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
10337 return resultobj;
10338 fail:
10339 return NULL;
10340 }
10341
10342
10343 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
10344 PyObject *resultobj = NULL;
10345 wxString result;
10346 char *kwnames[] = {
10347 NULL
10348 };
10349
10350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
10351 {
10352 PyThreadState* __tstate = wxPyBeginAllowThreads();
10353 result = wxLog_TimeStamp();
10354
10355 wxPyEndAllowThreads(__tstate);
10356 if (PyErr_Occurred()) SWIG_fail;
10357 }
10358 {
10359 #if wxUSE_UNICODE
10360 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10361 #else
10362 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10363 #endif
10364 }
10365 return resultobj;
10366 fail:
10367 return NULL;
10368 }
10369
10370
10371 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10372 PyObject *resultobj = NULL;
10373 wxLog *arg1 = (wxLog *) 0 ;
10374 PyObject * obj0 = 0 ;
10375 char *kwnames[] = {
10376 (char *) "self", NULL
10377 };
10378
10379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
10380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
10381 if (SWIG_arg_fail(1)) SWIG_fail;
10382 {
10383 PyThreadState* __tstate = wxPyBeginAllowThreads();
10384 wxLog_Destroy(arg1);
10385
10386 wxPyEndAllowThreads(__tstate);
10387 if (PyErr_Occurred()) SWIG_fail;
10388 }
10389 Py_INCREF(Py_None); resultobj = Py_None;
10390 return resultobj;
10391 fail:
10392 return NULL;
10393 }
10394
10395
10396 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
10397 PyObject *obj;
10398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10399 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
10400 Py_INCREF(obj);
10401 return Py_BuildValue((char *)"");
10402 }
10403 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
10404 PyObject *resultobj = NULL;
10405 wxLogStderr *result;
10406 char *kwnames[] = {
10407 NULL
10408 };
10409
10410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
10411 {
10412 PyThreadState* __tstate = wxPyBeginAllowThreads();
10413 result = (wxLogStderr *)new wxLogStderr();
10414
10415 wxPyEndAllowThreads(__tstate);
10416 if (PyErr_Occurred()) SWIG_fail;
10417 }
10418 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
10419 return resultobj;
10420 fail:
10421 return NULL;
10422 }
10423
10424
10425 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
10426 PyObject *obj;
10427 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10428 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
10429 Py_INCREF(obj);
10430 return Py_BuildValue((char *)"");
10431 }
10432 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
10433 PyObject *resultobj = NULL;
10434 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
10435 wxLogTextCtrl *result;
10436 PyObject * obj0 = 0 ;
10437 char *kwnames[] = {
10438 (char *) "pTextCtrl", NULL
10439 };
10440
10441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
10442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
10443 if (SWIG_arg_fail(1)) SWIG_fail;
10444 {
10445 PyThreadState* __tstate = wxPyBeginAllowThreads();
10446 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
10447
10448 wxPyEndAllowThreads(__tstate);
10449 if (PyErr_Occurred()) SWIG_fail;
10450 }
10451 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
10452 return resultobj;
10453 fail:
10454 return NULL;
10455 }
10456
10457
10458 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
10459 PyObject *obj;
10460 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10461 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
10462 Py_INCREF(obj);
10463 return Py_BuildValue((char *)"");
10464 }
10465 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
10466 PyObject *resultobj = NULL;
10467 wxLogGui *result;
10468 char *kwnames[] = {
10469 NULL
10470 };
10471
10472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
10473 {
10474 PyThreadState* __tstate = wxPyBeginAllowThreads();
10475 result = (wxLogGui *)new wxLogGui();
10476
10477 wxPyEndAllowThreads(__tstate);
10478 if (PyErr_Occurred()) SWIG_fail;
10479 }
10480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
10481 return resultobj;
10482 fail:
10483 return NULL;
10484 }
10485
10486
10487 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
10488 PyObject *obj;
10489 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10490 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
10491 Py_INCREF(obj);
10492 return Py_BuildValue((char *)"");
10493 }
10494 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
10495 PyObject *resultobj = NULL;
10496 wxFrame *arg1 = (wxFrame *) 0 ;
10497 wxString *arg2 = 0 ;
10498 bool arg3 = (bool) true ;
10499 bool arg4 = (bool) true ;
10500 wxLogWindow *result;
10501 bool temp2 = false ;
10502 PyObject * obj0 = 0 ;
10503 PyObject * obj1 = 0 ;
10504 PyObject * obj2 = 0 ;
10505 PyObject * obj3 = 0 ;
10506 char *kwnames[] = {
10507 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
10508 };
10509
10510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10512 if (SWIG_arg_fail(1)) SWIG_fail;
10513 {
10514 arg2 = wxString_in_helper(obj1);
10515 if (arg2 == NULL) SWIG_fail;
10516 temp2 = true;
10517 }
10518 if (obj2) {
10519 {
10520 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
10521 if (SWIG_arg_fail(3)) SWIG_fail;
10522 }
10523 }
10524 if (obj3) {
10525 {
10526 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
10527 if (SWIG_arg_fail(4)) SWIG_fail;
10528 }
10529 }
10530 {
10531 PyThreadState* __tstate = wxPyBeginAllowThreads();
10532 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
10533
10534 wxPyEndAllowThreads(__tstate);
10535 if (PyErr_Occurred()) SWIG_fail;
10536 }
10537 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
10538 {
10539 if (temp2)
10540 delete arg2;
10541 }
10542 return resultobj;
10543 fail:
10544 {
10545 if (temp2)
10546 delete arg2;
10547 }
10548 return NULL;
10549 }
10550
10551
10552 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
10553 PyObject *resultobj = NULL;
10554 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10555 bool arg2 = (bool) true ;
10556 PyObject * obj0 = 0 ;
10557 PyObject * obj1 = 0 ;
10558 char *kwnames[] = {
10559 (char *) "self",(char *) "bShow", NULL
10560 };
10561
10562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
10563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10564 if (SWIG_arg_fail(1)) SWIG_fail;
10565 if (obj1) {
10566 {
10567 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
10568 if (SWIG_arg_fail(2)) SWIG_fail;
10569 }
10570 }
10571 {
10572 PyThreadState* __tstate = wxPyBeginAllowThreads();
10573 (arg1)->Show(arg2);
10574
10575 wxPyEndAllowThreads(__tstate);
10576 if (PyErr_Occurred()) SWIG_fail;
10577 }
10578 Py_INCREF(Py_None); resultobj = Py_None;
10579 return resultobj;
10580 fail:
10581 return NULL;
10582 }
10583
10584
10585 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10586 PyObject *resultobj = NULL;
10587 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10588 wxFrame *result;
10589 PyObject * obj0 = 0 ;
10590 char *kwnames[] = {
10591 (char *) "self", NULL
10592 };
10593
10594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
10595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10596 if (SWIG_arg_fail(1)) SWIG_fail;
10597 {
10598 PyThreadState* __tstate = wxPyBeginAllowThreads();
10599 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
10600
10601 wxPyEndAllowThreads(__tstate);
10602 if (PyErr_Occurred()) SWIG_fail;
10603 }
10604 {
10605 resultobj = wxPyMake_wxObject(result, (bool)0);
10606 }
10607 return resultobj;
10608 fail:
10609 return NULL;
10610 }
10611
10612
10613 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10614 PyObject *resultobj = NULL;
10615 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10616 wxLog *result;
10617 PyObject * obj0 = 0 ;
10618 char *kwnames[] = {
10619 (char *) "self", NULL
10620 };
10621
10622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
10623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10624 if (SWIG_arg_fail(1)) SWIG_fail;
10625 {
10626 PyThreadState* __tstate = wxPyBeginAllowThreads();
10627 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
10628
10629 wxPyEndAllowThreads(__tstate);
10630 if (PyErr_Occurred()) SWIG_fail;
10631 }
10632 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10633 return resultobj;
10634 fail:
10635 return NULL;
10636 }
10637
10638
10639 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
10640 PyObject *resultobj = NULL;
10641 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10642 bool result;
10643 PyObject * obj0 = 0 ;
10644 char *kwnames[] = {
10645 (char *) "self", NULL
10646 };
10647
10648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
10649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10650 if (SWIG_arg_fail(1)) SWIG_fail;
10651 {
10652 PyThreadState* __tstate = wxPyBeginAllowThreads();
10653 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
10654
10655 wxPyEndAllowThreads(__tstate);
10656 if (PyErr_Occurred()) SWIG_fail;
10657 }
10658 {
10659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10660 }
10661 return resultobj;
10662 fail:
10663 return NULL;
10664 }
10665
10666
10667 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
10668 PyObject *resultobj = NULL;
10669 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
10670 bool arg2 ;
10671 PyObject * obj0 = 0 ;
10672 PyObject * obj1 = 0 ;
10673 char *kwnames[] = {
10674 (char *) "self",(char *) "bDoPass", NULL
10675 };
10676
10677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
10678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
10679 if (SWIG_arg_fail(1)) SWIG_fail;
10680 {
10681 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
10682 if (SWIG_arg_fail(2)) SWIG_fail;
10683 }
10684 {
10685 PyThreadState* __tstate = wxPyBeginAllowThreads();
10686 (arg1)->PassMessages(arg2);
10687
10688 wxPyEndAllowThreads(__tstate);
10689 if (PyErr_Occurred()) SWIG_fail;
10690 }
10691 Py_INCREF(Py_None); resultobj = Py_None;
10692 return resultobj;
10693 fail:
10694 return NULL;
10695 }
10696
10697
10698 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
10699 PyObject *obj;
10700 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10701 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
10702 Py_INCREF(obj);
10703 return Py_BuildValue((char *)"");
10704 }
10705 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
10706 PyObject *resultobj = NULL;
10707 wxLog *arg1 = (wxLog *) 0 ;
10708 wxLogChain *result;
10709 PyObject * obj0 = 0 ;
10710 char *kwnames[] = {
10711 (char *) "logger", NULL
10712 };
10713
10714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
10715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
10716 if (SWIG_arg_fail(1)) SWIG_fail;
10717 {
10718 PyThreadState* __tstate = wxPyBeginAllowThreads();
10719 result = (wxLogChain *)new wxLogChain(arg1);
10720
10721 wxPyEndAllowThreads(__tstate);
10722 if (PyErr_Occurred()) SWIG_fail;
10723 }
10724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
10725 return resultobj;
10726 fail:
10727 return NULL;
10728 }
10729
10730
10731 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
10732 PyObject *resultobj = NULL;
10733 wxLogChain *arg1 = (wxLogChain *) 0 ;
10734 wxLog *arg2 = (wxLog *) 0 ;
10735 PyObject * obj0 = 0 ;
10736 PyObject * obj1 = 0 ;
10737 char *kwnames[] = {
10738 (char *) "self",(char *) "logger", NULL
10739 };
10740
10741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
10742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10743 if (SWIG_arg_fail(1)) SWIG_fail;
10744 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
10745 if (SWIG_arg_fail(2)) SWIG_fail;
10746 {
10747 PyThreadState* __tstate = wxPyBeginAllowThreads();
10748 (arg1)->SetLog(arg2);
10749
10750 wxPyEndAllowThreads(__tstate);
10751 if (PyErr_Occurred()) SWIG_fail;
10752 }
10753 Py_INCREF(Py_None); resultobj = Py_None;
10754 return resultobj;
10755 fail:
10756 return NULL;
10757 }
10758
10759
10760 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
10761 PyObject *resultobj = NULL;
10762 wxLogChain *arg1 = (wxLogChain *) 0 ;
10763 bool arg2 ;
10764 PyObject * obj0 = 0 ;
10765 PyObject * obj1 = 0 ;
10766 char *kwnames[] = {
10767 (char *) "self",(char *) "bDoPass", NULL
10768 };
10769
10770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
10771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10772 if (SWIG_arg_fail(1)) SWIG_fail;
10773 {
10774 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
10775 if (SWIG_arg_fail(2)) SWIG_fail;
10776 }
10777 {
10778 PyThreadState* __tstate = wxPyBeginAllowThreads();
10779 (arg1)->PassMessages(arg2);
10780
10781 wxPyEndAllowThreads(__tstate);
10782 if (PyErr_Occurred()) SWIG_fail;
10783 }
10784 Py_INCREF(Py_None); resultobj = Py_None;
10785 return resultobj;
10786 fail:
10787 return NULL;
10788 }
10789
10790
10791 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
10792 PyObject *resultobj = NULL;
10793 wxLogChain *arg1 = (wxLogChain *) 0 ;
10794 bool result;
10795 PyObject * obj0 = 0 ;
10796 char *kwnames[] = {
10797 (char *) "self", NULL
10798 };
10799
10800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
10801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10802 if (SWIG_arg_fail(1)) SWIG_fail;
10803 {
10804 PyThreadState* __tstate = wxPyBeginAllowThreads();
10805 result = (bool)(arg1)->IsPassingMessages();
10806
10807 wxPyEndAllowThreads(__tstate);
10808 if (PyErr_Occurred()) SWIG_fail;
10809 }
10810 {
10811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10812 }
10813 return resultobj;
10814 fail:
10815 return NULL;
10816 }
10817
10818
10819 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj = NULL;
10821 wxLogChain *arg1 = (wxLogChain *) 0 ;
10822 wxLog *result;
10823 PyObject * obj0 = 0 ;
10824 char *kwnames[] = {
10825 (char *) "self", NULL
10826 };
10827
10828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
10829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
10830 if (SWIG_arg_fail(1)) SWIG_fail;
10831 {
10832 PyThreadState* __tstate = wxPyBeginAllowThreads();
10833 result = (wxLog *)(arg1)->GetOldLog();
10834
10835 wxPyEndAllowThreads(__tstate);
10836 if (PyErr_Occurred()) SWIG_fail;
10837 }
10838 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
10839 return resultobj;
10840 fail:
10841 return NULL;
10842 }
10843
10844
10845 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
10846 PyObject *obj;
10847 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10848 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
10849 Py_INCREF(obj);
10850 return Py_BuildValue((char *)"");
10851 }
10852 static PyObject *_wrap_new_LogBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
10853 PyObject *resultobj = NULL;
10854 wxLogBuffer *result;
10855 char *kwnames[] = {
10856 NULL
10857 };
10858
10859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogBuffer",kwnames)) goto fail;
10860 {
10861 PyThreadState* __tstate = wxPyBeginAllowThreads();
10862 result = (wxLogBuffer *)new wxLogBuffer();
10863
10864 wxPyEndAllowThreads(__tstate);
10865 if (PyErr_Occurred()) SWIG_fail;
10866 }
10867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogBuffer, 1);
10868 return resultobj;
10869 fail:
10870 return NULL;
10871 }
10872
10873
10874 static PyObject *_wrap_LogBuffer_GetBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
10875 PyObject *resultobj = NULL;
10876 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
10877 wxString *result;
10878 PyObject * obj0 = 0 ;
10879 char *kwnames[] = {
10880 (char *) "self", NULL
10881 };
10882
10883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogBuffer_GetBuffer",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 {
10889 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
10890 result = (wxString *) &_result_ref;
10891 }
10892
10893 wxPyEndAllowThreads(__tstate);
10894 if (PyErr_Occurred()) SWIG_fail;
10895 }
10896 {
10897 #if wxUSE_UNICODE
10898 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10899 #else
10900 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10901 #endif
10902 }
10903 return resultobj;
10904 fail:
10905 return NULL;
10906 }
10907
10908
10909 static PyObject *_wrap_LogBuffer_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
10910 PyObject *resultobj = NULL;
10911 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
10912 PyObject * obj0 = 0 ;
10913 char *kwnames[] = {
10914 (char *) "self", NULL
10915 };
10916
10917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogBuffer_Flush",kwnames,&obj0)) goto fail;
10918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_EXCEPTION | 0);
10919 if (SWIG_arg_fail(1)) SWIG_fail;
10920 {
10921 PyThreadState* __tstate = wxPyBeginAllowThreads();
10922 (arg1)->Flush();
10923
10924 wxPyEndAllowThreads(__tstate);
10925 if (PyErr_Occurred()) SWIG_fail;
10926 }
10927 Py_INCREF(Py_None); resultobj = Py_None;
10928 return resultobj;
10929 fail:
10930 return NULL;
10931 }
10932
10933
10934 static PyObject * LogBuffer_swigregister(PyObject *, PyObject *args) {
10935 PyObject *obj;
10936 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10937 SWIG_TypeClientData(SWIGTYPE_p_wxLogBuffer, obj);
10938 Py_INCREF(obj);
10939 return Py_BuildValue((char *)"");
10940 }
10941 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
10942 PyObject *resultobj = NULL;
10943 unsigned long result;
10944 char *kwnames[] = {
10945 NULL
10946 };
10947
10948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
10949 {
10950 PyThreadState* __tstate = wxPyBeginAllowThreads();
10951 result = (unsigned long)wxSysErrorCode();
10952
10953 wxPyEndAllowThreads(__tstate);
10954 if (PyErr_Occurred()) SWIG_fail;
10955 }
10956 {
10957 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10958 }
10959 return resultobj;
10960 fail:
10961 return NULL;
10962 }
10963
10964
10965 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
10966 PyObject *resultobj = NULL;
10967 unsigned long arg1 = (unsigned long) 0 ;
10968 wxString result;
10969 PyObject * obj0 = 0 ;
10970 char *kwnames[] = {
10971 (char *) "nErrCode", NULL
10972 };
10973
10974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10975 if (obj0) {
10976 {
10977 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
10978 if (SWIG_arg_fail(1)) SWIG_fail;
10979 }
10980 }
10981 {
10982 PyThreadState* __tstate = wxPyBeginAllowThreads();
10983 result = wxSysErrorMsg(arg1);
10984
10985 wxPyEndAllowThreads(__tstate);
10986 if (PyErr_Occurred()) SWIG_fail;
10987 }
10988 {
10989 #if wxUSE_UNICODE
10990 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10991 #else
10992 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10993 #endif
10994 }
10995 return resultobj;
10996 fail:
10997 return NULL;
10998 }
10999
11000
11001 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
11002 PyObject *resultobj = NULL;
11003 wxString *arg1 = 0 ;
11004 bool temp1 = false ;
11005 PyObject * obj0 = 0 ;
11006 char *kwnames[] = {
11007 (char *) "msg", NULL
11008 };
11009
11010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
11011 {
11012 arg1 = wxString_in_helper(obj0);
11013 if (arg1 == NULL) SWIG_fail;
11014 temp1 = true;
11015 }
11016 {
11017 PyThreadState* __tstate = wxPyBeginAllowThreads();
11018 wxPyLogFatalError((wxString const &)*arg1);
11019
11020 wxPyEndAllowThreads(__tstate);
11021 if (PyErr_Occurred()) SWIG_fail;
11022 }
11023 Py_INCREF(Py_None); resultobj = Py_None;
11024 {
11025 if (temp1)
11026 delete arg1;
11027 }
11028 return resultobj;
11029 fail:
11030 {
11031 if (temp1)
11032 delete arg1;
11033 }
11034 return NULL;
11035 }
11036
11037
11038 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
11039 PyObject *resultobj = NULL;
11040 wxString *arg1 = 0 ;
11041 bool temp1 = false ;
11042 PyObject * obj0 = 0 ;
11043 char *kwnames[] = {
11044 (char *) "msg", NULL
11045 };
11046
11047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
11048 {
11049 arg1 = wxString_in_helper(obj0);
11050 if (arg1 == NULL) SWIG_fail;
11051 temp1 = true;
11052 }
11053 {
11054 PyThreadState* __tstate = wxPyBeginAllowThreads();
11055 wxPyLogError((wxString const &)*arg1);
11056
11057 wxPyEndAllowThreads(__tstate);
11058 if (PyErr_Occurred()) SWIG_fail;
11059 }
11060 Py_INCREF(Py_None); resultobj = Py_None;
11061 {
11062 if (temp1)
11063 delete arg1;
11064 }
11065 return resultobj;
11066 fail:
11067 {
11068 if (temp1)
11069 delete arg1;
11070 }
11071 return NULL;
11072 }
11073
11074
11075 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
11076 PyObject *resultobj = NULL;
11077 wxString *arg1 = 0 ;
11078 bool temp1 = false ;
11079 PyObject * obj0 = 0 ;
11080 char *kwnames[] = {
11081 (char *) "msg", NULL
11082 };
11083
11084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
11085 {
11086 arg1 = wxString_in_helper(obj0);
11087 if (arg1 == NULL) SWIG_fail;
11088 temp1 = true;
11089 }
11090 {
11091 PyThreadState* __tstate = wxPyBeginAllowThreads();
11092 wxPyLogWarning((wxString const &)*arg1);
11093
11094 wxPyEndAllowThreads(__tstate);
11095 if (PyErr_Occurred()) SWIG_fail;
11096 }
11097 Py_INCREF(Py_None); resultobj = Py_None;
11098 {
11099 if (temp1)
11100 delete arg1;
11101 }
11102 return resultobj;
11103 fail:
11104 {
11105 if (temp1)
11106 delete arg1;
11107 }
11108 return NULL;
11109 }
11110
11111
11112 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
11113 PyObject *resultobj = NULL;
11114 wxString *arg1 = 0 ;
11115 bool temp1 = false ;
11116 PyObject * obj0 = 0 ;
11117 char *kwnames[] = {
11118 (char *) "msg", NULL
11119 };
11120
11121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
11122 {
11123 arg1 = wxString_in_helper(obj0);
11124 if (arg1 == NULL) SWIG_fail;
11125 temp1 = true;
11126 }
11127 {
11128 PyThreadState* __tstate = wxPyBeginAllowThreads();
11129 wxPyLogMessage((wxString const &)*arg1);
11130
11131 wxPyEndAllowThreads(__tstate);
11132 if (PyErr_Occurred()) SWIG_fail;
11133 }
11134 Py_INCREF(Py_None); resultobj = Py_None;
11135 {
11136 if (temp1)
11137 delete arg1;
11138 }
11139 return resultobj;
11140 fail:
11141 {
11142 if (temp1)
11143 delete arg1;
11144 }
11145 return NULL;
11146 }
11147
11148
11149 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11150 PyObject *resultobj = NULL;
11151 wxString *arg1 = 0 ;
11152 bool temp1 = false ;
11153 PyObject * obj0 = 0 ;
11154 char *kwnames[] = {
11155 (char *) "msg", NULL
11156 };
11157
11158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
11159 {
11160 arg1 = wxString_in_helper(obj0);
11161 if (arg1 == NULL) SWIG_fail;
11162 temp1 = true;
11163 }
11164 {
11165 PyThreadState* __tstate = wxPyBeginAllowThreads();
11166 wxPyLogInfo((wxString const &)*arg1);
11167
11168 wxPyEndAllowThreads(__tstate);
11169 if (PyErr_Occurred()) SWIG_fail;
11170 }
11171 Py_INCREF(Py_None); resultobj = Py_None;
11172 {
11173 if (temp1)
11174 delete arg1;
11175 }
11176 return resultobj;
11177 fail:
11178 {
11179 if (temp1)
11180 delete arg1;
11181 }
11182 return NULL;
11183 }
11184
11185
11186 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
11187 PyObject *resultobj = NULL;
11188 wxString *arg1 = 0 ;
11189 bool temp1 = false ;
11190 PyObject * obj0 = 0 ;
11191 char *kwnames[] = {
11192 (char *) "msg", NULL
11193 };
11194
11195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
11196 {
11197 arg1 = wxString_in_helper(obj0);
11198 if (arg1 == NULL) SWIG_fail;
11199 temp1 = true;
11200 }
11201 {
11202 PyThreadState* __tstate = wxPyBeginAllowThreads();
11203 wxPyLogDebug((wxString const &)*arg1);
11204
11205 wxPyEndAllowThreads(__tstate);
11206 if (PyErr_Occurred()) SWIG_fail;
11207 }
11208 Py_INCREF(Py_None); resultobj = Py_None;
11209 {
11210 if (temp1)
11211 delete arg1;
11212 }
11213 return resultobj;
11214 fail:
11215 {
11216 if (temp1)
11217 delete arg1;
11218 }
11219 return NULL;
11220 }
11221
11222
11223 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
11224 PyObject *resultobj = NULL;
11225 wxString *arg1 = 0 ;
11226 bool temp1 = false ;
11227 PyObject * obj0 = 0 ;
11228 char *kwnames[] = {
11229 (char *) "msg", NULL
11230 };
11231
11232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
11233 {
11234 arg1 = wxString_in_helper(obj0);
11235 if (arg1 == NULL) SWIG_fail;
11236 temp1 = true;
11237 }
11238 {
11239 PyThreadState* __tstate = wxPyBeginAllowThreads();
11240 wxPyLogVerbose((wxString const &)*arg1);
11241
11242 wxPyEndAllowThreads(__tstate);
11243 if (PyErr_Occurred()) SWIG_fail;
11244 }
11245 Py_INCREF(Py_None); resultobj = Py_None;
11246 {
11247 if (temp1)
11248 delete arg1;
11249 }
11250 return resultobj;
11251 fail:
11252 {
11253 if (temp1)
11254 delete arg1;
11255 }
11256 return NULL;
11257 }
11258
11259
11260 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
11261 PyObject *resultobj = NULL;
11262 wxString *arg1 = 0 ;
11263 bool temp1 = false ;
11264 PyObject * obj0 = 0 ;
11265 char *kwnames[] = {
11266 (char *) "msg", NULL
11267 };
11268
11269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
11270 {
11271 arg1 = wxString_in_helper(obj0);
11272 if (arg1 == NULL) SWIG_fail;
11273 temp1 = true;
11274 }
11275 {
11276 PyThreadState* __tstate = wxPyBeginAllowThreads();
11277 wxPyLogStatus((wxString const &)*arg1);
11278
11279 wxPyEndAllowThreads(__tstate);
11280 if (PyErr_Occurred()) SWIG_fail;
11281 }
11282 Py_INCREF(Py_None); resultobj = Py_None;
11283 {
11284 if (temp1)
11285 delete arg1;
11286 }
11287 return resultobj;
11288 fail:
11289 {
11290 if (temp1)
11291 delete arg1;
11292 }
11293 return NULL;
11294 }
11295
11296
11297 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
11298 PyObject *resultobj = NULL;
11299 wxFrame *arg1 = (wxFrame *) 0 ;
11300 wxString *arg2 = 0 ;
11301 bool temp2 = false ;
11302 PyObject * obj0 = 0 ;
11303 PyObject * obj1 = 0 ;
11304 char *kwnames[] = {
11305 (char *) "pFrame",(char *) "msg", NULL
11306 };
11307
11308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
11309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
11310 if (SWIG_arg_fail(1)) SWIG_fail;
11311 {
11312 arg2 = wxString_in_helper(obj1);
11313 if (arg2 == NULL) SWIG_fail;
11314 temp2 = true;
11315 }
11316 {
11317 PyThreadState* __tstate = wxPyBeginAllowThreads();
11318 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
11319
11320 wxPyEndAllowThreads(__tstate);
11321 if (PyErr_Occurred()) SWIG_fail;
11322 }
11323 Py_INCREF(Py_None); resultobj = Py_None;
11324 {
11325 if (temp2)
11326 delete arg2;
11327 }
11328 return resultobj;
11329 fail:
11330 {
11331 if (temp2)
11332 delete arg2;
11333 }
11334 return NULL;
11335 }
11336
11337
11338 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
11339 PyObject *resultobj = NULL;
11340 wxString *arg1 = 0 ;
11341 bool temp1 = false ;
11342 PyObject * obj0 = 0 ;
11343 char *kwnames[] = {
11344 (char *) "msg", NULL
11345 };
11346
11347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
11348 {
11349 arg1 = wxString_in_helper(obj0);
11350 if (arg1 == NULL) SWIG_fail;
11351 temp1 = true;
11352 }
11353 {
11354 PyThreadState* __tstate = wxPyBeginAllowThreads();
11355 wxPyLogSysError((wxString const &)*arg1);
11356
11357 wxPyEndAllowThreads(__tstate);
11358 if (PyErr_Occurred()) SWIG_fail;
11359 }
11360 Py_INCREF(Py_None); resultobj = Py_None;
11361 {
11362 if (temp1)
11363 delete arg1;
11364 }
11365 return resultobj;
11366 fail:
11367 {
11368 if (temp1)
11369 delete arg1;
11370 }
11371 return NULL;
11372 }
11373
11374
11375 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
11376 PyObject *resultobj = NULL;
11377 unsigned long arg1 ;
11378 wxString *arg2 = 0 ;
11379 bool temp2 = false ;
11380 PyObject * obj0 = 0 ;
11381 PyObject * obj1 = 0 ;
11382 char *kwnames[] = {
11383 (char *) "level",(char *) "msg", NULL
11384 };
11385
11386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
11387 {
11388 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
11389 if (SWIG_arg_fail(1)) SWIG_fail;
11390 }
11391 {
11392 arg2 = wxString_in_helper(obj1);
11393 if (arg2 == NULL) SWIG_fail;
11394 temp2 = true;
11395 }
11396 {
11397 PyThreadState* __tstate = wxPyBeginAllowThreads();
11398 wxPyLogGeneric(arg1,(wxString const &)*arg2);
11399
11400 wxPyEndAllowThreads(__tstate);
11401 if (PyErr_Occurred()) SWIG_fail;
11402 }
11403 Py_INCREF(Py_None); resultobj = Py_None;
11404 {
11405 if (temp2)
11406 delete arg2;
11407 }
11408 return resultobj;
11409 fail:
11410 {
11411 if (temp2)
11412 delete arg2;
11413 }
11414 return NULL;
11415 }
11416
11417
11418 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
11419 PyObject *resultobj = NULL;
11420 unsigned long arg1 ;
11421 wxString *arg2 = 0 ;
11422 bool temp2 = false ;
11423 PyObject * obj0 = 0 ;
11424 PyObject * obj1 = 0 ;
11425
11426 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
11427 {
11428 arg1 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj0));
11429 if (SWIG_arg_fail(1)) SWIG_fail;
11430 }
11431 {
11432 arg2 = wxString_in_helper(obj1);
11433 if (arg2 == NULL) SWIG_fail;
11434 temp2 = true;
11435 }
11436 {
11437 PyThreadState* __tstate = wxPyBeginAllowThreads();
11438 wxPyLogTrace(arg1,(wxString const &)*arg2);
11439
11440 wxPyEndAllowThreads(__tstate);
11441 if (PyErr_Occurred()) SWIG_fail;
11442 }
11443 Py_INCREF(Py_None); resultobj = Py_None;
11444 {
11445 if (temp2)
11446 delete arg2;
11447 }
11448 return resultobj;
11449 fail:
11450 {
11451 if (temp2)
11452 delete arg2;
11453 }
11454 return NULL;
11455 }
11456
11457
11458 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
11459 PyObject *resultobj = NULL;
11460 wxString *arg1 = 0 ;
11461 wxString *arg2 = 0 ;
11462 bool temp1 = false ;
11463 bool temp2 = false ;
11464 PyObject * obj0 = 0 ;
11465 PyObject * obj1 = 0 ;
11466
11467 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
11468 {
11469 arg1 = wxString_in_helper(obj0);
11470 if (arg1 == NULL) SWIG_fail;
11471 temp1 = true;
11472 }
11473 {
11474 arg2 = wxString_in_helper(obj1);
11475 if (arg2 == NULL) SWIG_fail;
11476 temp2 = true;
11477 }
11478 {
11479 PyThreadState* __tstate = wxPyBeginAllowThreads();
11480 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
11481
11482 wxPyEndAllowThreads(__tstate);
11483 if (PyErr_Occurred()) SWIG_fail;
11484 }
11485 Py_INCREF(Py_None); resultobj = Py_None;
11486 {
11487 if (temp1)
11488 delete arg1;
11489 }
11490 {
11491 if (temp2)
11492 delete arg2;
11493 }
11494 return resultobj;
11495 fail:
11496 {
11497 if (temp1)
11498 delete arg1;
11499 }
11500 {
11501 if (temp2)
11502 delete arg2;
11503 }
11504 return NULL;
11505 }
11506
11507
11508 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
11509 int argc;
11510 PyObject *argv[3];
11511 int ii;
11512
11513 argc = PyObject_Length(args);
11514 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
11515 argv[ii] = PyTuple_GetItem(args,ii);
11516 }
11517 if (argc == 2) {
11518 int _v;
11519 {
11520 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
11521 }
11522 if (_v) {
11523 {
11524 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11525 }
11526 if (_v) {
11527 return _wrap_LogTrace__SWIG_1(self,args);
11528 }
11529 }
11530 }
11531 if (argc == 2) {
11532 int _v;
11533 _v = SWIG_Check_unsigned_SS_long(argv[0]);
11534 if (_v) {
11535 {
11536 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
11537 }
11538 if (_v) {
11539 return _wrap_LogTrace__SWIG_0(self,args);
11540 }
11541 }
11542 }
11543
11544 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
11545 return NULL;
11546 }
11547
11548
11549 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
11550 PyObject *resultobj = NULL;
11551 wxString *arg1 = 0 ;
11552 wxString *arg2 = 0 ;
11553 bool temp1 = false ;
11554 bool temp2 = false ;
11555 PyObject * obj0 = 0 ;
11556 PyObject * obj1 = 0 ;
11557 char *kwnames[] = {
11558 (char *) "title",(char *) "text", NULL
11559 };
11560
11561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
11562 {
11563 arg1 = wxString_in_helper(obj0);
11564 if (arg1 == NULL) SWIG_fail;
11565 temp1 = true;
11566 }
11567 {
11568 arg2 = wxString_in_helper(obj1);
11569 if (arg2 == NULL) SWIG_fail;
11570 temp2 = true;
11571 }
11572 {
11573 PyThreadState* __tstate = wxPyBeginAllowThreads();
11574 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
11575
11576 wxPyEndAllowThreads(__tstate);
11577 if (PyErr_Occurred()) SWIG_fail;
11578 }
11579 Py_INCREF(Py_None); resultobj = Py_None;
11580 {
11581 if (temp1)
11582 delete arg1;
11583 }
11584 {
11585 if (temp2)
11586 delete arg2;
11587 }
11588 return resultobj;
11589 fail:
11590 {
11591 if (temp1)
11592 delete arg1;
11593 }
11594 {
11595 if (temp2)
11596 delete arg2;
11597 }
11598 return NULL;
11599 }
11600
11601
11602 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
11603 PyObject *resultobj = NULL;
11604 wxLogNull *result;
11605 char *kwnames[] = {
11606 NULL
11607 };
11608
11609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
11610 {
11611 PyThreadState* __tstate = wxPyBeginAllowThreads();
11612 result = (wxLogNull *)new wxLogNull();
11613
11614 wxPyEndAllowThreads(__tstate);
11615 if (PyErr_Occurred()) SWIG_fail;
11616 }
11617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
11618 return resultobj;
11619 fail:
11620 return NULL;
11621 }
11622
11623
11624 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
11625 PyObject *resultobj = NULL;
11626 wxLogNull *arg1 = (wxLogNull *) 0 ;
11627 PyObject * obj0 = 0 ;
11628 char *kwnames[] = {
11629 (char *) "self", NULL
11630 };
11631
11632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
11633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
11634 if (SWIG_arg_fail(1)) SWIG_fail;
11635 {
11636 PyThreadState* __tstate = wxPyBeginAllowThreads();
11637 delete arg1;
11638
11639 wxPyEndAllowThreads(__tstate);
11640 if (PyErr_Occurred()) SWIG_fail;
11641 }
11642 Py_INCREF(Py_None); resultobj = Py_None;
11643 return resultobj;
11644 fail:
11645 return NULL;
11646 }
11647
11648
11649 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
11650 PyObject *obj;
11651 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11652 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
11653 Py_INCREF(obj);
11654 return Py_BuildValue((char *)"");
11655 }
11656 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
11657 PyObject *resultobj = NULL;
11658 wxPyLog *result;
11659 char *kwnames[] = {
11660 NULL
11661 };
11662
11663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
11664 {
11665 PyThreadState* __tstate = wxPyBeginAllowThreads();
11666 result = (wxPyLog *)new wxPyLog();
11667
11668 wxPyEndAllowThreads(__tstate);
11669 if (PyErr_Occurred()) SWIG_fail;
11670 }
11671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
11672 return resultobj;
11673 fail:
11674 return NULL;
11675 }
11676
11677
11678 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11679 PyObject *resultobj = NULL;
11680 wxPyLog *arg1 = (wxPyLog *) 0 ;
11681 PyObject *arg2 = (PyObject *) 0 ;
11682 PyObject *arg3 = (PyObject *) 0 ;
11683 PyObject * obj0 = 0 ;
11684 PyObject * obj1 = 0 ;
11685 PyObject * obj2 = 0 ;
11686 char *kwnames[] = {
11687 (char *) "self",(char *) "self",(char *) "_class", NULL
11688 };
11689
11690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
11692 if (SWIG_arg_fail(1)) SWIG_fail;
11693 arg2 = obj1;
11694 arg3 = obj2;
11695 {
11696 PyThreadState* __tstate = wxPyBeginAllowThreads();
11697 (arg1)->_setCallbackInfo(arg2,arg3);
11698
11699 wxPyEndAllowThreads(__tstate);
11700 if (PyErr_Occurred()) SWIG_fail;
11701 }
11702 Py_INCREF(Py_None); resultobj = Py_None;
11703 return resultobj;
11704 fail:
11705 return NULL;
11706 }
11707
11708
11709 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
11710 PyObject *obj;
11711 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11712 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
11713 Py_INCREF(obj);
11714 return Py_BuildValue((char *)"");
11715 }
11716 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11717 PyObject *resultobj = NULL;
11718 int arg1 ;
11719 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11720 int arg3 = (int) wxKILL_NOCHILDREN ;
11721 wxKillError result;
11722 PyObject * obj0 = 0 ;
11723 PyObject * obj1 = 0 ;
11724 PyObject * obj2 = 0 ;
11725 char *kwnames[] = {
11726 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11727 };
11728
11729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11730 {
11731 arg1 = static_cast<int >(SWIG_As_int(obj0));
11732 if (SWIG_arg_fail(1)) SWIG_fail;
11733 }
11734 if (obj1) {
11735 {
11736 arg2 = static_cast<wxSignal >(SWIG_As_int(obj1));
11737 if (SWIG_arg_fail(2)) SWIG_fail;
11738 }
11739 }
11740 if (obj2) {
11741 {
11742 arg3 = static_cast<int >(SWIG_As_int(obj2));
11743 if (SWIG_arg_fail(3)) SWIG_fail;
11744 }
11745 }
11746 {
11747 PyThreadState* __tstate = wxPyBeginAllowThreads();
11748 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
11749
11750 wxPyEndAllowThreads(__tstate);
11751 if (PyErr_Occurred()) SWIG_fail;
11752 }
11753 resultobj = SWIG_From_int((result));
11754 return resultobj;
11755 fail:
11756 return NULL;
11757 }
11758
11759
11760 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
11761 PyObject *resultobj = NULL;
11762 int arg1 ;
11763 bool result;
11764 PyObject * obj0 = 0 ;
11765 char *kwnames[] = {
11766 (char *) "pid", NULL
11767 };
11768
11769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
11770 {
11771 arg1 = static_cast<int >(SWIG_As_int(obj0));
11772 if (SWIG_arg_fail(1)) SWIG_fail;
11773 }
11774 {
11775 PyThreadState* __tstate = wxPyBeginAllowThreads();
11776 result = (bool)wxPyProcess::Exists(arg1);
11777
11778 wxPyEndAllowThreads(__tstate);
11779 if (PyErr_Occurred()) SWIG_fail;
11780 }
11781 {
11782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11783 }
11784 return resultobj;
11785 fail:
11786 return NULL;
11787 }
11788
11789
11790 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
11791 PyObject *resultobj = NULL;
11792 wxString *arg1 = 0 ;
11793 int arg2 = (int) wxEXEC_ASYNC ;
11794 wxPyProcess *result;
11795 bool temp1 = false ;
11796 PyObject * obj0 = 0 ;
11797 PyObject * obj1 = 0 ;
11798 char *kwnames[] = {
11799 (char *) "cmd",(char *) "flags", NULL
11800 };
11801
11802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
11803 {
11804 arg1 = wxString_in_helper(obj0);
11805 if (arg1 == NULL) SWIG_fail;
11806 temp1 = true;
11807 }
11808 if (obj1) {
11809 {
11810 arg2 = static_cast<int >(SWIG_As_int(obj1));
11811 if (SWIG_arg_fail(2)) SWIG_fail;
11812 }
11813 }
11814 {
11815 PyThreadState* __tstate = wxPyBeginAllowThreads();
11816 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
11817
11818 wxPyEndAllowThreads(__tstate);
11819 if (PyErr_Occurred()) SWIG_fail;
11820 }
11821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
11822 {
11823 if (temp1)
11824 delete arg1;
11825 }
11826 return resultobj;
11827 fail:
11828 {
11829 if (temp1)
11830 delete arg1;
11831 }
11832 return NULL;
11833 }
11834
11835
11836 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
11837 PyObject *resultobj = NULL;
11838 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11839 int arg2 = (int) -1 ;
11840 wxPyProcess *result;
11841 PyObject * obj0 = 0 ;
11842 PyObject * obj1 = 0 ;
11843 char *kwnames[] = {
11844 (char *) "parent",(char *) "id", NULL
11845 };
11846
11847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
11848 if (obj0) {
11849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
11850 if (SWIG_arg_fail(1)) SWIG_fail;
11851 }
11852 if (obj1) {
11853 {
11854 arg2 = static_cast<int >(SWIG_As_int(obj1));
11855 if (SWIG_arg_fail(2)) SWIG_fail;
11856 }
11857 }
11858 {
11859 PyThreadState* __tstate = wxPyBeginAllowThreads();
11860 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
11861
11862 wxPyEndAllowThreads(__tstate);
11863 if (PyErr_Occurred()) SWIG_fail;
11864 }
11865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
11866 return resultobj;
11867 fail:
11868 return NULL;
11869 }
11870
11871
11872 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
11873 PyObject *resultobj = NULL;
11874 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11875 PyObject *arg2 = (PyObject *) 0 ;
11876 PyObject *arg3 = (PyObject *) 0 ;
11877 PyObject * obj0 = 0 ;
11878 PyObject * obj1 = 0 ;
11879 PyObject * obj2 = 0 ;
11880 char *kwnames[] = {
11881 (char *) "self",(char *) "self",(char *) "_class", NULL
11882 };
11883
11884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
11885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11886 if (SWIG_arg_fail(1)) SWIG_fail;
11887 arg2 = obj1;
11888 arg3 = obj2;
11889 {
11890 PyThreadState* __tstate = wxPyBeginAllowThreads();
11891 (arg1)->_setCallbackInfo(arg2,arg3);
11892
11893 wxPyEndAllowThreads(__tstate);
11894 if (PyErr_Occurred()) SWIG_fail;
11895 }
11896 Py_INCREF(Py_None); resultobj = Py_None;
11897 return resultobj;
11898 fail:
11899 return NULL;
11900 }
11901
11902
11903 static PyObject *_wrap_Process_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
11904 PyObject *resultobj = NULL;
11905 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11906 int arg2 ;
11907 int arg3 ;
11908 PyObject * obj0 = 0 ;
11909 PyObject * obj1 = 0 ;
11910 PyObject * obj2 = 0 ;
11911 char *kwnames[] = {
11912 (char *) "self",(char *) "pid",(char *) "status", NULL
11913 };
11914
11915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
11916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11917 if (SWIG_arg_fail(1)) SWIG_fail;
11918 {
11919 arg2 = static_cast<int >(SWIG_As_int(obj1));
11920 if (SWIG_arg_fail(2)) SWIG_fail;
11921 }
11922 {
11923 arg3 = static_cast<int >(SWIG_As_int(obj2));
11924 if (SWIG_arg_fail(3)) SWIG_fail;
11925 }
11926 {
11927 PyThreadState* __tstate = wxPyBeginAllowThreads();
11928 (arg1)->OnTerminate(arg2,arg3);
11929
11930 wxPyEndAllowThreads(__tstate);
11931 if (PyErr_Occurred()) SWIG_fail;
11932 }
11933 Py_INCREF(Py_None); resultobj = Py_None;
11934 return resultobj;
11935 fail:
11936 return NULL;
11937 }
11938
11939
11940 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
11941 PyObject *resultobj = NULL;
11942 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11943 PyObject * obj0 = 0 ;
11944 char *kwnames[] = {
11945 (char *) "self", NULL
11946 };
11947
11948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
11949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11950 if (SWIG_arg_fail(1)) SWIG_fail;
11951 {
11952 PyThreadState* __tstate = wxPyBeginAllowThreads();
11953 (arg1)->Redirect();
11954
11955 wxPyEndAllowThreads(__tstate);
11956 if (PyErr_Occurred()) SWIG_fail;
11957 }
11958 Py_INCREF(Py_None); resultobj = Py_None;
11959 return resultobj;
11960 fail:
11961 return NULL;
11962 }
11963
11964
11965 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
11966 PyObject *resultobj = NULL;
11967 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11968 bool result;
11969 PyObject * obj0 = 0 ;
11970 char *kwnames[] = {
11971 (char *) "self", NULL
11972 };
11973
11974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11976 if (SWIG_arg_fail(1)) SWIG_fail;
11977 {
11978 PyThreadState* __tstate = wxPyBeginAllowThreads();
11979 result = (bool)(arg1)->IsRedirected();
11980
11981 wxPyEndAllowThreads(__tstate);
11982 if (PyErr_Occurred()) SWIG_fail;
11983 }
11984 {
11985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11986 }
11987 return resultobj;
11988 fail:
11989 return NULL;
11990 }
11991
11992
11993 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11994 PyObject *resultobj = NULL;
11995 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11996 PyObject * obj0 = 0 ;
11997 char *kwnames[] = {
11998 (char *) "self", NULL
11999 };
12000
12001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
12002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12003 if (SWIG_arg_fail(1)) SWIG_fail;
12004 {
12005 PyThreadState* __tstate = wxPyBeginAllowThreads();
12006 (arg1)->Detach();
12007
12008 wxPyEndAllowThreads(__tstate);
12009 if (PyErr_Occurred()) SWIG_fail;
12010 }
12011 Py_INCREF(Py_None); resultobj = Py_None;
12012 return resultobj;
12013 fail:
12014 return NULL;
12015 }
12016
12017
12018 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
12019 PyObject *resultobj = NULL;
12020 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12021 wxInputStream *result;
12022 PyObject * obj0 = 0 ;
12023 char *kwnames[] = {
12024 (char *) "self", NULL
12025 };
12026
12027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
12028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12029 if (SWIG_arg_fail(1)) SWIG_fail;
12030 {
12031 PyThreadState* __tstate = wxPyBeginAllowThreads();
12032 result = (wxInputStream *)(arg1)->GetInputStream();
12033
12034 wxPyEndAllowThreads(__tstate);
12035 if (PyErr_Occurred()) SWIG_fail;
12036 }
12037 {
12038 wxPyInputStream * _ptr = NULL;
12039
12040 if (result) {
12041 _ptr = new wxPyInputStream(result);
12042 }
12043 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12044 }
12045 return resultobj;
12046 fail:
12047 return NULL;
12048 }
12049
12050
12051 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
12052 PyObject *resultobj = NULL;
12053 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12054 wxInputStream *result;
12055 PyObject * obj0 = 0 ;
12056 char *kwnames[] = {
12057 (char *) "self", NULL
12058 };
12059
12060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
12061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12062 if (SWIG_arg_fail(1)) SWIG_fail;
12063 {
12064 PyThreadState* __tstate = wxPyBeginAllowThreads();
12065 result = (wxInputStream *)(arg1)->GetErrorStream();
12066
12067 wxPyEndAllowThreads(__tstate);
12068 if (PyErr_Occurred()) SWIG_fail;
12069 }
12070 {
12071 wxPyInputStream * _ptr = NULL;
12072
12073 if (result) {
12074 _ptr = new wxPyInputStream(result);
12075 }
12076 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12077 }
12078 return resultobj;
12079 fail:
12080 return NULL;
12081 }
12082
12083
12084 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
12085 PyObject *resultobj = NULL;
12086 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12087 wxOutputStream *result;
12088 PyObject * obj0 = 0 ;
12089 char *kwnames[] = {
12090 (char *) "self", NULL
12091 };
12092
12093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
12094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12095 if (SWIG_arg_fail(1)) SWIG_fail;
12096 {
12097 PyThreadState* __tstate = wxPyBeginAllowThreads();
12098 result = (wxOutputStream *)(arg1)->GetOutputStream();
12099
12100 wxPyEndAllowThreads(__tstate);
12101 if (PyErr_Occurred()) SWIG_fail;
12102 }
12103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
12104 return resultobj;
12105 fail:
12106 return NULL;
12107 }
12108
12109
12110 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
12111 PyObject *resultobj = NULL;
12112 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12113 PyObject * obj0 = 0 ;
12114 char *kwnames[] = {
12115 (char *) "self", NULL
12116 };
12117
12118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
12119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12120 if (SWIG_arg_fail(1)) SWIG_fail;
12121 {
12122 PyThreadState* __tstate = wxPyBeginAllowThreads();
12123 (arg1)->CloseOutput();
12124
12125 wxPyEndAllowThreads(__tstate);
12126 if (PyErr_Occurred()) SWIG_fail;
12127 }
12128 Py_INCREF(Py_None); resultobj = Py_None;
12129 return resultobj;
12130 fail:
12131 return NULL;
12132 }
12133
12134
12135 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
12136 PyObject *resultobj = NULL;
12137 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12138 bool result;
12139 PyObject * obj0 = 0 ;
12140 char *kwnames[] = {
12141 (char *) "self", NULL
12142 };
12143
12144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
12145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12146 if (SWIG_arg_fail(1)) SWIG_fail;
12147 {
12148 PyThreadState* __tstate = wxPyBeginAllowThreads();
12149 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
12150
12151 wxPyEndAllowThreads(__tstate);
12152 if (PyErr_Occurred()) SWIG_fail;
12153 }
12154 {
12155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12156 }
12157 return resultobj;
12158 fail:
12159 return NULL;
12160 }
12161
12162
12163 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
12164 PyObject *resultobj = NULL;
12165 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12166 bool result;
12167 PyObject * obj0 = 0 ;
12168 char *kwnames[] = {
12169 (char *) "self", NULL
12170 };
12171
12172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
12173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12174 if (SWIG_arg_fail(1)) SWIG_fail;
12175 {
12176 PyThreadState* __tstate = wxPyBeginAllowThreads();
12177 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
12178
12179 wxPyEndAllowThreads(__tstate);
12180 if (PyErr_Occurred()) SWIG_fail;
12181 }
12182 {
12183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12184 }
12185 return resultobj;
12186 fail:
12187 return NULL;
12188 }
12189
12190
12191 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
12192 PyObject *resultobj = NULL;
12193 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
12194 bool result;
12195 PyObject * obj0 = 0 ;
12196 char *kwnames[] = {
12197 (char *) "self", NULL
12198 };
12199
12200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
12201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12202 if (SWIG_arg_fail(1)) SWIG_fail;
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
12206
12207 wxPyEndAllowThreads(__tstate);
12208 if (PyErr_Occurred()) SWIG_fail;
12209 }
12210 {
12211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12212 }
12213 return resultobj;
12214 fail:
12215 return NULL;
12216 }
12217
12218
12219 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
12220 PyObject *obj;
12221 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12222 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
12223 Py_INCREF(obj);
12224 return Py_BuildValue((char *)"");
12225 }
12226 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12227 PyObject *resultobj = NULL;
12228 int arg1 = (int) 0 ;
12229 int arg2 = (int) 0 ;
12230 int arg3 = (int) 0 ;
12231 wxProcessEvent *result;
12232 PyObject * obj0 = 0 ;
12233 PyObject * obj1 = 0 ;
12234 PyObject * obj2 = 0 ;
12235 char *kwnames[] = {
12236 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
12237 };
12238
12239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
12240 if (obj0) {
12241 {
12242 arg1 = static_cast<int >(SWIG_As_int(obj0));
12243 if (SWIG_arg_fail(1)) SWIG_fail;
12244 }
12245 }
12246 if (obj1) {
12247 {
12248 arg2 = static_cast<int >(SWIG_As_int(obj1));
12249 if (SWIG_arg_fail(2)) SWIG_fail;
12250 }
12251 }
12252 if (obj2) {
12253 {
12254 arg3 = static_cast<int >(SWIG_As_int(obj2));
12255 if (SWIG_arg_fail(3)) SWIG_fail;
12256 }
12257 }
12258 {
12259 PyThreadState* __tstate = wxPyBeginAllowThreads();
12260 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
12261
12262 wxPyEndAllowThreads(__tstate);
12263 if (PyErr_Occurred()) SWIG_fail;
12264 }
12265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
12266 return resultobj;
12267 fail:
12268 return NULL;
12269 }
12270
12271
12272 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
12273 PyObject *resultobj = NULL;
12274 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12275 int result;
12276 PyObject * obj0 = 0 ;
12277 char *kwnames[] = {
12278 (char *) "self", NULL
12279 };
12280
12281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
12282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12283 if (SWIG_arg_fail(1)) SWIG_fail;
12284 {
12285 PyThreadState* __tstate = wxPyBeginAllowThreads();
12286 result = (int)(arg1)->GetPid();
12287
12288 wxPyEndAllowThreads(__tstate);
12289 if (PyErr_Occurred()) SWIG_fail;
12290 }
12291 {
12292 resultobj = SWIG_From_int(static_cast<int >(result));
12293 }
12294 return resultobj;
12295 fail:
12296 return NULL;
12297 }
12298
12299
12300 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
12301 PyObject *resultobj = NULL;
12302 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12303 int result;
12304 PyObject * obj0 = 0 ;
12305 char *kwnames[] = {
12306 (char *) "self", NULL
12307 };
12308
12309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
12310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12311 if (SWIG_arg_fail(1)) SWIG_fail;
12312 {
12313 PyThreadState* __tstate = wxPyBeginAllowThreads();
12314 result = (int)(arg1)->GetExitCode();
12315
12316 wxPyEndAllowThreads(__tstate);
12317 if (PyErr_Occurred()) SWIG_fail;
12318 }
12319 {
12320 resultobj = SWIG_From_int(static_cast<int >(result));
12321 }
12322 return resultobj;
12323 fail:
12324 return NULL;
12325 }
12326
12327
12328 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
12329 PyObject *resultobj = NULL;
12330 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12331 int arg2 ;
12332 PyObject * obj0 = 0 ;
12333 PyObject * obj1 = 0 ;
12334 char *kwnames[] = {
12335 (char *) "self",(char *) "m_pid", NULL
12336 };
12337
12338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
12339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12340 if (SWIG_arg_fail(1)) SWIG_fail;
12341 {
12342 arg2 = static_cast<int >(SWIG_As_int(obj1));
12343 if (SWIG_arg_fail(2)) SWIG_fail;
12344 }
12345 if (arg1) (arg1)->m_pid = arg2;
12346
12347 Py_INCREF(Py_None); resultobj = Py_None;
12348 return resultobj;
12349 fail:
12350 return NULL;
12351 }
12352
12353
12354 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
12355 PyObject *resultobj = NULL;
12356 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12357 int result;
12358 PyObject * obj0 = 0 ;
12359 char *kwnames[] = {
12360 (char *) "self", NULL
12361 };
12362
12363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
12364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12365 if (SWIG_arg_fail(1)) SWIG_fail;
12366 result = (int) ((arg1)->m_pid);
12367
12368 {
12369 resultobj = SWIG_From_int(static_cast<int >(result));
12370 }
12371 return resultobj;
12372 fail:
12373 return NULL;
12374 }
12375
12376
12377 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
12378 PyObject *resultobj = NULL;
12379 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12380 int arg2 ;
12381 PyObject * obj0 = 0 ;
12382 PyObject * obj1 = 0 ;
12383 char *kwnames[] = {
12384 (char *) "self",(char *) "m_exitcode", NULL
12385 };
12386
12387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
12388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12389 if (SWIG_arg_fail(1)) SWIG_fail;
12390 {
12391 arg2 = static_cast<int >(SWIG_As_int(obj1));
12392 if (SWIG_arg_fail(2)) SWIG_fail;
12393 }
12394 if (arg1) (arg1)->m_exitcode = arg2;
12395
12396 Py_INCREF(Py_None); resultobj = Py_None;
12397 return resultobj;
12398 fail:
12399 return NULL;
12400 }
12401
12402
12403 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
12404 PyObject *resultobj = NULL;
12405 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
12406 int result;
12407 PyObject * obj0 = 0 ;
12408 char *kwnames[] = {
12409 (char *) "self", NULL
12410 };
12411
12412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
12413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
12414 if (SWIG_arg_fail(1)) SWIG_fail;
12415 result = (int) ((arg1)->m_exitcode);
12416
12417 {
12418 resultobj = SWIG_From_int(static_cast<int >(result));
12419 }
12420 return resultobj;
12421 fail:
12422 return NULL;
12423 }
12424
12425
12426 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
12427 PyObject *obj;
12428 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12429 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
12430 Py_INCREF(obj);
12431 return Py_BuildValue((char *)"");
12432 }
12433 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
12434 PyObject *resultobj = NULL;
12435 wxString *arg1 = 0 ;
12436 int arg2 = (int) wxEXEC_ASYNC ;
12437 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
12438 long result;
12439 bool temp1 = false ;
12440 PyObject * obj0 = 0 ;
12441 PyObject * obj1 = 0 ;
12442 PyObject * obj2 = 0 ;
12443 char *kwnames[] = {
12444 (char *) "command",(char *) "flags",(char *) "process", NULL
12445 };
12446
12447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
12448 {
12449 arg1 = wxString_in_helper(obj0);
12450 if (arg1 == NULL) SWIG_fail;
12451 temp1 = true;
12452 }
12453 if (obj1) {
12454 {
12455 arg2 = static_cast<int >(SWIG_As_int(obj1));
12456 if (SWIG_arg_fail(2)) SWIG_fail;
12457 }
12458 }
12459 if (obj2) {
12460 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
12461 if (SWIG_arg_fail(3)) SWIG_fail;
12462 }
12463 {
12464 if (!wxPyCheckForApp()) SWIG_fail;
12465 PyThreadState* __tstate = wxPyBeginAllowThreads();
12466 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
12467
12468 wxPyEndAllowThreads(__tstate);
12469 if (PyErr_Occurred()) SWIG_fail;
12470 }
12471 {
12472 resultobj = SWIG_From_long(static_cast<long >(result));
12473 }
12474 {
12475 if (temp1)
12476 delete arg1;
12477 }
12478 return resultobj;
12479 fail:
12480 {
12481 if (temp1)
12482 delete arg1;
12483 }
12484 return NULL;
12485 }
12486
12487
12488 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
12489 PyObject *resultobj = NULL;
12490 long arg1 ;
12491 wxSignal arg2 = (wxSignal) wxSIGTERM ;
12492 wxKillError *arg3 = (wxKillError *) 0 ;
12493 int arg4 = (int) wxKILL_NOCHILDREN ;
12494 int result;
12495 wxKillError temp3 ;
12496 PyObject * obj0 = 0 ;
12497 PyObject * obj1 = 0 ;
12498 PyObject * obj2 = 0 ;
12499 char *kwnames[] = {
12500 (char *) "pid",(char *) "sig",(char *) "flags", NULL
12501 };
12502
12503 {
12504 arg3 = &temp3;
12505 }
12506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
12507 {
12508 arg1 = static_cast<long >(SWIG_As_long(obj0));
12509 if (SWIG_arg_fail(1)) SWIG_fail;
12510 }
12511 if (obj1) {
12512 {
12513 arg2 = static_cast<wxSignal >(SWIG_As_int(obj1));
12514 if (SWIG_arg_fail(2)) SWIG_fail;
12515 }
12516 }
12517 if (obj2) {
12518 {
12519 arg4 = static_cast<int >(SWIG_As_int(obj2));
12520 if (SWIG_arg_fail(4)) SWIG_fail;
12521 }
12522 }
12523 {
12524 PyThreadState* __tstate = wxPyBeginAllowThreads();
12525 result = (int)wxKill(arg1,arg2,arg3,arg4);
12526
12527 wxPyEndAllowThreads(__tstate);
12528 if (PyErr_Occurred()) SWIG_fail;
12529 }
12530 {
12531 resultobj = SWIG_From_int(static_cast<int >(result));
12532 }
12533 {
12534 PyObject* o;
12535 o = PyInt_FromLong((long) (*arg3));
12536
12537 resultobj = t_output_helper(resultobj, o);
12538
12539
12540
12541 }
12542 return resultobj;
12543 fail:
12544 return NULL;
12545 }
12546
12547
12548 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
12549 PyObject *resultobj = NULL;
12550 int arg1 = (int) wxJOYSTICK1 ;
12551 wxJoystick *result;
12552 PyObject * obj0 = 0 ;
12553 char *kwnames[] = {
12554 (char *) "joystick", NULL
12555 };
12556
12557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
12558 if (obj0) {
12559 {
12560 arg1 = static_cast<int >(SWIG_As_int(obj0));
12561 if (SWIG_arg_fail(1)) SWIG_fail;
12562 }
12563 }
12564 {
12565 if (!wxPyCheckForApp()) SWIG_fail;
12566 PyThreadState* __tstate = wxPyBeginAllowThreads();
12567 result = (wxJoystick *)new wxJoystick(arg1);
12568
12569 wxPyEndAllowThreads(__tstate);
12570 if (PyErr_Occurred()) SWIG_fail;
12571 }
12572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
12573 return resultobj;
12574 fail:
12575 return NULL;
12576 }
12577
12578
12579 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
12580 PyObject *resultobj = NULL;
12581 wxJoystick *arg1 = (wxJoystick *) 0 ;
12582 PyObject * obj0 = 0 ;
12583 char *kwnames[] = {
12584 (char *) "self", NULL
12585 };
12586
12587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
12588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12589 if (SWIG_arg_fail(1)) SWIG_fail;
12590 {
12591 PyThreadState* __tstate = wxPyBeginAllowThreads();
12592 delete arg1;
12593
12594 wxPyEndAllowThreads(__tstate);
12595 if (PyErr_Occurred()) SWIG_fail;
12596 }
12597 Py_INCREF(Py_None); resultobj = Py_None;
12598 return resultobj;
12599 fail:
12600 return NULL;
12601 }
12602
12603
12604 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12605 PyObject *resultobj = NULL;
12606 wxJoystick *arg1 = (wxJoystick *) 0 ;
12607 wxPoint result;
12608 PyObject * obj0 = 0 ;
12609 char *kwnames[] = {
12610 (char *) "self", NULL
12611 };
12612
12613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
12614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12615 if (SWIG_arg_fail(1)) SWIG_fail;
12616 {
12617 PyThreadState* __tstate = wxPyBeginAllowThreads();
12618 result = (arg1)->GetPosition();
12619
12620 wxPyEndAllowThreads(__tstate);
12621 if (PyErr_Occurred()) SWIG_fail;
12622 }
12623 {
12624 wxPoint * resultptr;
12625 resultptr = new wxPoint(static_cast<wxPoint & >(result));
12626 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12627 }
12628 return resultobj;
12629 fail:
12630 return NULL;
12631 }
12632
12633
12634 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12635 PyObject *resultobj = NULL;
12636 wxJoystick *arg1 = (wxJoystick *) 0 ;
12637 int result;
12638 PyObject * obj0 = 0 ;
12639 char *kwnames[] = {
12640 (char *) "self", NULL
12641 };
12642
12643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
12644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12645 if (SWIG_arg_fail(1)) SWIG_fail;
12646 {
12647 PyThreadState* __tstate = wxPyBeginAllowThreads();
12648 result = (int)(arg1)->GetZPosition();
12649
12650 wxPyEndAllowThreads(__tstate);
12651 if (PyErr_Occurred()) SWIG_fail;
12652 }
12653 {
12654 resultobj = SWIG_From_int(static_cast<int >(result));
12655 }
12656 return resultobj;
12657 fail:
12658 return NULL;
12659 }
12660
12661
12662 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12663 PyObject *resultobj = NULL;
12664 wxJoystick *arg1 = (wxJoystick *) 0 ;
12665 int result;
12666 PyObject * obj0 = 0 ;
12667 char *kwnames[] = {
12668 (char *) "self", NULL
12669 };
12670
12671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
12672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12673 if (SWIG_arg_fail(1)) SWIG_fail;
12674 {
12675 PyThreadState* __tstate = wxPyBeginAllowThreads();
12676 result = (int)(arg1)->GetButtonState();
12677
12678 wxPyEndAllowThreads(__tstate);
12679 if (PyErr_Occurred()) SWIG_fail;
12680 }
12681 {
12682 resultobj = SWIG_From_int(static_cast<int >(result));
12683 }
12684 return resultobj;
12685 fail:
12686 return NULL;
12687 }
12688
12689
12690 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12691 PyObject *resultobj = NULL;
12692 wxJoystick *arg1 = (wxJoystick *) 0 ;
12693 int result;
12694 PyObject * obj0 = 0 ;
12695 char *kwnames[] = {
12696 (char *) "self", NULL
12697 };
12698
12699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
12700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12701 if (SWIG_arg_fail(1)) SWIG_fail;
12702 {
12703 PyThreadState* __tstate = wxPyBeginAllowThreads();
12704 result = (int)(arg1)->GetPOVPosition();
12705
12706 wxPyEndAllowThreads(__tstate);
12707 if (PyErr_Occurred()) SWIG_fail;
12708 }
12709 {
12710 resultobj = SWIG_From_int(static_cast<int >(result));
12711 }
12712 return resultobj;
12713 fail:
12714 return NULL;
12715 }
12716
12717
12718 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12719 PyObject *resultobj = NULL;
12720 wxJoystick *arg1 = (wxJoystick *) 0 ;
12721 int result;
12722 PyObject * obj0 = 0 ;
12723 char *kwnames[] = {
12724 (char *) "self", NULL
12725 };
12726
12727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
12728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12729 if (SWIG_arg_fail(1)) SWIG_fail;
12730 {
12731 PyThreadState* __tstate = wxPyBeginAllowThreads();
12732 result = (int)(arg1)->GetPOVCTSPosition();
12733
12734 wxPyEndAllowThreads(__tstate);
12735 if (PyErr_Occurred()) SWIG_fail;
12736 }
12737 {
12738 resultobj = SWIG_From_int(static_cast<int >(result));
12739 }
12740 return resultobj;
12741 fail:
12742 return NULL;
12743 }
12744
12745
12746 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12747 PyObject *resultobj = NULL;
12748 wxJoystick *arg1 = (wxJoystick *) 0 ;
12749 int result;
12750 PyObject * obj0 = 0 ;
12751 char *kwnames[] = {
12752 (char *) "self", NULL
12753 };
12754
12755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
12756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12757 if (SWIG_arg_fail(1)) SWIG_fail;
12758 {
12759 PyThreadState* __tstate = wxPyBeginAllowThreads();
12760 result = (int)(arg1)->GetRudderPosition();
12761
12762 wxPyEndAllowThreads(__tstate);
12763 if (PyErr_Occurred()) SWIG_fail;
12764 }
12765 {
12766 resultobj = SWIG_From_int(static_cast<int >(result));
12767 }
12768 return resultobj;
12769 fail:
12770 return NULL;
12771 }
12772
12773
12774 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12775 PyObject *resultobj = NULL;
12776 wxJoystick *arg1 = (wxJoystick *) 0 ;
12777 int result;
12778 PyObject * obj0 = 0 ;
12779 char *kwnames[] = {
12780 (char *) "self", NULL
12781 };
12782
12783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
12784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12785 if (SWIG_arg_fail(1)) SWIG_fail;
12786 {
12787 PyThreadState* __tstate = wxPyBeginAllowThreads();
12788 result = (int)(arg1)->GetUPosition();
12789
12790 wxPyEndAllowThreads(__tstate);
12791 if (PyErr_Occurred()) SWIG_fail;
12792 }
12793 {
12794 resultobj = SWIG_From_int(static_cast<int >(result));
12795 }
12796 return resultobj;
12797 fail:
12798 return NULL;
12799 }
12800
12801
12802 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12803 PyObject *resultobj = NULL;
12804 wxJoystick *arg1 = (wxJoystick *) 0 ;
12805 int result;
12806 PyObject * obj0 = 0 ;
12807 char *kwnames[] = {
12808 (char *) "self", NULL
12809 };
12810
12811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
12812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12813 if (SWIG_arg_fail(1)) SWIG_fail;
12814 {
12815 PyThreadState* __tstate = wxPyBeginAllowThreads();
12816 result = (int)(arg1)->GetVPosition();
12817
12818 wxPyEndAllowThreads(__tstate);
12819 if (PyErr_Occurred()) SWIG_fail;
12820 }
12821 {
12822 resultobj = SWIG_From_int(static_cast<int >(result));
12823 }
12824 return resultobj;
12825 fail:
12826 return NULL;
12827 }
12828
12829
12830 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
12831 PyObject *resultobj = NULL;
12832 wxJoystick *arg1 = (wxJoystick *) 0 ;
12833 int result;
12834 PyObject * obj0 = 0 ;
12835 char *kwnames[] = {
12836 (char *) "self", NULL
12837 };
12838
12839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
12840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12841 if (SWIG_arg_fail(1)) SWIG_fail;
12842 {
12843 PyThreadState* __tstate = wxPyBeginAllowThreads();
12844 result = (int)(arg1)->GetMovementThreshold();
12845
12846 wxPyEndAllowThreads(__tstate);
12847 if (PyErr_Occurred()) SWIG_fail;
12848 }
12849 {
12850 resultobj = SWIG_From_int(static_cast<int >(result));
12851 }
12852 return resultobj;
12853 fail:
12854 return NULL;
12855 }
12856
12857
12858 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
12859 PyObject *resultobj = NULL;
12860 wxJoystick *arg1 = (wxJoystick *) 0 ;
12861 int arg2 ;
12862 PyObject * obj0 = 0 ;
12863 PyObject * obj1 = 0 ;
12864 char *kwnames[] = {
12865 (char *) "self",(char *) "threshold", NULL
12866 };
12867
12868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
12869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12870 if (SWIG_arg_fail(1)) SWIG_fail;
12871 {
12872 arg2 = static_cast<int >(SWIG_As_int(obj1));
12873 if (SWIG_arg_fail(2)) SWIG_fail;
12874 }
12875 {
12876 PyThreadState* __tstate = wxPyBeginAllowThreads();
12877 (arg1)->SetMovementThreshold(arg2);
12878
12879 wxPyEndAllowThreads(__tstate);
12880 if (PyErr_Occurred()) SWIG_fail;
12881 }
12882 Py_INCREF(Py_None); resultobj = Py_None;
12883 return resultobj;
12884 fail:
12885 return NULL;
12886 }
12887
12888
12889 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
12890 PyObject *resultobj = NULL;
12891 wxJoystick *arg1 = (wxJoystick *) 0 ;
12892 bool result;
12893 PyObject * obj0 = 0 ;
12894 char *kwnames[] = {
12895 (char *) "self", NULL
12896 };
12897
12898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
12899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12900 if (SWIG_arg_fail(1)) SWIG_fail;
12901 {
12902 PyThreadState* __tstate = wxPyBeginAllowThreads();
12903 result = (bool)(arg1)->IsOk();
12904
12905 wxPyEndAllowThreads(__tstate);
12906 if (PyErr_Occurred()) SWIG_fail;
12907 }
12908 {
12909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12910 }
12911 return resultobj;
12912 fail:
12913 return NULL;
12914 }
12915
12916
12917 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
12918 PyObject *resultobj = NULL;
12919 wxJoystick *arg1 = (wxJoystick *) 0 ;
12920 int result;
12921 PyObject * obj0 = 0 ;
12922 char *kwnames[] = {
12923 (char *) "self", NULL
12924 };
12925
12926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
12927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12928 if (SWIG_arg_fail(1)) SWIG_fail;
12929 {
12930 PyThreadState* __tstate = wxPyBeginAllowThreads();
12931 result = (int)(arg1)->GetNumberJoysticks();
12932
12933 wxPyEndAllowThreads(__tstate);
12934 if (PyErr_Occurred()) SWIG_fail;
12935 }
12936 {
12937 resultobj = SWIG_From_int(static_cast<int >(result));
12938 }
12939 return resultobj;
12940 fail:
12941 return NULL;
12942 }
12943
12944
12945 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
12946 PyObject *resultobj = NULL;
12947 wxJoystick *arg1 = (wxJoystick *) 0 ;
12948 int result;
12949 PyObject * obj0 = 0 ;
12950 char *kwnames[] = {
12951 (char *) "self", NULL
12952 };
12953
12954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
12955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12956 if (SWIG_arg_fail(1)) SWIG_fail;
12957 {
12958 PyThreadState* __tstate = wxPyBeginAllowThreads();
12959 result = (int)(arg1)->GetManufacturerId();
12960
12961 wxPyEndAllowThreads(__tstate);
12962 if (PyErr_Occurred()) SWIG_fail;
12963 }
12964 {
12965 resultobj = SWIG_From_int(static_cast<int >(result));
12966 }
12967 return resultobj;
12968 fail:
12969 return NULL;
12970 }
12971
12972
12973 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12974 PyObject *resultobj = NULL;
12975 wxJoystick *arg1 = (wxJoystick *) 0 ;
12976 int result;
12977 PyObject * obj0 = 0 ;
12978 char *kwnames[] = {
12979 (char *) "self", NULL
12980 };
12981
12982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12984 if (SWIG_arg_fail(1)) SWIG_fail;
12985 {
12986 PyThreadState* __tstate = wxPyBeginAllowThreads();
12987 result = (int)(arg1)->GetProductId();
12988
12989 wxPyEndAllowThreads(__tstate);
12990 if (PyErr_Occurred()) SWIG_fail;
12991 }
12992 {
12993 resultobj = SWIG_From_int(static_cast<int >(result));
12994 }
12995 return resultobj;
12996 fail:
12997 return NULL;
12998 }
12999
13000
13001 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
13002 PyObject *resultobj = NULL;
13003 wxJoystick *arg1 = (wxJoystick *) 0 ;
13004 wxString result;
13005 PyObject * obj0 = 0 ;
13006 char *kwnames[] = {
13007 (char *) "self", NULL
13008 };
13009
13010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
13011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13012 if (SWIG_arg_fail(1)) SWIG_fail;
13013 {
13014 PyThreadState* __tstate = wxPyBeginAllowThreads();
13015 result = (arg1)->GetProductName();
13016
13017 wxPyEndAllowThreads(__tstate);
13018 if (PyErr_Occurred()) SWIG_fail;
13019 }
13020 {
13021 #if wxUSE_UNICODE
13022 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13023 #else
13024 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13025 #endif
13026 }
13027 return resultobj;
13028 fail:
13029 return NULL;
13030 }
13031
13032
13033 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
13034 PyObject *resultobj = NULL;
13035 wxJoystick *arg1 = (wxJoystick *) 0 ;
13036 int result;
13037 PyObject * obj0 = 0 ;
13038 char *kwnames[] = {
13039 (char *) "self", NULL
13040 };
13041
13042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
13043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13044 if (SWIG_arg_fail(1)) SWIG_fail;
13045 {
13046 PyThreadState* __tstate = wxPyBeginAllowThreads();
13047 result = (int)(arg1)->GetXMin();
13048
13049 wxPyEndAllowThreads(__tstate);
13050 if (PyErr_Occurred()) SWIG_fail;
13051 }
13052 {
13053 resultobj = SWIG_From_int(static_cast<int >(result));
13054 }
13055 return resultobj;
13056 fail:
13057 return NULL;
13058 }
13059
13060
13061 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
13062 PyObject *resultobj = NULL;
13063 wxJoystick *arg1 = (wxJoystick *) 0 ;
13064 int result;
13065 PyObject * obj0 = 0 ;
13066 char *kwnames[] = {
13067 (char *) "self", NULL
13068 };
13069
13070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
13071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13072 if (SWIG_arg_fail(1)) SWIG_fail;
13073 {
13074 PyThreadState* __tstate = wxPyBeginAllowThreads();
13075 result = (int)(arg1)->GetYMin();
13076
13077 wxPyEndAllowThreads(__tstate);
13078 if (PyErr_Occurred()) SWIG_fail;
13079 }
13080 {
13081 resultobj = SWIG_From_int(static_cast<int >(result));
13082 }
13083 return resultobj;
13084 fail:
13085 return NULL;
13086 }
13087
13088
13089 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
13090 PyObject *resultobj = NULL;
13091 wxJoystick *arg1 = (wxJoystick *) 0 ;
13092 int result;
13093 PyObject * obj0 = 0 ;
13094 char *kwnames[] = {
13095 (char *) "self", NULL
13096 };
13097
13098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
13099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13100 if (SWIG_arg_fail(1)) SWIG_fail;
13101 {
13102 PyThreadState* __tstate = wxPyBeginAllowThreads();
13103 result = (int)(arg1)->GetZMin();
13104
13105 wxPyEndAllowThreads(__tstate);
13106 if (PyErr_Occurred()) SWIG_fail;
13107 }
13108 {
13109 resultobj = SWIG_From_int(static_cast<int >(result));
13110 }
13111 return resultobj;
13112 fail:
13113 return NULL;
13114 }
13115
13116
13117 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
13118 PyObject *resultobj = NULL;
13119 wxJoystick *arg1 = (wxJoystick *) 0 ;
13120 int result;
13121 PyObject * obj0 = 0 ;
13122 char *kwnames[] = {
13123 (char *) "self", NULL
13124 };
13125
13126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
13127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13128 if (SWIG_arg_fail(1)) SWIG_fail;
13129 {
13130 PyThreadState* __tstate = wxPyBeginAllowThreads();
13131 result = (int)(arg1)->GetXMax();
13132
13133 wxPyEndAllowThreads(__tstate);
13134 if (PyErr_Occurred()) SWIG_fail;
13135 }
13136 {
13137 resultobj = SWIG_From_int(static_cast<int >(result));
13138 }
13139 return resultobj;
13140 fail:
13141 return NULL;
13142 }
13143
13144
13145 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
13146 PyObject *resultobj = NULL;
13147 wxJoystick *arg1 = (wxJoystick *) 0 ;
13148 int result;
13149 PyObject * obj0 = 0 ;
13150 char *kwnames[] = {
13151 (char *) "self", NULL
13152 };
13153
13154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
13155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13156 if (SWIG_arg_fail(1)) SWIG_fail;
13157 {
13158 PyThreadState* __tstate = wxPyBeginAllowThreads();
13159 result = (int)(arg1)->GetYMax();
13160
13161 wxPyEndAllowThreads(__tstate);
13162 if (PyErr_Occurred()) SWIG_fail;
13163 }
13164 {
13165 resultobj = SWIG_From_int(static_cast<int >(result));
13166 }
13167 return resultobj;
13168 fail:
13169 return NULL;
13170 }
13171
13172
13173 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
13174 PyObject *resultobj = NULL;
13175 wxJoystick *arg1 = (wxJoystick *) 0 ;
13176 int result;
13177 PyObject * obj0 = 0 ;
13178 char *kwnames[] = {
13179 (char *) "self", NULL
13180 };
13181
13182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
13183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13184 if (SWIG_arg_fail(1)) SWIG_fail;
13185 {
13186 PyThreadState* __tstate = wxPyBeginAllowThreads();
13187 result = (int)(arg1)->GetZMax();
13188
13189 wxPyEndAllowThreads(__tstate);
13190 if (PyErr_Occurred()) SWIG_fail;
13191 }
13192 {
13193 resultobj = SWIG_From_int(static_cast<int >(result));
13194 }
13195 return resultobj;
13196 fail:
13197 return NULL;
13198 }
13199
13200
13201 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
13202 PyObject *resultobj = NULL;
13203 wxJoystick *arg1 = (wxJoystick *) 0 ;
13204 int result;
13205 PyObject * obj0 = 0 ;
13206 char *kwnames[] = {
13207 (char *) "self", NULL
13208 };
13209
13210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
13211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13212 if (SWIG_arg_fail(1)) SWIG_fail;
13213 {
13214 PyThreadState* __tstate = wxPyBeginAllowThreads();
13215 result = (int)(arg1)->GetNumberButtons();
13216
13217 wxPyEndAllowThreads(__tstate);
13218 if (PyErr_Occurred()) SWIG_fail;
13219 }
13220 {
13221 resultobj = SWIG_From_int(static_cast<int >(result));
13222 }
13223 return resultobj;
13224 fail:
13225 return NULL;
13226 }
13227
13228
13229 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
13230 PyObject *resultobj = NULL;
13231 wxJoystick *arg1 = (wxJoystick *) 0 ;
13232 int result;
13233 PyObject * obj0 = 0 ;
13234 char *kwnames[] = {
13235 (char *) "self", NULL
13236 };
13237
13238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
13239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13240 if (SWIG_arg_fail(1)) SWIG_fail;
13241 {
13242 PyThreadState* __tstate = wxPyBeginAllowThreads();
13243 result = (int)(arg1)->GetNumberAxes();
13244
13245 wxPyEndAllowThreads(__tstate);
13246 if (PyErr_Occurred()) SWIG_fail;
13247 }
13248 {
13249 resultobj = SWIG_From_int(static_cast<int >(result));
13250 }
13251 return resultobj;
13252 fail:
13253 return NULL;
13254 }
13255
13256
13257 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
13258 PyObject *resultobj = NULL;
13259 wxJoystick *arg1 = (wxJoystick *) 0 ;
13260 int result;
13261 PyObject * obj0 = 0 ;
13262 char *kwnames[] = {
13263 (char *) "self", NULL
13264 };
13265
13266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
13267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13268 if (SWIG_arg_fail(1)) SWIG_fail;
13269 {
13270 PyThreadState* __tstate = wxPyBeginAllowThreads();
13271 result = (int)(arg1)->GetMaxButtons();
13272
13273 wxPyEndAllowThreads(__tstate);
13274 if (PyErr_Occurred()) SWIG_fail;
13275 }
13276 {
13277 resultobj = SWIG_From_int(static_cast<int >(result));
13278 }
13279 return resultobj;
13280 fail:
13281 return NULL;
13282 }
13283
13284
13285 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
13286 PyObject *resultobj = NULL;
13287 wxJoystick *arg1 = (wxJoystick *) 0 ;
13288 int result;
13289 PyObject * obj0 = 0 ;
13290 char *kwnames[] = {
13291 (char *) "self", NULL
13292 };
13293
13294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
13295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13296 if (SWIG_arg_fail(1)) SWIG_fail;
13297 {
13298 PyThreadState* __tstate = wxPyBeginAllowThreads();
13299 result = (int)(arg1)->GetMaxAxes();
13300
13301 wxPyEndAllowThreads(__tstate);
13302 if (PyErr_Occurred()) SWIG_fail;
13303 }
13304 {
13305 resultobj = SWIG_From_int(static_cast<int >(result));
13306 }
13307 return resultobj;
13308 fail:
13309 return NULL;
13310 }
13311
13312
13313 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
13314 PyObject *resultobj = NULL;
13315 wxJoystick *arg1 = (wxJoystick *) 0 ;
13316 int result;
13317 PyObject * obj0 = 0 ;
13318 char *kwnames[] = {
13319 (char *) "self", NULL
13320 };
13321
13322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
13323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13324 if (SWIG_arg_fail(1)) SWIG_fail;
13325 {
13326 PyThreadState* __tstate = wxPyBeginAllowThreads();
13327 result = (int)(arg1)->GetPollingMin();
13328
13329 wxPyEndAllowThreads(__tstate);
13330 if (PyErr_Occurred()) SWIG_fail;
13331 }
13332 {
13333 resultobj = SWIG_From_int(static_cast<int >(result));
13334 }
13335 return resultobj;
13336 fail:
13337 return NULL;
13338 }
13339
13340
13341 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
13342 PyObject *resultobj = NULL;
13343 wxJoystick *arg1 = (wxJoystick *) 0 ;
13344 int result;
13345 PyObject * obj0 = 0 ;
13346 char *kwnames[] = {
13347 (char *) "self", NULL
13348 };
13349
13350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
13351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13352 if (SWIG_arg_fail(1)) SWIG_fail;
13353 {
13354 PyThreadState* __tstate = wxPyBeginAllowThreads();
13355 result = (int)(arg1)->GetPollingMax();
13356
13357 wxPyEndAllowThreads(__tstate);
13358 if (PyErr_Occurred()) SWIG_fail;
13359 }
13360 {
13361 resultobj = SWIG_From_int(static_cast<int >(result));
13362 }
13363 return resultobj;
13364 fail:
13365 return NULL;
13366 }
13367
13368
13369 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
13370 PyObject *resultobj = NULL;
13371 wxJoystick *arg1 = (wxJoystick *) 0 ;
13372 int result;
13373 PyObject * obj0 = 0 ;
13374 char *kwnames[] = {
13375 (char *) "self", NULL
13376 };
13377
13378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
13379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13380 if (SWIG_arg_fail(1)) SWIG_fail;
13381 {
13382 PyThreadState* __tstate = wxPyBeginAllowThreads();
13383 result = (int)(arg1)->GetRudderMin();
13384
13385 wxPyEndAllowThreads(__tstate);
13386 if (PyErr_Occurred()) SWIG_fail;
13387 }
13388 {
13389 resultobj = SWIG_From_int(static_cast<int >(result));
13390 }
13391 return resultobj;
13392 fail:
13393 return NULL;
13394 }
13395
13396
13397 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
13398 PyObject *resultobj = NULL;
13399 wxJoystick *arg1 = (wxJoystick *) 0 ;
13400 int result;
13401 PyObject * obj0 = 0 ;
13402 char *kwnames[] = {
13403 (char *) "self", NULL
13404 };
13405
13406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
13407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13408 if (SWIG_arg_fail(1)) SWIG_fail;
13409 {
13410 PyThreadState* __tstate = wxPyBeginAllowThreads();
13411 result = (int)(arg1)->GetRudderMax();
13412
13413 wxPyEndAllowThreads(__tstate);
13414 if (PyErr_Occurred()) SWIG_fail;
13415 }
13416 {
13417 resultobj = SWIG_From_int(static_cast<int >(result));
13418 }
13419 return resultobj;
13420 fail:
13421 return NULL;
13422 }
13423
13424
13425 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
13426 PyObject *resultobj = NULL;
13427 wxJoystick *arg1 = (wxJoystick *) 0 ;
13428 int result;
13429 PyObject * obj0 = 0 ;
13430 char *kwnames[] = {
13431 (char *) "self", NULL
13432 };
13433
13434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
13435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13436 if (SWIG_arg_fail(1)) SWIG_fail;
13437 {
13438 PyThreadState* __tstate = wxPyBeginAllowThreads();
13439 result = (int)(arg1)->GetUMin();
13440
13441 wxPyEndAllowThreads(__tstate);
13442 if (PyErr_Occurred()) SWIG_fail;
13443 }
13444 {
13445 resultobj = SWIG_From_int(static_cast<int >(result));
13446 }
13447 return resultobj;
13448 fail:
13449 return NULL;
13450 }
13451
13452
13453 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
13454 PyObject *resultobj = NULL;
13455 wxJoystick *arg1 = (wxJoystick *) 0 ;
13456 int result;
13457 PyObject * obj0 = 0 ;
13458 char *kwnames[] = {
13459 (char *) "self", NULL
13460 };
13461
13462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
13463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13464 if (SWIG_arg_fail(1)) SWIG_fail;
13465 {
13466 PyThreadState* __tstate = wxPyBeginAllowThreads();
13467 result = (int)(arg1)->GetUMax();
13468
13469 wxPyEndAllowThreads(__tstate);
13470 if (PyErr_Occurred()) SWIG_fail;
13471 }
13472 {
13473 resultobj = SWIG_From_int(static_cast<int >(result));
13474 }
13475 return resultobj;
13476 fail:
13477 return NULL;
13478 }
13479
13480
13481 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
13482 PyObject *resultobj = NULL;
13483 wxJoystick *arg1 = (wxJoystick *) 0 ;
13484 int result;
13485 PyObject * obj0 = 0 ;
13486 char *kwnames[] = {
13487 (char *) "self", NULL
13488 };
13489
13490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
13491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13492 if (SWIG_arg_fail(1)) SWIG_fail;
13493 {
13494 PyThreadState* __tstate = wxPyBeginAllowThreads();
13495 result = (int)(arg1)->GetVMin();
13496
13497 wxPyEndAllowThreads(__tstate);
13498 if (PyErr_Occurred()) SWIG_fail;
13499 }
13500 {
13501 resultobj = SWIG_From_int(static_cast<int >(result));
13502 }
13503 return resultobj;
13504 fail:
13505 return NULL;
13506 }
13507
13508
13509 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
13510 PyObject *resultobj = NULL;
13511 wxJoystick *arg1 = (wxJoystick *) 0 ;
13512 int result;
13513 PyObject * obj0 = 0 ;
13514 char *kwnames[] = {
13515 (char *) "self", NULL
13516 };
13517
13518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
13519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13520 if (SWIG_arg_fail(1)) SWIG_fail;
13521 {
13522 PyThreadState* __tstate = wxPyBeginAllowThreads();
13523 result = (int)(arg1)->GetVMax();
13524
13525 wxPyEndAllowThreads(__tstate);
13526 if (PyErr_Occurred()) SWIG_fail;
13527 }
13528 {
13529 resultobj = SWIG_From_int(static_cast<int >(result));
13530 }
13531 return resultobj;
13532 fail:
13533 return NULL;
13534 }
13535
13536
13537 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
13538 PyObject *resultobj = NULL;
13539 wxJoystick *arg1 = (wxJoystick *) 0 ;
13540 bool result;
13541 PyObject * obj0 = 0 ;
13542 char *kwnames[] = {
13543 (char *) "self", NULL
13544 };
13545
13546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
13547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13548 if (SWIG_arg_fail(1)) SWIG_fail;
13549 {
13550 PyThreadState* __tstate = wxPyBeginAllowThreads();
13551 result = (bool)(arg1)->HasRudder();
13552
13553 wxPyEndAllowThreads(__tstate);
13554 if (PyErr_Occurred()) SWIG_fail;
13555 }
13556 {
13557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13558 }
13559 return resultobj;
13560 fail:
13561 return NULL;
13562 }
13563
13564
13565 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
13566 PyObject *resultobj = NULL;
13567 wxJoystick *arg1 = (wxJoystick *) 0 ;
13568 bool result;
13569 PyObject * obj0 = 0 ;
13570 char *kwnames[] = {
13571 (char *) "self", NULL
13572 };
13573
13574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
13575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13576 if (SWIG_arg_fail(1)) SWIG_fail;
13577 {
13578 PyThreadState* __tstate = wxPyBeginAllowThreads();
13579 result = (bool)(arg1)->HasZ();
13580
13581 wxPyEndAllowThreads(__tstate);
13582 if (PyErr_Occurred()) SWIG_fail;
13583 }
13584 {
13585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13586 }
13587 return resultobj;
13588 fail:
13589 return NULL;
13590 }
13591
13592
13593 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
13594 PyObject *resultobj = NULL;
13595 wxJoystick *arg1 = (wxJoystick *) 0 ;
13596 bool result;
13597 PyObject * obj0 = 0 ;
13598 char *kwnames[] = {
13599 (char *) "self", NULL
13600 };
13601
13602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
13603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13604 if (SWIG_arg_fail(1)) SWIG_fail;
13605 {
13606 PyThreadState* __tstate = wxPyBeginAllowThreads();
13607 result = (bool)(arg1)->HasU();
13608
13609 wxPyEndAllowThreads(__tstate);
13610 if (PyErr_Occurred()) SWIG_fail;
13611 }
13612 {
13613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13614 }
13615 return resultobj;
13616 fail:
13617 return NULL;
13618 }
13619
13620
13621 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
13622 PyObject *resultobj = NULL;
13623 wxJoystick *arg1 = (wxJoystick *) 0 ;
13624 bool result;
13625 PyObject * obj0 = 0 ;
13626 char *kwnames[] = {
13627 (char *) "self", NULL
13628 };
13629
13630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
13631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13632 if (SWIG_arg_fail(1)) SWIG_fail;
13633 {
13634 PyThreadState* __tstate = wxPyBeginAllowThreads();
13635 result = (bool)(arg1)->HasV();
13636
13637 wxPyEndAllowThreads(__tstate);
13638 if (PyErr_Occurred()) SWIG_fail;
13639 }
13640 {
13641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13642 }
13643 return resultobj;
13644 fail:
13645 return NULL;
13646 }
13647
13648
13649 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
13650 PyObject *resultobj = NULL;
13651 wxJoystick *arg1 = (wxJoystick *) 0 ;
13652 bool result;
13653 PyObject * obj0 = 0 ;
13654 char *kwnames[] = {
13655 (char *) "self", NULL
13656 };
13657
13658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
13659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13660 if (SWIG_arg_fail(1)) SWIG_fail;
13661 {
13662 PyThreadState* __tstate = wxPyBeginAllowThreads();
13663 result = (bool)(arg1)->HasPOV();
13664
13665 wxPyEndAllowThreads(__tstate);
13666 if (PyErr_Occurred()) SWIG_fail;
13667 }
13668 {
13669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13670 }
13671 return resultobj;
13672 fail:
13673 return NULL;
13674 }
13675
13676
13677 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
13678 PyObject *resultobj = NULL;
13679 wxJoystick *arg1 = (wxJoystick *) 0 ;
13680 bool result;
13681 PyObject * obj0 = 0 ;
13682 char *kwnames[] = {
13683 (char *) "self", NULL
13684 };
13685
13686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
13687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13688 if (SWIG_arg_fail(1)) SWIG_fail;
13689 {
13690 PyThreadState* __tstate = wxPyBeginAllowThreads();
13691 result = (bool)(arg1)->HasPOV4Dir();
13692
13693 wxPyEndAllowThreads(__tstate);
13694 if (PyErr_Occurred()) SWIG_fail;
13695 }
13696 {
13697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13698 }
13699 return resultobj;
13700 fail:
13701 return NULL;
13702 }
13703
13704
13705 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
13706 PyObject *resultobj = NULL;
13707 wxJoystick *arg1 = (wxJoystick *) 0 ;
13708 bool result;
13709 PyObject * obj0 = 0 ;
13710 char *kwnames[] = {
13711 (char *) "self", NULL
13712 };
13713
13714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
13715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13716 if (SWIG_arg_fail(1)) SWIG_fail;
13717 {
13718 PyThreadState* __tstate = wxPyBeginAllowThreads();
13719 result = (bool)(arg1)->HasPOVCTS();
13720
13721 wxPyEndAllowThreads(__tstate);
13722 if (PyErr_Occurred()) SWIG_fail;
13723 }
13724 {
13725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13726 }
13727 return resultobj;
13728 fail:
13729 return NULL;
13730 }
13731
13732
13733 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
13734 PyObject *resultobj = NULL;
13735 wxJoystick *arg1 = (wxJoystick *) 0 ;
13736 wxWindow *arg2 = (wxWindow *) 0 ;
13737 int arg3 = (int) 0 ;
13738 bool result;
13739 PyObject * obj0 = 0 ;
13740 PyObject * obj1 = 0 ;
13741 PyObject * obj2 = 0 ;
13742 char *kwnames[] = {
13743 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
13744 };
13745
13746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
13747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13748 if (SWIG_arg_fail(1)) SWIG_fail;
13749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
13750 if (SWIG_arg_fail(2)) SWIG_fail;
13751 if (obj2) {
13752 {
13753 arg3 = static_cast<int >(SWIG_As_int(obj2));
13754 if (SWIG_arg_fail(3)) SWIG_fail;
13755 }
13756 }
13757 {
13758 PyThreadState* __tstate = wxPyBeginAllowThreads();
13759 result = (bool)(arg1)->SetCapture(arg2,arg3);
13760
13761 wxPyEndAllowThreads(__tstate);
13762 if (PyErr_Occurred()) SWIG_fail;
13763 }
13764 {
13765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13766 }
13767 return resultobj;
13768 fail:
13769 return NULL;
13770 }
13771
13772
13773 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
13774 PyObject *resultobj = NULL;
13775 wxJoystick *arg1 = (wxJoystick *) 0 ;
13776 bool result;
13777 PyObject * obj0 = 0 ;
13778 char *kwnames[] = {
13779 (char *) "self", NULL
13780 };
13781
13782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
13783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
13784 if (SWIG_arg_fail(1)) SWIG_fail;
13785 {
13786 PyThreadState* __tstate = wxPyBeginAllowThreads();
13787 result = (bool)(arg1)->ReleaseCapture();
13788
13789 wxPyEndAllowThreads(__tstate);
13790 if (PyErr_Occurred()) SWIG_fail;
13791 }
13792 {
13793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13794 }
13795 return resultobj;
13796 fail:
13797 return NULL;
13798 }
13799
13800
13801 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
13802 PyObject *obj;
13803 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13804 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
13805 Py_INCREF(obj);
13806 return Py_BuildValue((char *)"");
13807 }
13808 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
13809 PyObject *resultobj = NULL;
13810 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
13811 int arg2 = (int) 0 ;
13812 int arg3 = (int) wxJOYSTICK1 ;
13813 int arg4 = (int) 0 ;
13814 wxJoystickEvent *result;
13815 PyObject * obj0 = 0 ;
13816 PyObject * obj1 = 0 ;
13817 PyObject * obj2 = 0 ;
13818 PyObject * obj3 = 0 ;
13819 char *kwnames[] = {
13820 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
13821 };
13822
13823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13824 if (obj0) {
13825 {
13826 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
13827 if (SWIG_arg_fail(1)) SWIG_fail;
13828 }
13829 }
13830 if (obj1) {
13831 {
13832 arg2 = static_cast<int >(SWIG_As_int(obj1));
13833 if (SWIG_arg_fail(2)) SWIG_fail;
13834 }
13835 }
13836 if (obj2) {
13837 {
13838 arg3 = static_cast<int >(SWIG_As_int(obj2));
13839 if (SWIG_arg_fail(3)) SWIG_fail;
13840 }
13841 }
13842 if (obj3) {
13843 {
13844 arg4 = static_cast<int >(SWIG_As_int(obj3));
13845 if (SWIG_arg_fail(4)) SWIG_fail;
13846 }
13847 }
13848 {
13849 PyThreadState* __tstate = wxPyBeginAllowThreads();
13850 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
13851
13852 wxPyEndAllowThreads(__tstate);
13853 if (PyErr_Occurred()) SWIG_fail;
13854 }
13855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
13856 return resultobj;
13857 fail:
13858 return NULL;
13859 }
13860
13861
13862 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13863 PyObject *resultobj = NULL;
13864 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13865 wxPoint result;
13866 PyObject * obj0 = 0 ;
13867 char *kwnames[] = {
13868 (char *) "self", NULL
13869 };
13870
13871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
13872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13873 if (SWIG_arg_fail(1)) SWIG_fail;
13874 {
13875 PyThreadState* __tstate = wxPyBeginAllowThreads();
13876 result = ((wxJoystickEvent const *)arg1)->GetPosition();
13877
13878 wxPyEndAllowThreads(__tstate);
13879 if (PyErr_Occurred()) SWIG_fail;
13880 }
13881 {
13882 wxPoint * resultptr;
13883 resultptr = new wxPoint(static_cast<wxPoint & >(result));
13884 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
13885 }
13886 return resultobj;
13887 fail:
13888 return NULL;
13889 }
13890
13891
13892 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13893 PyObject *resultobj = NULL;
13894 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13895 int result;
13896 PyObject * obj0 = 0 ;
13897 char *kwnames[] = {
13898 (char *) "self", NULL
13899 };
13900
13901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
13902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13903 if (SWIG_arg_fail(1)) SWIG_fail;
13904 {
13905 PyThreadState* __tstate = wxPyBeginAllowThreads();
13906 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
13907
13908 wxPyEndAllowThreads(__tstate);
13909 if (PyErr_Occurred()) SWIG_fail;
13910 }
13911 {
13912 resultobj = SWIG_From_int(static_cast<int >(result));
13913 }
13914 return resultobj;
13915 fail:
13916 return NULL;
13917 }
13918
13919
13920 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13921 PyObject *resultobj = NULL;
13922 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13923 int result;
13924 PyObject * obj0 = 0 ;
13925 char *kwnames[] = {
13926 (char *) "self", NULL
13927 };
13928
13929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
13930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13931 if (SWIG_arg_fail(1)) SWIG_fail;
13932 {
13933 PyThreadState* __tstate = wxPyBeginAllowThreads();
13934 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
13935
13936 wxPyEndAllowThreads(__tstate);
13937 if (PyErr_Occurred()) SWIG_fail;
13938 }
13939 {
13940 resultobj = SWIG_From_int(static_cast<int >(result));
13941 }
13942 return resultobj;
13943 fail:
13944 return NULL;
13945 }
13946
13947
13948 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13949 PyObject *resultobj = NULL;
13950 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13951 int result;
13952 PyObject * obj0 = 0 ;
13953 char *kwnames[] = {
13954 (char *) "self", NULL
13955 };
13956
13957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
13958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13959 if (SWIG_arg_fail(1)) SWIG_fail;
13960 {
13961 PyThreadState* __tstate = wxPyBeginAllowThreads();
13962 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
13963
13964 wxPyEndAllowThreads(__tstate);
13965 if (PyErr_Occurred()) SWIG_fail;
13966 }
13967 {
13968 resultobj = SWIG_From_int(static_cast<int >(result));
13969 }
13970 return resultobj;
13971 fail:
13972 return NULL;
13973 }
13974
13975
13976 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13977 PyObject *resultobj = NULL;
13978 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13979 int result;
13980 PyObject * obj0 = 0 ;
13981 char *kwnames[] = {
13982 (char *) "self", NULL
13983 };
13984
13985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13987 if (SWIG_arg_fail(1)) SWIG_fail;
13988 {
13989 PyThreadState* __tstate = wxPyBeginAllowThreads();
13990 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13991
13992 wxPyEndAllowThreads(__tstate);
13993 if (PyErr_Occurred()) SWIG_fail;
13994 }
13995 {
13996 resultobj = SWIG_From_int(static_cast<int >(result));
13997 }
13998 return resultobj;
13999 fail:
14000 return NULL;
14001 }
14002
14003
14004 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
14005 PyObject *resultobj = NULL;
14006 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14007 int arg2 ;
14008 PyObject * obj0 = 0 ;
14009 PyObject * obj1 = 0 ;
14010 char *kwnames[] = {
14011 (char *) "self",(char *) "stick", NULL
14012 };
14013
14014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
14015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14016 if (SWIG_arg_fail(1)) SWIG_fail;
14017 {
14018 arg2 = static_cast<int >(SWIG_As_int(obj1));
14019 if (SWIG_arg_fail(2)) SWIG_fail;
14020 }
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 (arg1)->SetJoystick(arg2);
14024
14025 wxPyEndAllowThreads(__tstate);
14026 if (PyErr_Occurred()) SWIG_fail;
14027 }
14028 Py_INCREF(Py_None); resultobj = Py_None;
14029 return resultobj;
14030 fail:
14031 return NULL;
14032 }
14033
14034
14035 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
14036 PyObject *resultobj = NULL;
14037 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14038 int arg2 ;
14039 PyObject * obj0 = 0 ;
14040 PyObject * obj1 = 0 ;
14041 char *kwnames[] = {
14042 (char *) "self",(char *) "state", NULL
14043 };
14044
14045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
14046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14047 if (SWIG_arg_fail(1)) SWIG_fail;
14048 {
14049 arg2 = static_cast<int >(SWIG_As_int(obj1));
14050 if (SWIG_arg_fail(2)) SWIG_fail;
14051 }
14052 {
14053 PyThreadState* __tstate = wxPyBeginAllowThreads();
14054 (arg1)->SetButtonState(arg2);
14055
14056 wxPyEndAllowThreads(__tstate);
14057 if (PyErr_Occurred()) SWIG_fail;
14058 }
14059 Py_INCREF(Py_None); resultobj = Py_None;
14060 return resultobj;
14061 fail:
14062 return NULL;
14063 }
14064
14065
14066 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
14067 PyObject *resultobj = NULL;
14068 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14069 int arg2 ;
14070 PyObject * obj0 = 0 ;
14071 PyObject * obj1 = 0 ;
14072 char *kwnames[] = {
14073 (char *) "self",(char *) "change", NULL
14074 };
14075
14076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
14077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14078 if (SWIG_arg_fail(1)) SWIG_fail;
14079 {
14080 arg2 = static_cast<int >(SWIG_As_int(obj1));
14081 if (SWIG_arg_fail(2)) SWIG_fail;
14082 }
14083 {
14084 PyThreadState* __tstate = wxPyBeginAllowThreads();
14085 (arg1)->SetButtonChange(arg2);
14086
14087 wxPyEndAllowThreads(__tstate);
14088 if (PyErr_Occurred()) SWIG_fail;
14089 }
14090 Py_INCREF(Py_None); resultobj = Py_None;
14091 return resultobj;
14092 fail:
14093 return NULL;
14094 }
14095
14096
14097 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
14098 PyObject *resultobj = NULL;
14099 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14100 wxPoint *arg2 = 0 ;
14101 wxPoint temp2 ;
14102 PyObject * obj0 = 0 ;
14103 PyObject * obj1 = 0 ;
14104 char *kwnames[] = {
14105 (char *) "self",(char *) "pos", NULL
14106 };
14107
14108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
14109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14110 if (SWIG_arg_fail(1)) SWIG_fail;
14111 {
14112 arg2 = &temp2;
14113 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
14114 }
14115 {
14116 PyThreadState* __tstate = wxPyBeginAllowThreads();
14117 (arg1)->SetPosition((wxPoint const &)*arg2);
14118
14119 wxPyEndAllowThreads(__tstate);
14120 if (PyErr_Occurred()) SWIG_fail;
14121 }
14122 Py_INCREF(Py_None); resultobj = Py_None;
14123 return resultobj;
14124 fail:
14125 return NULL;
14126 }
14127
14128
14129 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
14130 PyObject *resultobj = NULL;
14131 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14132 int arg2 ;
14133 PyObject * obj0 = 0 ;
14134 PyObject * obj1 = 0 ;
14135 char *kwnames[] = {
14136 (char *) "self",(char *) "zPos", NULL
14137 };
14138
14139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
14140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14141 if (SWIG_arg_fail(1)) SWIG_fail;
14142 {
14143 arg2 = static_cast<int >(SWIG_As_int(obj1));
14144 if (SWIG_arg_fail(2)) SWIG_fail;
14145 }
14146 {
14147 PyThreadState* __tstate = wxPyBeginAllowThreads();
14148 (arg1)->SetZPosition(arg2);
14149
14150 wxPyEndAllowThreads(__tstate);
14151 if (PyErr_Occurred()) SWIG_fail;
14152 }
14153 Py_INCREF(Py_None); resultobj = Py_None;
14154 return resultobj;
14155 fail:
14156 return NULL;
14157 }
14158
14159
14160 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
14161 PyObject *resultobj = NULL;
14162 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14163 bool result;
14164 PyObject * obj0 = 0 ;
14165 char *kwnames[] = {
14166 (char *) "self", NULL
14167 };
14168
14169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
14170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14171 if (SWIG_arg_fail(1)) SWIG_fail;
14172 {
14173 PyThreadState* __tstate = wxPyBeginAllowThreads();
14174 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
14175
14176 wxPyEndAllowThreads(__tstate);
14177 if (PyErr_Occurred()) SWIG_fail;
14178 }
14179 {
14180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14181 }
14182 return resultobj;
14183 fail:
14184 return NULL;
14185 }
14186
14187
14188 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
14189 PyObject *resultobj = NULL;
14190 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14191 bool result;
14192 PyObject * obj0 = 0 ;
14193 char *kwnames[] = {
14194 (char *) "self", NULL
14195 };
14196
14197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
14198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14199 if (SWIG_arg_fail(1)) SWIG_fail;
14200 {
14201 PyThreadState* __tstate = wxPyBeginAllowThreads();
14202 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
14203
14204 wxPyEndAllowThreads(__tstate);
14205 if (PyErr_Occurred()) SWIG_fail;
14206 }
14207 {
14208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14209 }
14210 return resultobj;
14211 fail:
14212 return NULL;
14213 }
14214
14215
14216 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
14217 PyObject *resultobj = NULL;
14218 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14219 bool result;
14220 PyObject * obj0 = 0 ;
14221 char *kwnames[] = {
14222 (char *) "self", NULL
14223 };
14224
14225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
14226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14227 if (SWIG_arg_fail(1)) SWIG_fail;
14228 {
14229 PyThreadState* __tstate = wxPyBeginAllowThreads();
14230 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
14231
14232 wxPyEndAllowThreads(__tstate);
14233 if (PyErr_Occurred()) SWIG_fail;
14234 }
14235 {
14236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14237 }
14238 return resultobj;
14239 fail:
14240 return NULL;
14241 }
14242
14243
14244 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
14245 PyObject *resultobj = NULL;
14246 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14247 int arg2 = (int) wxJOY_BUTTON_ANY ;
14248 bool result;
14249 PyObject * obj0 = 0 ;
14250 PyObject * obj1 = 0 ;
14251 char *kwnames[] = {
14252 (char *) "self",(char *) "but", NULL
14253 };
14254
14255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
14256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14257 if (SWIG_arg_fail(1)) SWIG_fail;
14258 if (obj1) {
14259 {
14260 arg2 = static_cast<int >(SWIG_As_int(obj1));
14261 if (SWIG_arg_fail(2)) SWIG_fail;
14262 }
14263 }
14264 {
14265 PyThreadState* __tstate = wxPyBeginAllowThreads();
14266 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
14267
14268 wxPyEndAllowThreads(__tstate);
14269 if (PyErr_Occurred()) SWIG_fail;
14270 }
14271 {
14272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14273 }
14274 return resultobj;
14275 fail:
14276 return NULL;
14277 }
14278
14279
14280 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
14281 PyObject *resultobj = NULL;
14282 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14283 int arg2 = (int) wxJOY_BUTTON_ANY ;
14284 bool result;
14285 PyObject * obj0 = 0 ;
14286 PyObject * obj1 = 0 ;
14287 char *kwnames[] = {
14288 (char *) "self",(char *) "but", NULL
14289 };
14290
14291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
14292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14293 if (SWIG_arg_fail(1)) SWIG_fail;
14294 if (obj1) {
14295 {
14296 arg2 = static_cast<int >(SWIG_As_int(obj1));
14297 if (SWIG_arg_fail(2)) SWIG_fail;
14298 }
14299 }
14300 {
14301 PyThreadState* __tstate = wxPyBeginAllowThreads();
14302 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
14303
14304 wxPyEndAllowThreads(__tstate);
14305 if (PyErr_Occurred()) SWIG_fail;
14306 }
14307 {
14308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14309 }
14310 return resultobj;
14311 fail:
14312 return NULL;
14313 }
14314
14315
14316 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
14317 PyObject *resultobj = NULL;
14318 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
14319 int arg2 = (int) wxJOY_BUTTON_ANY ;
14320 bool result;
14321 PyObject * obj0 = 0 ;
14322 PyObject * obj1 = 0 ;
14323 char *kwnames[] = {
14324 (char *) "self",(char *) "but", NULL
14325 };
14326
14327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
14328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
14329 if (SWIG_arg_fail(1)) SWIG_fail;
14330 if (obj1) {
14331 {
14332 arg2 = static_cast<int >(SWIG_As_int(obj1));
14333 if (SWIG_arg_fail(2)) SWIG_fail;
14334 }
14335 }
14336 {
14337 PyThreadState* __tstate = wxPyBeginAllowThreads();
14338 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
14339
14340 wxPyEndAllowThreads(__tstate);
14341 if (PyErr_Occurred()) SWIG_fail;
14342 }
14343 {
14344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14345 }
14346 return resultobj;
14347 fail:
14348 return NULL;
14349 }
14350
14351
14352 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
14353 PyObject *obj;
14354 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14355 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
14356 Py_INCREF(obj);
14357 return Py_BuildValue((char *)"");
14358 }
14359 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
14360 PyObject *resultobj = NULL;
14361 wxString const &arg1_defvalue = wxPyEmptyString ;
14362 wxString *arg1 = (wxString *) &arg1_defvalue ;
14363 wxSound *result;
14364 bool temp1 = false ;
14365 PyObject * obj0 = 0 ;
14366 char *kwnames[] = {
14367 (char *) "fileName", NULL
14368 };
14369
14370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
14371 if (obj0) {
14372 {
14373 arg1 = wxString_in_helper(obj0);
14374 if (arg1 == NULL) SWIG_fail;
14375 temp1 = true;
14376 }
14377 }
14378 {
14379 if (!wxPyCheckForApp()) SWIG_fail;
14380 PyThreadState* __tstate = wxPyBeginAllowThreads();
14381 result = (wxSound *)new_wxSound((wxString const &)*arg1);
14382
14383 wxPyEndAllowThreads(__tstate);
14384 if (PyErr_Occurred()) SWIG_fail;
14385 }
14386 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
14387 {
14388 if (temp1)
14389 delete arg1;
14390 }
14391 return resultobj;
14392 fail:
14393 {
14394 if (temp1)
14395 delete arg1;
14396 }
14397 return NULL;
14398 }
14399
14400
14401 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
14402 PyObject *resultobj = NULL;
14403 PyObject *arg1 = (PyObject *) 0 ;
14404 wxSound *result;
14405 PyObject * obj0 = 0 ;
14406 char *kwnames[] = {
14407 (char *) "data", NULL
14408 };
14409
14410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
14411 arg1 = obj0;
14412 {
14413 if (!wxPyCheckForApp()) SWIG_fail;
14414 PyThreadState* __tstate = wxPyBeginAllowThreads();
14415 result = (wxSound *)new_wxSound(arg1);
14416
14417 wxPyEndAllowThreads(__tstate);
14418 if (PyErr_Occurred()) SWIG_fail;
14419 }
14420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
14421 return resultobj;
14422 fail:
14423 return NULL;
14424 }
14425
14426
14427 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
14428 PyObject *resultobj = NULL;
14429 wxSound *arg1 = (wxSound *) 0 ;
14430 PyObject * obj0 = 0 ;
14431 char *kwnames[] = {
14432 (char *) "self", NULL
14433 };
14434
14435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
14436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14437 if (SWIG_arg_fail(1)) SWIG_fail;
14438 {
14439 PyThreadState* __tstate = wxPyBeginAllowThreads();
14440 delete arg1;
14441
14442 wxPyEndAllowThreads(__tstate);
14443 if (PyErr_Occurred()) SWIG_fail;
14444 }
14445 Py_INCREF(Py_None); resultobj = Py_None;
14446 return resultobj;
14447 fail:
14448 return NULL;
14449 }
14450
14451
14452 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
14453 PyObject *resultobj = NULL;
14454 wxSound *arg1 = (wxSound *) 0 ;
14455 wxString *arg2 = 0 ;
14456 bool result;
14457 bool temp2 = false ;
14458 PyObject * obj0 = 0 ;
14459 PyObject * obj1 = 0 ;
14460 char *kwnames[] = {
14461 (char *) "self",(char *) "fileName", NULL
14462 };
14463
14464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
14465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14466 if (SWIG_arg_fail(1)) SWIG_fail;
14467 {
14468 arg2 = wxString_in_helper(obj1);
14469 if (arg2 == NULL) SWIG_fail;
14470 temp2 = true;
14471 }
14472 {
14473 PyThreadState* __tstate = wxPyBeginAllowThreads();
14474 result = (bool)(arg1)->Create((wxString const &)*arg2);
14475
14476 wxPyEndAllowThreads(__tstate);
14477 if (PyErr_Occurred()) SWIG_fail;
14478 }
14479 {
14480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14481 }
14482 {
14483 if (temp2)
14484 delete arg2;
14485 }
14486 return resultobj;
14487 fail:
14488 {
14489 if (temp2)
14490 delete arg2;
14491 }
14492 return NULL;
14493 }
14494
14495
14496 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
14497 PyObject *resultobj = NULL;
14498 wxSound *arg1 = (wxSound *) 0 ;
14499 PyObject *arg2 = (PyObject *) 0 ;
14500 bool result;
14501 PyObject * obj0 = 0 ;
14502 PyObject * obj1 = 0 ;
14503 char *kwnames[] = {
14504 (char *) "self",(char *) "data", NULL
14505 };
14506
14507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
14508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14509 if (SWIG_arg_fail(1)) SWIG_fail;
14510 arg2 = obj1;
14511 {
14512 PyThreadState* __tstate = wxPyBeginAllowThreads();
14513 result = (bool)wxSound_CreateFromData(arg1,arg2);
14514
14515 wxPyEndAllowThreads(__tstate);
14516 if (PyErr_Occurred()) SWIG_fail;
14517 }
14518 {
14519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14520 }
14521 return resultobj;
14522 fail:
14523 return NULL;
14524 }
14525
14526
14527 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
14528 PyObject *resultobj = NULL;
14529 wxSound *arg1 = (wxSound *) 0 ;
14530 bool result;
14531 PyObject * obj0 = 0 ;
14532 char *kwnames[] = {
14533 (char *) "self", NULL
14534 };
14535
14536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
14537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14538 if (SWIG_arg_fail(1)) SWIG_fail;
14539 {
14540 PyThreadState* __tstate = wxPyBeginAllowThreads();
14541 result = (bool)(arg1)->IsOk();
14542
14543 wxPyEndAllowThreads(__tstate);
14544 if (PyErr_Occurred()) SWIG_fail;
14545 }
14546 {
14547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14548 }
14549 return resultobj;
14550 fail:
14551 return NULL;
14552 }
14553
14554
14555 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
14556 PyObject *resultobj = NULL;
14557 wxSound *arg1 = (wxSound *) 0 ;
14558 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
14559 bool result;
14560 PyObject * obj0 = 0 ;
14561 PyObject * obj1 = 0 ;
14562 char *kwnames[] = {
14563 (char *) "self",(char *) "flags", NULL
14564 };
14565
14566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
14567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
14568 if (SWIG_arg_fail(1)) SWIG_fail;
14569 if (obj1) {
14570 {
14571 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
14572 if (SWIG_arg_fail(2)) SWIG_fail;
14573 }
14574 }
14575 {
14576 if (!wxPyCheckForApp()) SWIG_fail;
14577 PyThreadState* __tstate = wxPyBeginAllowThreads();
14578 result = (bool)((wxSound const *)arg1)->Play(arg2);
14579
14580 wxPyEndAllowThreads(__tstate);
14581 if (PyErr_Occurred()) SWIG_fail;
14582 }
14583 {
14584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14585 }
14586 return resultobj;
14587 fail:
14588 return NULL;
14589 }
14590
14591
14592 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
14593 PyObject *resultobj = NULL;
14594 wxString *arg1 = 0 ;
14595 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
14596 bool result;
14597 bool temp1 = false ;
14598 PyObject * obj0 = 0 ;
14599 PyObject * obj1 = 0 ;
14600 char *kwnames[] = {
14601 (char *) "filename",(char *) "flags", NULL
14602 };
14603
14604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
14605 {
14606 arg1 = wxString_in_helper(obj0);
14607 if (arg1 == NULL) SWIG_fail;
14608 temp1 = true;
14609 }
14610 if (obj1) {
14611 {
14612 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
14613 if (SWIG_arg_fail(2)) SWIG_fail;
14614 }
14615 }
14616 {
14617 if (!wxPyCheckForApp()) SWIG_fail;
14618 PyThreadState* __tstate = wxPyBeginAllowThreads();
14619 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
14620
14621 wxPyEndAllowThreads(__tstate);
14622 if (PyErr_Occurred()) SWIG_fail;
14623 }
14624 {
14625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14626 }
14627 {
14628 if (temp1)
14629 delete arg1;
14630 }
14631 return resultobj;
14632 fail:
14633 {
14634 if (temp1)
14635 delete arg1;
14636 }
14637 return NULL;
14638 }
14639
14640
14641 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
14642 PyObject *resultobj = NULL;
14643 char *kwnames[] = {
14644 NULL
14645 };
14646
14647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
14648 {
14649 if (!wxPyCheckForApp()) SWIG_fail;
14650 PyThreadState* __tstate = wxPyBeginAllowThreads();
14651 wxSound::Stop();
14652
14653 wxPyEndAllowThreads(__tstate);
14654 if (PyErr_Occurred()) SWIG_fail;
14655 }
14656 Py_INCREF(Py_None); resultobj = Py_None;
14657 return resultobj;
14658 fail:
14659 return NULL;
14660 }
14661
14662
14663 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
14664 PyObject *obj;
14665 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14666 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
14667 Py_INCREF(obj);
14668 return Py_BuildValue((char *)"");
14669 }
14670 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14671 PyObject *resultobj = NULL;
14672 wxString *arg1 = 0 ;
14673 wxString *arg2 = 0 ;
14674 wxString *arg3 = 0 ;
14675 wxString *arg4 = 0 ;
14676 wxFileTypeInfo *result;
14677 bool temp1 = false ;
14678 bool temp2 = false ;
14679 bool temp3 = false ;
14680 bool temp4 = false ;
14681 PyObject * obj0 = 0 ;
14682 PyObject * obj1 = 0 ;
14683 PyObject * obj2 = 0 ;
14684 PyObject * obj3 = 0 ;
14685 char *kwnames[] = {
14686 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
14687 };
14688
14689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14690 {
14691 arg1 = wxString_in_helper(obj0);
14692 if (arg1 == NULL) SWIG_fail;
14693 temp1 = true;
14694 }
14695 {
14696 arg2 = wxString_in_helper(obj1);
14697 if (arg2 == NULL) SWIG_fail;
14698 temp2 = true;
14699 }
14700 {
14701 arg3 = wxString_in_helper(obj2);
14702 if (arg3 == NULL) SWIG_fail;
14703 temp3 = true;
14704 }
14705 {
14706 arg4 = wxString_in_helper(obj3);
14707 if (arg4 == NULL) SWIG_fail;
14708 temp4 = true;
14709 }
14710 {
14711 PyThreadState* __tstate = wxPyBeginAllowThreads();
14712 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
14713
14714 wxPyEndAllowThreads(__tstate);
14715 if (PyErr_Occurred()) SWIG_fail;
14716 }
14717 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
14718 {
14719 if (temp1)
14720 delete arg1;
14721 }
14722 {
14723 if (temp2)
14724 delete arg2;
14725 }
14726 {
14727 if (temp3)
14728 delete arg3;
14729 }
14730 {
14731 if (temp4)
14732 delete arg4;
14733 }
14734 return resultobj;
14735 fail:
14736 {
14737 if (temp1)
14738 delete arg1;
14739 }
14740 {
14741 if (temp2)
14742 delete arg2;
14743 }
14744 {
14745 if (temp3)
14746 delete arg3;
14747 }
14748 {
14749 if (temp4)
14750 delete arg4;
14751 }
14752 return NULL;
14753 }
14754
14755
14756 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
14757 PyObject *resultobj = NULL;
14758 wxArrayString *arg1 = 0 ;
14759 wxFileTypeInfo *result;
14760 bool temp1 = false ;
14761 PyObject * obj0 = 0 ;
14762 char *kwnames[] = {
14763 (char *) "sArray", NULL
14764 };
14765
14766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
14767 {
14768 if (! PySequence_Check(obj0)) {
14769 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
14770 SWIG_fail;
14771 }
14772 arg1 = new wxArrayString;
14773 temp1 = true;
14774 int i, len=PySequence_Length(obj0);
14775 for (i=0; i<len; i++) {
14776 PyObject* item = PySequence_GetItem(obj0, i);
14777 wxString* s = wxString_in_helper(item);
14778 if (PyErr_Occurred()) SWIG_fail;
14779 arg1->Add(*s);
14780 delete s;
14781 Py_DECREF(item);
14782 }
14783 }
14784 {
14785 PyThreadState* __tstate = wxPyBeginAllowThreads();
14786 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
14787
14788 wxPyEndAllowThreads(__tstate);
14789 if (PyErr_Occurred()) SWIG_fail;
14790 }
14791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
14792 {
14793 if (temp1) delete arg1;
14794 }
14795 return resultobj;
14796 fail:
14797 {
14798 if (temp1) delete arg1;
14799 }
14800 return NULL;
14801 }
14802
14803
14804 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14805 PyObject *resultobj = NULL;
14806 wxFileTypeInfo *result;
14807 char *kwnames[] = {
14808 NULL
14809 };
14810
14811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
14812 {
14813 PyThreadState* __tstate = wxPyBeginAllowThreads();
14814 result = (wxFileTypeInfo *)new wxFileTypeInfo();
14815
14816 wxPyEndAllowThreads(__tstate);
14817 if (PyErr_Occurred()) SWIG_fail;
14818 }
14819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
14820 return resultobj;
14821 fail:
14822 return NULL;
14823 }
14824
14825
14826 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
14827 PyObject *resultobj = NULL;
14828 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14829 bool result;
14830 PyObject * obj0 = 0 ;
14831 char *kwnames[] = {
14832 (char *) "self", NULL
14833 };
14834
14835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
14836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14837 if (SWIG_arg_fail(1)) SWIG_fail;
14838 {
14839 PyThreadState* __tstate = wxPyBeginAllowThreads();
14840 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
14841
14842 wxPyEndAllowThreads(__tstate);
14843 if (PyErr_Occurred()) SWIG_fail;
14844 }
14845 {
14846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14847 }
14848 return resultobj;
14849 fail:
14850 return NULL;
14851 }
14852
14853
14854 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14855 PyObject *resultobj = NULL;
14856 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14857 wxString *arg2 = 0 ;
14858 int arg3 = (int) 0 ;
14859 bool temp2 = false ;
14860 PyObject * obj0 = 0 ;
14861 PyObject * obj1 = 0 ;
14862 PyObject * obj2 = 0 ;
14863 char *kwnames[] = {
14864 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
14865 };
14866
14867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14869 if (SWIG_arg_fail(1)) SWIG_fail;
14870 {
14871 arg2 = wxString_in_helper(obj1);
14872 if (arg2 == NULL) SWIG_fail;
14873 temp2 = true;
14874 }
14875 if (obj2) {
14876 {
14877 arg3 = static_cast<int >(SWIG_As_int(obj2));
14878 if (SWIG_arg_fail(3)) SWIG_fail;
14879 }
14880 }
14881 {
14882 PyThreadState* __tstate = wxPyBeginAllowThreads();
14883 (arg1)->SetIcon((wxString const &)*arg2,arg3);
14884
14885 wxPyEndAllowThreads(__tstate);
14886 if (PyErr_Occurred()) SWIG_fail;
14887 }
14888 Py_INCREF(Py_None); resultobj = Py_None;
14889 {
14890 if (temp2)
14891 delete arg2;
14892 }
14893 return resultobj;
14894 fail:
14895 {
14896 if (temp2)
14897 delete arg2;
14898 }
14899 return NULL;
14900 }
14901
14902
14903 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14904 PyObject *resultobj = NULL;
14905 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14906 wxString *arg2 = 0 ;
14907 bool temp2 = false ;
14908 PyObject * obj0 = 0 ;
14909 PyObject * obj1 = 0 ;
14910 char *kwnames[] = {
14911 (char *) "self",(char *) "shortDesc", NULL
14912 };
14913
14914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
14915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14916 if (SWIG_arg_fail(1)) SWIG_fail;
14917 {
14918 arg2 = wxString_in_helper(obj1);
14919 if (arg2 == NULL) SWIG_fail;
14920 temp2 = true;
14921 }
14922 {
14923 PyThreadState* __tstate = wxPyBeginAllowThreads();
14924 (arg1)->SetShortDesc((wxString const &)*arg2);
14925
14926 wxPyEndAllowThreads(__tstate);
14927 if (PyErr_Occurred()) SWIG_fail;
14928 }
14929 Py_INCREF(Py_None); resultobj = Py_None;
14930 {
14931 if (temp2)
14932 delete arg2;
14933 }
14934 return resultobj;
14935 fail:
14936 {
14937 if (temp2)
14938 delete arg2;
14939 }
14940 return NULL;
14941 }
14942
14943
14944 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14945 PyObject *resultobj = NULL;
14946 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14947 wxString *result;
14948 PyObject * obj0 = 0 ;
14949 char *kwnames[] = {
14950 (char *) "self", NULL
14951 };
14952
14953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14955 if (SWIG_arg_fail(1)) SWIG_fail;
14956 {
14957 PyThreadState* __tstate = wxPyBeginAllowThreads();
14958 {
14959 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14960 result = (wxString *) &_result_ref;
14961 }
14962
14963 wxPyEndAllowThreads(__tstate);
14964 if (PyErr_Occurred()) SWIG_fail;
14965 }
14966 {
14967 #if wxUSE_UNICODE
14968 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14969 #else
14970 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14971 #endif
14972 }
14973 return resultobj;
14974 fail:
14975 return NULL;
14976 }
14977
14978
14979 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14980 PyObject *resultobj = NULL;
14981 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14982 wxString *result;
14983 PyObject * obj0 = 0 ;
14984 char *kwnames[] = {
14985 (char *) "self", NULL
14986 };
14987
14988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14990 if (SWIG_arg_fail(1)) SWIG_fail;
14991 {
14992 PyThreadState* __tstate = wxPyBeginAllowThreads();
14993 {
14994 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14995 result = (wxString *) &_result_ref;
14996 }
14997
14998 wxPyEndAllowThreads(__tstate);
14999 if (PyErr_Occurred()) SWIG_fail;
15000 }
15001 {
15002 #if wxUSE_UNICODE
15003 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15004 #else
15005 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15006 #endif
15007 }
15008 return resultobj;
15009 fail:
15010 return NULL;
15011 }
15012
15013
15014 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15015 PyObject *resultobj = NULL;
15016 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15017 wxString *result;
15018 PyObject * obj0 = 0 ;
15019 char *kwnames[] = {
15020 (char *) "self", NULL
15021 };
15022
15023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
15024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15025 if (SWIG_arg_fail(1)) SWIG_fail;
15026 {
15027 PyThreadState* __tstate = wxPyBeginAllowThreads();
15028 {
15029 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
15030 result = (wxString *) &_result_ref;
15031 }
15032
15033 wxPyEndAllowThreads(__tstate);
15034 if (PyErr_Occurred()) SWIG_fail;
15035 }
15036 {
15037 #if wxUSE_UNICODE
15038 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15039 #else
15040 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15041 #endif
15042 }
15043 return resultobj;
15044 fail:
15045 return NULL;
15046 }
15047
15048
15049 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
15050 PyObject *resultobj = NULL;
15051 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15052 wxString *result;
15053 PyObject * obj0 = 0 ;
15054 char *kwnames[] = {
15055 (char *) "self", NULL
15056 };
15057
15058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
15059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15060 if (SWIG_arg_fail(1)) SWIG_fail;
15061 {
15062 PyThreadState* __tstate = wxPyBeginAllowThreads();
15063 {
15064 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
15065 result = (wxString *) &_result_ref;
15066 }
15067
15068 wxPyEndAllowThreads(__tstate);
15069 if (PyErr_Occurred()) SWIG_fail;
15070 }
15071 {
15072 #if wxUSE_UNICODE
15073 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15074 #else
15075 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15076 #endif
15077 }
15078 return resultobj;
15079 fail:
15080 return NULL;
15081 }
15082
15083
15084 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
15085 PyObject *resultobj = NULL;
15086 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15087 wxString *result;
15088 PyObject * obj0 = 0 ;
15089 char *kwnames[] = {
15090 (char *) "self", NULL
15091 };
15092
15093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
15094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15095 if (SWIG_arg_fail(1)) SWIG_fail;
15096 {
15097 PyThreadState* __tstate = wxPyBeginAllowThreads();
15098 {
15099 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
15100 result = (wxString *) &_result_ref;
15101 }
15102
15103 wxPyEndAllowThreads(__tstate);
15104 if (PyErr_Occurred()) SWIG_fail;
15105 }
15106 {
15107 #if wxUSE_UNICODE
15108 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15109 #else
15110 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15111 #endif
15112 }
15113 return resultobj;
15114 fail:
15115 return NULL;
15116 }
15117
15118
15119 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
15120 PyObject *resultobj = NULL;
15121 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15122 wxArrayString *result;
15123 PyObject * obj0 = 0 ;
15124 char *kwnames[] = {
15125 (char *) "self", NULL
15126 };
15127
15128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
15129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15130 if (SWIG_arg_fail(1)) SWIG_fail;
15131 {
15132 PyThreadState* __tstate = wxPyBeginAllowThreads();
15133 {
15134 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
15135 result = (wxArrayString *) &_result_ref;
15136 }
15137
15138 wxPyEndAllowThreads(__tstate);
15139 if (PyErr_Occurred()) SWIG_fail;
15140 }
15141 {
15142 resultobj = wxArrayString2PyList_helper(*result);
15143 }
15144 return resultobj;
15145 fail:
15146 return NULL;
15147 }
15148
15149
15150 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
15151 PyObject *resultobj = NULL;
15152 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15153 int result;
15154 PyObject * obj0 = 0 ;
15155 char *kwnames[] = {
15156 (char *) "self", NULL
15157 };
15158
15159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
15160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15161 if (SWIG_arg_fail(1)) SWIG_fail;
15162 {
15163 PyThreadState* __tstate = wxPyBeginAllowThreads();
15164 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
15165
15166 wxPyEndAllowThreads(__tstate);
15167 if (PyErr_Occurred()) SWIG_fail;
15168 }
15169 {
15170 resultobj = SWIG_From_int(static_cast<int >(result));
15171 }
15172 return resultobj;
15173 fail:
15174 return NULL;
15175 }
15176
15177
15178 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
15179 PyObject *resultobj = NULL;
15180 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15181 wxString *result;
15182 PyObject * obj0 = 0 ;
15183 char *kwnames[] = {
15184 (char *) "self", NULL
15185 };
15186
15187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
15188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15189 if (SWIG_arg_fail(1)) SWIG_fail;
15190 {
15191 PyThreadState* __tstate = wxPyBeginAllowThreads();
15192 {
15193 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
15194 result = (wxString *) &_result_ref;
15195 }
15196
15197 wxPyEndAllowThreads(__tstate);
15198 if (PyErr_Occurred()) SWIG_fail;
15199 }
15200 {
15201 #if wxUSE_UNICODE
15202 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
15203 #else
15204 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
15205 #endif
15206 }
15207 return resultobj;
15208 fail:
15209 return NULL;
15210 }
15211
15212
15213 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
15214 PyObject *resultobj = NULL;
15215 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
15216 int result;
15217 PyObject * obj0 = 0 ;
15218 char *kwnames[] = {
15219 (char *) "self", NULL
15220 };
15221
15222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
15223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15224 if (SWIG_arg_fail(1)) SWIG_fail;
15225 {
15226 PyThreadState* __tstate = wxPyBeginAllowThreads();
15227 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
15228
15229 wxPyEndAllowThreads(__tstate);
15230 if (PyErr_Occurred()) SWIG_fail;
15231 }
15232 {
15233 resultobj = SWIG_From_int(static_cast<int >(result));
15234 }
15235 return resultobj;
15236 fail:
15237 return NULL;
15238 }
15239
15240
15241 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
15242 PyObject *obj;
15243 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15244 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
15245 Py_INCREF(obj);
15246 return Py_BuildValue((char *)"");
15247 }
15248 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
15249 PyObject *resultobj = NULL;
15250 wxFileTypeInfo *arg1 = 0 ;
15251 wxFileType *result;
15252 PyObject * obj0 = 0 ;
15253 char *kwnames[] = {
15254 (char *) "ftInfo", NULL
15255 };
15256
15257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
15258 {
15259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15260 if (SWIG_arg_fail(1)) SWIG_fail;
15261 if (arg1 == NULL) {
15262 SWIG_null_ref("wxFileTypeInfo");
15263 }
15264 if (SWIG_arg_fail(1)) SWIG_fail;
15265 }
15266 {
15267 PyThreadState* __tstate = wxPyBeginAllowThreads();
15268 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
15269
15270 wxPyEndAllowThreads(__tstate);
15271 if (PyErr_Occurred()) SWIG_fail;
15272 }
15273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15274 return resultobj;
15275 fail:
15276 return NULL;
15277 }
15278
15279
15280 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
15281 PyObject *resultobj = NULL;
15282 wxFileType *arg1 = (wxFileType *) 0 ;
15283 PyObject * obj0 = 0 ;
15284 char *kwnames[] = {
15285 (char *) "self", NULL
15286 };
15287
15288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
15289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15290 if (SWIG_arg_fail(1)) SWIG_fail;
15291 {
15292 PyThreadState* __tstate = wxPyBeginAllowThreads();
15293 delete arg1;
15294
15295 wxPyEndAllowThreads(__tstate);
15296 if (PyErr_Occurred()) SWIG_fail;
15297 }
15298 Py_INCREF(Py_None); resultobj = Py_None;
15299 return resultobj;
15300 fail:
15301 return NULL;
15302 }
15303
15304
15305 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15306 PyObject *resultobj = NULL;
15307 wxFileType *arg1 = (wxFileType *) 0 ;
15308 PyObject *result;
15309 PyObject * obj0 = 0 ;
15310 char *kwnames[] = {
15311 (char *) "self", NULL
15312 };
15313
15314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
15315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15316 if (SWIG_arg_fail(1)) SWIG_fail;
15317 {
15318 PyThreadState* __tstate = wxPyBeginAllowThreads();
15319 result = (PyObject *)wxFileType_GetMimeType(arg1);
15320
15321 wxPyEndAllowThreads(__tstate);
15322 if (PyErr_Occurred()) SWIG_fail;
15323 }
15324 resultobj = result;
15325 return resultobj;
15326 fail:
15327 return NULL;
15328 }
15329
15330
15331 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15332 PyObject *resultobj = NULL;
15333 wxFileType *arg1 = (wxFileType *) 0 ;
15334 PyObject *result;
15335 PyObject * obj0 = 0 ;
15336 char *kwnames[] = {
15337 (char *) "self", NULL
15338 };
15339
15340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
15341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15342 if (SWIG_arg_fail(1)) SWIG_fail;
15343 {
15344 PyThreadState* __tstate = wxPyBeginAllowThreads();
15345 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
15346
15347 wxPyEndAllowThreads(__tstate);
15348 if (PyErr_Occurred()) SWIG_fail;
15349 }
15350 resultobj = result;
15351 return resultobj;
15352 fail:
15353 return NULL;
15354 }
15355
15356
15357 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
15358 PyObject *resultobj = NULL;
15359 wxFileType *arg1 = (wxFileType *) 0 ;
15360 PyObject *result;
15361 PyObject * obj0 = 0 ;
15362 char *kwnames[] = {
15363 (char *) "self", NULL
15364 };
15365
15366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
15367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15368 if (SWIG_arg_fail(1)) SWIG_fail;
15369 {
15370 PyThreadState* __tstate = wxPyBeginAllowThreads();
15371 result = (PyObject *)wxFileType_GetExtensions(arg1);
15372
15373 wxPyEndAllowThreads(__tstate);
15374 if (PyErr_Occurred()) SWIG_fail;
15375 }
15376 resultobj = result;
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
15384 PyObject *resultobj = NULL;
15385 wxFileType *arg1 = (wxFileType *) 0 ;
15386 wxIcon *result;
15387 PyObject * obj0 = 0 ;
15388 char *kwnames[] = {
15389 (char *) "self", NULL
15390 };
15391
15392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
15393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15394 if (SWIG_arg_fail(1)) SWIG_fail;
15395 {
15396 PyThreadState* __tstate = wxPyBeginAllowThreads();
15397 result = (wxIcon *)wxFileType_GetIcon(arg1);
15398
15399 wxPyEndAllowThreads(__tstate);
15400 if (PyErr_Occurred()) SWIG_fail;
15401 }
15402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
15403 return resultobj;
15404 fail:
15405 return NULL;
15406 }
15407
15408
15409 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15410 PyObject *resultobj = NULL;
15411 wxFileType *arg1 = (wxFileType *) 0 ;
15412 PyObject *result;
15413 PyObject * obj0 = 0 ;
15414 char *kwnames[] = {
15415 (char *) "self", NULL
15416 };
15417
15418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
15419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15420 if (SWIG_arg_fail(1)) SWIG_fail;
15421 {
15422 PyThreadState* __tstate = wxPyBeginAllowThreads();
15423 result = (PyObject *)wxFileType_GetIconInfo(arg1);
15424
15425 wxPyEndAllowThreads(__tstate);
15426 if (PyErr_Occurred()) SWIG_fail;
15427 }
15428 resultobj = result;
15429 return resultobj;
15430 fail:
15431 return NULL;
15432 }
15433
15434
15435 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
15436 PyObject *resultobj = NULL;
15437 wxFileType *arg1 = (wxFileType *) 0 ;
15438 PyObject *result;
15439 PyObject * obj0 = 0 ;
15440 char *kwnames[] = {
15441 (char *) "self", NULL
15442 };
15443
15444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
15445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15446 if (SWIG_arg_fail(1)) SWIG_fail;
15447 {
15448 PyThreadState* __tstate = wxPyBeginAllowThreads();
15449 result = (PyObject *)wxFileType_GetDescription(arg1);
15450
15451 wxPyEndAllowThreads(__tstate);
15452 if (PyErr_Occurred()) SWIG_fail;
15453 }
15454 resultobj = result;
15455 return resultobj;
15456 fail:
15457 return NULL;
15458 }
15459
15460
15461 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15462 PyObject *resultobj = NULL;
15463 wxFileType *arg1 = (wxFileType *) 0 ;
15464 wxString *arg2 = 0 ;
15465 wxString const &arg3_defvalue = wxPyEmptyString ;
15466 wxString *arg3 = (wxString *) &arg3_defvalue ;
15467 PyObject *result;
15468 bool temp2 = false ;
15469 bool temp3 = false ;
15470 PyObject * obj0 = 0 ;
15471 PyObject * obj1 = 0 ;
15472 PyObject * obj2 = 0 ;
15473 char *kwnames[] = {
15474 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
15475 };
15476
15477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
15478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15479 if (SWIG_arg_fail(1)) SWIG_fail;
15480 {
15481 arg2 = wxString_in_helper(obj1);
15482 if (arg2 == NULL) SWIG_fail;
15483 temp2 = true;
15484 }
15485 if (obj2) {
15486 {
15487 arg3 = wxString_in_helper(obj2);
15488 if (arg3 == NULL) SWIG_fail;
15489 temp3 = true;
15490 }
15491 }
15492 {
15493 PyThreadState* __tstate = wxPyBeginAllowThreads();
15494 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15495
15496 wxPyEndAllowThreads(__tstate);
15497 if (PyErr_Occurred()) SWIG_fail;
15498 }
15499 resultobj = result;
15500 {
15501 if (temp2)
15502 delete arg2;
15503 }
15504 {
15505 if (temp3)
15506 delete arg3;
15507 }
15508 return resultobj;
15509 fail:
15510 {
15511 if (temp2)
15512 delete arg2;
15513 }
15514 {
15515 if (temp3)
15516 delete arg3;
15517 }
15518 return NULL;
15519 }
15520
15521
15522 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15523 PyObject *resultobj = NULL;
15524 wxFileType *arg1 = (wxFileType *) 0 ;
15525 wxString *arg2 = 0 ;
15526 wxString const &arg3_defvalue = wxPyEmptyString ;
15527 wxString *arg3 = (wxString *) &arg3_defvalue ;
15528 PyObject *result;
15529 bool temp2 = false ;
15530 bool temp3 = false ;
15531 PyObject * obj0 = 0 ;
15532 PyObject * obj1 = 0 ;
15533 PyObject * obj2 = 0 ;
15534 char *kwnames[] = {
15535 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
15536 };
15537
15538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
15539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15540 if (SWIG_arg_fail(1)) SWIG_fail;
15541 {
15542 arg2 = wxString_in_helper(obj1);
15543 if (arg2 == NULL) SWIG_fail;
15544 temp2 = true;
15545 }
15546 if (obj2) {
15547 {
15548 arg3 = wxString_in_helper(obj2);
15549 if (arg3 == NULL) SWIG_fail;
15550 temp3 = true;
15551 }
15552 }
15553 {
15554 PyThreadState* __tstate = wxPyBeginAllowThreads();
15555 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15556
15557 wxPyEndAllowThreads(__tstate);
15558 if (PyErr_Occurred()) SWIG_fail;
15559 }
15560 resultobj = result;
15561 {
15562 if (temp2)
15563 delete arg2;
15564 }
15565 {
15566 if (temp3)
15567 delete arg3;
15568 }
15569 return resultobj;
15570 fail:
15571 {
15572 if (temp2)
15573 delete arg2;
15574 }
15575 {
15576 if (temp3)
15577 delete arg3;
15578 }
15579 return NULL;
15580 }
15581
15582
15583 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
15584 PyObject *resultobj = NULL;
15585 wxFileType *arg1 = (wxFileType *) 0 ;
15586 wxString *arg2 = 0 ;
15587 wxString const &arg3_defvalue = wxPyEmptyString ;
15588 wxString *arg3 = (wxString *) &arg3_defvalue ;
15589 PyObject *result;
15590 bool temp2 = false ;
15591 bool temp3 = false ;
15592 PyObject * obj0 = 0 ;
15593 PyObject * obj1 = 0 ;
15594 PyObject * obj2 = 0 ;
15595 char *kwnames[] = {
15596 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
15597 };
15598
15599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
15600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15601 if (SWIG_arg_fail(1)) SWIG_fail;
15602 {
15603 arg2 = wxString_in_helper(obj1);
15604 if (arg2 == NULL) SWIG_fail;
15605 temp2 = true;
15606 }
15607 if (obj2) {
15608 {
15609 arg3 = wxString_in_helper(obj2);
15610 if (arg3 == NULL) SWIG_fail;
15611 temp3 = true;
15612 }
15613 }
15614 {
15615 PyThreadState* __tstate = wxPyBeginAllowThreads();
15616 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15617
15618 wxPyEndAllowThreads(__tstate);
15619 if (PyErr_Occurred()) SWIG_fail;
15620 }
15621 resultobj = result;
15622 {
15623 if (temp2)
15624 delete arg2;
15625 }
15626 {
15627 if (temp3)
15628 delete arg3;
15629 }
15630 return resultobj;
15631 fail:
15632 {
15633 if (temp2)
15634 delete arg2;
15635 }
15636 {
15637 if (temp3)
15638 delete arg3;
15639 }
15640 return NULL;
15641 }
15642
15643
15644 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15645 PyObject *resultobj = NULL;
15646 wxFileType *arg1 = (wxFileType *) 0 ;
15647 wxString *arg2 = 0 ;
15648 wxString *arg3 = 0 ;
15649 bool arg4 = (bool) true ;
15650 bool result;
15651 bool temp2 = false ;
15652 bool temp3 = false ;
15653 PyObject * obj0 = 0 ;
15654 PyObject * obj1 = 0 ;
15655 PyObject * obj2 = 0 ;
15656 PyObject * obj3 = 0 ;
15657 char *kwnames[] = {
15658 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
15659 };
15660
15661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15663 if (SWIG_arg_fail(1)) SWIG_fail;
15664 {
15665 arg2 = wxString_in_helper(obj1);
15666 if (arg2 == NULL) SWIG_fail;
15667 temp2 = true;
15668 }
15669 {
15670 arg3 = wxString_in_helper(obj2);
15671 if (arg3 == NULL) SWIG_fail;
15672 temp3 = true;
15673 }
15674 if (obj3) {
15675 {
15676 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
15677 if (SWIG_arg_fail(4)) SWIG_fail;
15678 }
15679 }
15680 {
15681 PyThreadState* __tstate = wxPyBeginAllowThreads();
15682 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
15683
15684 wxPyEndAllowThreads(__tstate);
15685 if (PyErr_Occurred()) SWIG_fail;
15686 }
15687 {
15688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15689 }
15690 {
15691 if (temp2)
15692 delete arg2;
15693 }
15694 {
15695 if (temp3)
15696 delete arg3;
15697 }
15698 return resultobj;
15699 fail:
15700 {
15701 if (temp2)
15702 delete arg2;
15703 }
15704 {
15705 if (temp3)
15706 delete arg3;
15707 }
15708 return NULL;
15709 }
15710
15711
15712 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
15713 PyObject *resultobj = NULL;
15714 wxFileType *arg1 = (wxFileType *) 0 ;
15715 wxString const &arg2_defvalue = wxPyEmptyString ;
15716 wxString *arg2 = (wxString *) &arg2_defvalue ;
15717 int arg3 = (int) 0 ;
15718 bool result;
15719 bool temp2 = false ;
15720 PyObject * obj0 = 0 ;
15721 PyObject * obj1 = 0 ;
15722 PyObject * obj2 = 0 ;
15723 char *kwnames[] = {
15724 (char *) "self",(char *) "cmd",(char *) "index", NULL
15725 };
15726
15727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
15728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15729 if (SWIG_arg_fail(1)) SWIG_fail;
15730 if (obj1) {
15731 {
15732 arg2 = wxString_in_helper(obj1);
15733 if (arg2 == NULL) SWIG_fail;
15734 temp2 = true;
15735 }
15736 }
15737 if (obj2) {
15738 {
15739 arg3 = static_cast<int >(SWIG_As_int(obj2));
15740 if (SWIG_arg_fail(3)) SWIG_fail;
15741 }
15742 }
15743 {
15744 PyThreadState* __tstate = wxPyBeginAllowThreads();
15745 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
15746
15747 wxPyEndAllowThreads(__tstate);
15748 if (PyErr_Occurred()) SWIG_fail;
15749 }
15750 {
15751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15752 }
15753 {
15754 if (temp2)
15755 delete arg2;
15756 }
15757 return resultobj;
15758 fail:
15759 {
15760 if (temp2)
15761 delete arg2;
15762 }
15763 return NULL;
15764 }
15765
15766
15767 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15768 PyObject *resultobj = NULL;
15769 wxFileType *arg1 = (wxFileType *) 0 ;
15770 bool result;
15771 PyObject * obj0 = 0 ;
15772 char *kwnames[] = {
15773 (char *) "self", NULL
15774 };
15775
15776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
15777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15778 if (SWIG_arg_fail(1)) SWIG_fail;
15779 {
15780 PyThreadState* __tstate = wxPyBeginAllowThreads();
15781 result = (bool)(arg1)->Unassociate();
15782
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 {
15787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15788 }
15789 return resultobj;
15790 fail:
15791 return NULL;
15792 }
15793
15794
15795 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
15796 PyObject *resultobj = NULL;
15797 wxString *arg1 = 0 ;
15798 wxString *arg2 = 0 ;
15799 wxString const &arg3_defvalue = wxPyEmptyString ;
15800 wxString *arg3 = (wxString *) &arg3_defvalue ;
15801 wxString result;
15802 bool temp1 = false ;
15803 bool temp2 = false ;
15804 bool temp3 = false ;
15805 PyObject * obj0 = 0 ;
15806 PyObject * obj1 = 0 ;
15807 PyObject * obj2 = 0 ;
15808 char *kwnames[] = {
15809 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
15810 };
15811
15812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
15813 {
15814 arg1 = wxString_in_helper(obj0);
15815 if (arg1 == NULL) SWIG_fail;
15816 temp1 = true;
15817 }
15818 {
15819 arg2 = wxString_in_helper(obj1);
15820 if (arg2 == NULL) SWIG_fail;
15821 temp2 = true;
15822 }
15823 if (obj2) {
15824 {
15825 arg3 = wxString_in_helper(obj2);
15826 if (arg3 == NULL) SWIG_fail;
15827 temp3 = true;
15828 }
15829 }
15830 {
15831 PyThreadState* __tstate = wxPyBeginAllowThreads();
15832 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
15833
15834 wxPyEndAllowThreads(__tstate);
15835 if (PyErr_Occurred()) SWIG_fail;
15836 }
15837 {
15838 #if wxUSE_UNICODE
15839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15840 #else
15841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15842 #endif
15843 }
15844 {
15845 if (temp1)
15846 delete arg1;
15847 }
15848 {
15849 if (temp2)
15850 delete arg2;
15851 }
15852 {
15853 if (temp3)
15854 delete arg3;
15855 }
15856 return resultobj;
15857 fail:
15858 {
15859 if (temp1)
15860 delete arg1;
15861 }
15862 {
15863 if (temp2)
15864 delete arg2;
15865 }
15866 {
15867 if (temp3)
15868 delete arg3;
15869 }
15870 return NULL;
15871 }
15872
15873
15874 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
15875 PyObject *obj;
15876 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15877 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
15878 Py_INCREF(obj);
15879 return Py_BuildValue((char *)"");
15880 }
15881 static int _wrap_TheMimeTypesManager_set(PyObject *) {
15882 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
15883 return 1;
15884 }
15885
15886
15887 static PyObject *_wrap_TheMimeTypesManager_get(void) {
15888 PyObject *pyobj = NULL;
15889
15890 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
15891 return pyobj;
15892 }
15893
15894
15895 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
15896 PyObject *resultobj = NULL;
15897 wxString *arg1 = 0 ;
15898 wxString *arg2 = 0 ;
15899 bool result;
15900 bool temp1 = false ;
15901 bool temp2 = false ;
15902 PyObject * obj0 = 0 ;
15903 PyObject * obj1 = 0 ;
15904 char *kwnames[] = {
15905 (char *) "mimeType",(char *) "wildcard", NULL
15906 };
15907
15908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
15909 {
15910 arg1 = wxString_in_helper(obj0);
15911 if (arg1 == NULL) SWIG_fail;
15912 temp1 = true;
15913 }
15914 {
15915 arg2 = wxString_in_helper(obj1);
15916 if (arg2 == NULL) SWIG_fail;
15917 temp2 = true;
15918 }
15919 {
15920 PyThreadState* __tstate = wxPyBeginAllowThreads();
15921 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
15922
15923 wxPyEndAllowThreads(__tstate);
15924 if (PyErr_Occurred()) SWIG_fail;
15925 }
15926 {
15927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15928 }
15929 {
15930 if (temp1)
15931 delete arg1;
15932 }
15933 {
15934 if (temp2)
15935 delete arg2;
15936 }
15937 return resultobj;
15938 fail:
15939 {
15940 if (temp1)
15941 delete arg1;
15942 }
15943 {
15944 if (temp2)
15945 delete arg2;
15946 }
15947 return NULL;
15948 }
15949
15950
15951 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15952 PyObject *resultobj = NULL;
15953 wxMimeTypesManager *result;
15954 char *kwnames[] = {
15955 NULL
15956 };
15957
15958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15959 {
15960 PyThreadState* __tstate = wxPyBeginAllowThreads();
15961 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15962
15963 wxPyEndAllowThreads(__tstate);
15964 if (PyErr_Occurred()) SWIG_fail;
15965 }
15966 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15967 return resultobj;
15968 fail:
15969 return NULL;
15970 }
15971
15972
15973 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15974 PyObject *resultobj = NULL;
15975 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15976 int arg2 = (int) wxMAILCAP_ALL ;
15977 wxString const &arg3_defvalue = wxPyEmptyString ;
15978 wxString *arg3 = (wxString *) &arg3_defvalue ;
15979 bool temp3 = false ;
15980 PyObject * obj0 = 0 ;
15981 PyObject * obj1 = 0 ;
15982 PyObject * obj2 = 0 ;
15983 char *kwnames[] = {
15984 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15985 };
15986
15987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15989 if (SWIG_arg_fail(1)) SWIG_fail;
15990 if (obj1) {
15991 {
15992 arg2 = static_cast<int >(SWIG_As_int(obj1));
15993 if (SWIG_arg_fail(2)) SWIG_fail;
15994 }
15995 }
15996 if (obj2) {
15997 {
15998 arg3 = wxString_in_helper(obj2);
15999 if (arg3 == NULL) SWIG_fail;
16000 temp3 = true;
16001 }
16002 }
16003 {
16004 PyThreadState* __tstate = wxPyBeginAllowThreads();
16005 (arg1)->Initialize(arg2,(wxString const &)*arg3);
16006
16007 wxPyEndAllowThreads(__tstate);
16008 if (PyErr_Occurred()) SWIG_fail;
16009 }
16010 Py_INCREF(Py_None); resultobj = Py_None;
16011 {
16012 if (temp3)
16013 delete arg3;
16014 }
16015 return resultobj;
16016 fail:
16017 {
16018 if (temp3)
16019 delete arg3;
16020 }
16021 return NULL;
16022 }
16023
16024
16025 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
16026 PyObject *resultobj = NULL;
16027 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16028 PyObject * obj0 = 0 ;
16029 char *kwnames[] = {
16030 (char *) "self", NULL
16031 };
16032
16033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
16034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16035 if (SWIG_arg_fail(1)) SWIG_fail;
16036 {
16037 PyThreadState* __tstate = wxPyBeginAllowThreads();
16038 (arg1)->ClearData();
16039
16040 wxPyEndAllowThreads(__tstate);
16041 if (PyErr_Occurred()) SWIG_fail;
16042 }
16043 Py_INCREF(Py_None); resultobj = Py_None;
16044 return resultobj;
16045 fail:
16046 return NULL;
16047 }
16048
16049
16050 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
16051 PyObject *resultobj = NULL;
16052 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16053 wxString *arg2 = 0 ;
16054 wxFileType *result;
16055 bool temp2 = false ;
16056 PyObject * obj0 = 0 ;
16057 PyObject * obj1 = 0 ;
16058 char *kwnames[] = {
16059 (char *) "self",(char *) "ext", NULL
16060 };
16061
16062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
16063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16064 if (SWIG_arg_fail(1)) SWIG_fail;
16065 {
16066 arg2 = wxString_in_helper(obj1);
16067 if (arg2 == NULL) SWIG_fail;
16068 temp2 = true;
16069 }
16070 {
16071 PyThreadState* __tstate = wxPyBeginAllowThreads();
16072 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
16073
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
16078 {
16079 if (temp2)
16080 delete arg2;
16081 }
16082 return resultobj;
16083 fail:
16084 {
16085 if (temp2)
16086 delete arg2;
16087 }
16088 return NULL;
16089 }
16090
16091
16092 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
16093 PyObject *resultobj = NULL;
16094 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16095 wxString *arg2 = 0 ;
16096 wxFileType *result;
16097 bool temp2 = false ;
16098 PyObject * obj0 = 0 ;
16099 PyObject * obj1 = 0 ;
16100 char *kwnames[] = {
16101 (char *) "self",(char *) "mimeType", NULL
16102 };
16103
16104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
16105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16106 if (SWIG_arg_fail(1)) SWIG_fail;
16107 {
16108 arg2 = wxString_in_helper(obj1);
16109 if (arg2 == NULL) SWIG_fail;
16110 temp2 = true;
16111 }
16112 {
16113 PyThreadState* __tstate = wxPyBeginAllowThreads();
16114 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
16115
16116 wxPyEndAllowThreads(__tstate);
16117 if (PyErr_Occurred()) SWIG_fail;
16118 }
16119 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
16120 {
16121 if (temp2)
16122 delete arg2;
16123 }
16124 return resultobj;
16125 fail:
16126 {
16127 if (temp2)
16128 delete arg2;
16129 }
16130 return NULL;
16131 }
16132
16133
16134 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
16135 PyObject *resultobj = NULL;
16136 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16137 wxString *arg2 = 0 ;
16138 bool arg3 = (bool) false ;
16139 bool result;
16140 bool temp2 = false ;
16141 PyObject * obj0 = 0 ;
16142 PyObject * obj1 = 0 ;
16143 PyObject * obj2 = 0 ;
16144 char *kwnames[] = {
16145 (char *) "self",(char *) "filename",(char *) "fallback", NULL
16146 };
16147
16148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16150 if (SWIG_arg_fail(1)) SWIG_fail;
16151 {
16152 arg2 = wxString_in_helper(obj1);
16153 if (arg2 == NULL) SWIG_fail;
16154 temp2 = true;
16155 }
16156 if (obj2) {
16157 {
16158 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
16159 if (SWIG_arg_fail(3)) SWIG_fail;
16160 }
16161 }
16162 {
16163 PyThreadState* __tstate = wxPyBeginAllowThreads();
16164 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
16165
16166 wxPyEndAllowThreads(__tstate);
16167 if (PyErr_Occurred()) SWIG_fail;
16168 }
16169 {
16170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16171 }
16172 {
16173 if (temp2)
16174 delete arg2;
16175 }
16176 return resultobj;
16177 fail:
16178 {
16179 if (temp2)
16180 delete arg2;
16181 }
16182 return NULL;
16183 }
16184
16185
16186 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
16187 PyObject *resultobj = NULL;
16188 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16189 wxString *arg2 = 0 ;
16190 bool result;
16191 bool temp2 = false ;
16192 PyObject * obj0 = 0 ;
16193 PyObject * obj1 = 0 ;
16194 char *kwnames[] = {
16195 (char *) "self",(char *) "filename", NULL
16196 };
16197
16198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
16199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16200 if (SWIG_arg_fail(1)) SWIG_fail;
16201 {
16202 arg2 = wxString_in_helper(obj1);
16203 if (arg2 == NULL) SWIG_fail;
16204 temp2 = true;
16205 }
16206 {
16207 PyThreadState* __tstate = wxPyBeginAllowThreads();
16208 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
16209
16210 wxPyEndAllowThreads(__tstate);
16211 if (PyErr_Occurred()) SWIG_fail;
16212 }
16213 {
16214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16215 }
16216 {
16217 if (temp2)
16218 delete arg2;
16219 }
16220 return resultobj;
16221 fail:
16222 {
16223 if (temp2)
16224 delete arg2;
16225 }
16226 return NULL;
16227 }
16228
16229
16230 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
16231 PyObject *resultobj = NULL;
16232 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16233 PyObject *result;
16234 PyObject * obj0 = 0 ;
16235 char *kwnames[] = {
16236 (char *) "self", NULL
16237 };
16238
16239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
16240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16241 if (SWIG_arg_fail(1)) SWIG_fail;
16242 {
16243 PyThreadState* __tstate = wxPyBeginAllowThreads();
16244 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
16245
16246 wxPyEndAllowThreads(__tstate);
16247 if (PyErr_Occurred()) SWIG_fail;
16248 }
16249 resultobj = result;
16250 return resultobj;
16251 fail:
16252 return NULL;
16253 }
16254
16255
16256 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
16257 PyObject *resultobj = NULL;
16258 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16259 wxFileTypeInfo *arg2 = 0 ;
16260 PyObject * obj0 = 0 ;
16261 PyObject * obj1 = 0 ;
16262 char *kwnames[] = {
16263 (char *) "self",(char *) "ft", NULL
16264 };
16265
16266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
16267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16268 if (SWIG_arg_fail(1)) SWIG_fail;
16269 {
16270 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
16271 if (SWIG_arg_fail(2)) SWIG_fail;
16272 if (arg2 == NULL) {
16273 SWIG_null_ref("wxFileTypeInfo");
16274 }
16275 if (SWIG_arg_fail(2)) SWIG_fail;
16276 }
16277 {
16278 PyThreadState* __tstate = wxPyBeginAllowThreads();
16279 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
16280
16281 wxPyEndAllowThreads(__tstate);
16282 if (PyErr_Occurred()) SWIG_fail;
16283 }
16284 Py_INCREF(Py_None); resultobj = Py_None;
16285 return resultobj;
16286 fail:
16287 return NULL;
16288 }
16289
16290
16291 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
16292 PyObject *resultobj = NULL;
16293 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16294 wxFileTypeInfo *arg2 = 0 ;
16295 wxFileType *result;
16296 PyObject * obj0 = 0 ;
16297 PyObject * obj1 = 0 ;
16298 char *kwnames[] = {
16299 (char *) "self",(char *) "ftInfo", NULL
16300 };
16301
16302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
16303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16304 if (SWIG_arg_fail(1)) SWIG_fail;
16305 {
16306 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
16307 if (SWIG_arg_fail(2)) SWIG_fail;
16308 if (arg2 == NULL) {
16309 SWIG_null_ref("wxFileTypeInfo");
16310 }
16311 if (SWIG_arg_fail(2)) SWIG_fail;
16312 }
16313 {
16314 PyThreadState* __tstate = wxPyBeginAllowThreads();
16315 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
16316
16317 wxPyEndAllowThreads(__tstate);
16318 if (PyErr_Occurred()) SWIG_fail;
16319 }
16320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
16321 return resultobj;
16322 fail:
16323 return NULL;
16324 }
16325
16326
16327 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
16328 PyObject *resultobj = NULL;
16329 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16330 wxFileType *arg2 = (wxFileType *) 0 ;
16331 bool result;
16332 PyObject * obj0 = 0 ;
16333 PyObject * obj1 = 0 ;
16334 char *kwnames[] = {
16335 (char *) "self",(char *) "ft", NULL
16336 };
16337
16338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
16339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16340 if (SWIG_arg_fail(1)) SWIG_fail;
16341 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
16342 if (SWIG_arg_fail(2)) SWIG_fail;
16343 {
16344 PyThreadState* __tstate = wxPyBeginAllowThreads();
16345 result = (bool)(arg1)->Unassociate(arg2);
16346
16347 wxPyEndAllowThreads(__tstate);
16348 if (PyErr_Occurred()) SWIG_fail;
16349 }
16350 {
16351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16352 }
16353 return resultobj;
16354 fail:
16355 return NULL;
16356 }
16357
16358
16359 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
16360 PyObject *resultobj = NULL;
16361 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
16362 PyObject * obj0 = 0 ;
16363 char *kwnames[] = {
16364 (char *) "self", NULL
16365 };
16366
16367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
16368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
16369 if (SWIG_arg_fail(1)) SWIG_fail;
16370 {
16371 PyThreadState* __tstate = wxPyBeginAllowThreads();
16372 delete arg1;
16373
16374 wxPyEndAllowThreads(__tstate);
16375 if (PyErr_Occurred()) SWIG_fail;
16376 }
16377 Py_INCREF(Py_None); resultobj = Py_None;
16378 return resultobj;
16379 fail:
16380 return NULL;
16381 }
16382
16383
16384 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
16385 PyObject *obj;
16386 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16387 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
16388 Py_INCREF(obj);
16389 return Py_BuildValue((char *)"");
16390 }
16391 static int _wrap_ART_TOOLBAR_set(PyObject *) {
16392 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
16393 return 1;
16394 }
16395
16396
16397 static PyObject *_wrap_ART_TOOLBAR_get(void) {
16398 PyObject *pyobj = NULL;
16399
16400 {
16401 #if wxUSE_UNICODE
16402 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
16403 #else
16404 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
16405 #endif
16406 }
16407 return pyobj;
16408 }
16409
16410
16411 static int _wrap_ART_MENU_set(PyObject *) {
16412 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
16413 return 1;
16414 }
16415
16416
16417 static PyObject *_wrap_ART_MENU_get(void) {
16418 PyObject *pyobj = NULL;
16419
16420 {
16421 #if wxUSE_UNICODE
16422 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
16423 #else
16424 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
16425 #endif
16426 }
16427 return pyobj;
16428 }
16429
16430
16431 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
16432 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
16433 return 1;
16434 }
16435
16436
16437 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
16438 PyObject *pyobj = NULL;
16439
16440 {
16441 #if wxUSE_UNICODE
16442 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
16443 #else
16444 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
16445 #endif
16446 }
16447 return pyobj;
16448 }
16449
16450
16451 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
16452 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
16453 return 1;
16454 }
16455
16456
16457 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
16458 PyObject *pyobj = NULL;
16459
16460 {
16461 #if wxUSE_UNICODE
16462 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
16463 #else
16464 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
16465 #endif
16466 }
16467 return pyobj;
16468 }
16469
16470
16471 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
16472 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
16473 return 1;
16474 }
16475
16476
16477 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
16478 PyObject *pyobj = NULL;
16479
16480 {
16481 #if wxUSE_UNICODE
16482 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
16483 #else
16484 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
16485 #endif
16486 }
16487 return pyobj;
16488 }
16489
16490
16491 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
16492 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
16493 return 1;
16494 }
16495
16496
16497 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
16498 PyObject *pyobj = NULL;
16499
16500 {
16501 #if wxUSE_UNICODE
16502 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
16503 #else
16504 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
16505 #endif
16506 }
16507 return pyobj;
16508 }
16509
16510
16511 static int _wrap_ART_BUTTON_set(PyObject *) {
16512 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
16513 return 1;
16514 }
16515
16516
16517 static PyObject *_wrap_ART_BUTTON_get(void) {
16518 PyObject *pyobj = NULL;
16519
16520 {
16521 #if wxUSE_UNICODE
16522 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
16523 #else
16524 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
16525 #endif
16526 }
16527 return pyobj;
16528 }
16529
16530
16531 static int _wrap_ART_OTHER_set(PyObject *) {
16532 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
16533 return 1;
16534 }
16535
16536
16537 static PyObject *_wrap_ART_OTHER_get(void) {
16538 PyObject *pyobj = NULL;
16539
16540 {
16541 #if wxUSE_UNICODE
16542 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
16543 #else
16544 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
16545 #endif
16546 }
16547 return pyobj;
16548 }
16549
16550
16551 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
16552 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
16553 return 1;
16554 }
16555
16556
16557 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
16558 PyObject *pyobj = NULL;
16559
16560 {
16561 #if wxUSE_UNICODE
16562 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
16563 #else
16564 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
16565 #endif
16566 }
16567 return pyobj;
16568 }
16569
16570
16571 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
16572 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
16573 return 1;
16574 }
16575
16576
16577 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
16578 PyObject *pyobj = NULL;
16579
16580 {
16581 #if wxUSE_UNICODE
16582 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
16583 #else
16584 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
16585 #endif
16586 }
16587 return pyobj;
16588 }
16589
16590
16591 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
16592 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
16593 return 1;
16594 }
16595
16596
16597 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
16598 PyObject *pyobj = NULL;
16599
16600 {
16601 #if wxUSE_UNICODE
16602 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
16603 #else
16604 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
16605 #endif
16606 }
16607 return pyobj;
16608 }
16609
16610
16611 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
16612 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
16613 return 1;
16614 }
16615
16616
16617 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
16618 PyObject *pyobj = NULL;
16619
16620 {
16621 #if wxUSE_UNICODE
16622 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
16623 #else
16624 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
16625 #endif
16626 }
16627 return pyobj;
16628 }
16629
16630
16631 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
16632 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
16633 return 1;
16634 }
16635
16636
16637 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
16638 PyObject *pyobj = NULL;
16639
16640 {
16641 #if wxUSE_UNICODE
16642 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
16643 #else
16644 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
16645 #endif
16646 }
16647 return pyobj;
16648 }
16649
16650
16651 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
16652 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
16653 return 1;
16654 }
16655
16656
16657 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
16658 PyObject *pyobj = NULL;
16659
16660 {
16661 #if wxUSE_UNICODE
16662 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
16663 #else
16664 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
16665 #endif
16666 }
16667 return pyobj;
16668 }
16669
16670
16671 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
16672 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
16673 return 1;
16674 }
16675
16676
16677 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
16678 PyObject *pyobj = NULL;
16679
16680 {
16681 #if wxUSE_UNICODE
16682 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
16683 #else
16684 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
16685 #endif
16686 }
16687 return pyobj;
16688 }
16689
16690
16691 static int _wrap_ART_GO_BACK_set(PyObject *) {
16692 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
16693 return 1;
16694 }
16695
16696
16697 static PyObject *_wrap_ART_GO_BACK_get(void) {
16698 PyObject *pyobj = NULL;
16699
16700 {
16701 #if wxUSE_UNICODE
16702 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
16703 #else
16704 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
16705 #endif
16706 }
16707 return pyobj;
16708 }
16709
16710
16711 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
16712 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
16713 return 1;
16714 }
16715
16716
16717 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
16718 PyObject *pyobj = NULL;
16719
16720 {
16721 #if wxUSE_UNICODE
16722 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
16723 #else
16724 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
16725 #endif
16726 }
16727 return pyobj;
16728 }
16729
16730
16731 static int _wrap_ART_GO_UP_set(PyObject *) {
16732 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
16733 return 1;
16734 }
16735
16736
16737 static PyObject *_wrap_ART_GO_UP_get(void) {
16738 PyObject *pyobj = NULL;
16739
16740 {
16741 #if wxUSE_UNICODE
16742 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
16743 #else
16744 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
16745 #endif
16746 }
16747 return pyobj;
16748 }
16749
16750
16751 static int _wrap_ART_GO_DOWN_set(PyObject *) {
16752 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
16753 return 1;
16754 }
16755
16756
16757 static PyObject *_wrap_ART_GO_DOWN_get(void) {
16758 PyObject *pyobj = NULL;
16759
16760 {
16761 #if wxUSE_UNICODE
16762 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
16763 #else
16764 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
16765 #endif
16766 }
16767 return pyobj;
16768 }
16769
16770
16771 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
16772 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
16773 return 1;
16774 }
16775
16776
16777 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
16778 PyObject *pyobj = NULL;
16779
16780 {
16781 #if wxUSE_UNICODE
16782 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
16783 #else
16784 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
16785 #endif
16786 }
16787 return pyobj;
16788 }
16789
16790
16791 static int _wrap_ART_GO_HOME_set(PyObject *) {
16792 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
16793 return 1;
16794 }
16795
16796
16797 static PyObject *_wrap_ART_GO_HOME_get(void) {
16798 PyObject *pyobj = NULL;
16799
16800 {
16801 #if wxUSE_UNICODE
16802 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
16803 #else
16804 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
16805 #endif
16806 }
16807 return pyobj;
16808 }
16809
16810
16811 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
16812 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
16813 return 1;
16814 }
16815
16816
16817 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
16818 PyObject *pyobj = NULL;
16819
16820 {
16821 #if wxUSE_UNICODE
16822 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
16823 #else
16824 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
16825 #endif
16826 }
16827 return pyobj;
16828 }
16829
16830
16831 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
16832 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
16833 return 1;
16834 }
16835
16836
16837 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
16838 PyObject *pyobj = NULL;
16839
16840 {
16841 #if wxUSE_UNICODE
16842 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
16843 #else
16844 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
16845 #endif
16846 }
16847 return pyobj;
16848 }
16849
16850
16851 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
16852 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
16853 return 1;
16854 }
16855
16856
16857 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
16858 PyObject *pyobj = NULL;
16859
16860 {
16861 #if wxUSE_UNICODE
16862 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
16863 #else
16864 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
16865 #endif
16866 }
16867 return pyobj;
16868 }
16869
16870
16871 static int _wrap_ART_PRINT_set(PyObject *) {
16872 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
16873 return 1;
16874 }
16875
16876
16877 static PyObject *_wrap_ART_PRINT_get(void) {
16878 PyObject *pyobj = NULL;
16879
16880 {
16881 #if wxUSE_UNICODE
16882 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16883 #else
16884 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
16885 #endif
16886 }
16887 return pyobj;
16888 }
16889
16890
16891 static int _wrap_ART_HELP_set(PyObject *) {
16892 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
16893 return 1;
16894 }
16895
16896
16897 static PyObject *_wrap_ART_HELP_get(void) {
16898 PyObject *pyobj = NULL;
16899
16900 {
16901 #if wxUSE_UNICODE
16902 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16903 #else
16904 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
16905 #endif
16906 }
16907 return pyobj;
16908 }
16909
16910
16911 static int _wrap_ART_TIP_set(PyObject *) {
16912 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
16913 return 1;
16914 }
16915
16916
16917 static PyObject *_wrap_ART_TIP_get(void) {
16918 PyObject *pyobj = NULL;
16919
16920 {
16921 #if wxUSE_UNICODE
16922 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16923 #else
16924 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
16925 #endif
16926 }
16927 return pyobj;
16928 }
16929
16930
16931 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
16932 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
16933 return 1;
16934 }
16935
16936
16937 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16938 PyObject *pyobj = NULL;
16939
16940 {
16941 #if wxUSE_UNICODE
16942 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16943 #else
16944 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16945 #endif
16946 }
16947 return pyobj;
16948 }
16949
16950
16951 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16952 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16953 return 1;
16954 }
16955
16956
16957 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16958 PyObject *pyobj = NULL;
16959
16960 {
16961 #if wxUSE_UNICODE
16962 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16963 #else
16964 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16965 #endif
16966 }
16967 return pyobj;
16968 }
16969
16970
16971 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16972 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16973 return 1;
16974 }
16975
16976
16977 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16978 PyObject *pyobj = NULL;
16979
16980 {
16981 #if wxUSE_UNICODE
16982 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16983 #else
16984 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16985 #endif
16986 }
16987 return pyobj;
16988 }
16989
16990
16991 static int _wrap_ART_HARDDISK_set(PyObject *) {
16992 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16993 return 1;
16994 }
16995
16996
16997 static PyObject *_wrap_ART_HARDDISK_get(void) {
16998 PyObject *pyobj = NULL;
16999
17000 {
17001 #if wxUSE_UNICODE
17002 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
17003 #else
17004 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
17005 #endif
17006 }
17007 return pyobj;
17008 }
17009
17010
17011 static int _wrap_ART_FLOPPY_set(PyObject *) {
17012 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
17013 return 1;
17014 }
17015
17016
17017 static PyObject *_wrap_ART_FLOPPY_get(void) {
17018 PyObject *pyobj = NULL;
17019
17020 {
17021 #if wxUSE_UNICODE
17022 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
17023 #else
17024 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
17025 #endif
17026 }
17027 return pyobj;
17028 }
17029
17030
17031 static int _wrap_ART_CDROM_set(PyObject *) {
17032 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
17033 return 1;
17034 }
17035
17036
17037 static PyObject *_wrap_ART_CDROM_get(void) {
17038 PyObject *pyobj = NULL;
17039
17040 {
17041 #if wxUSE_UNICODE
17042 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
17043 #else
17044 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
17045 #endif
17046 }
17047 return pyobj;
17048 }
17049
17050
17051 static int _wrap_ART_REMOVABLE_set(PyObject *) {
17052 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
17053 return 1;
17054 }
17055
17056
17057 static PyObject *_wrap_ART_REMOVABLE_get(void) {
17058 PyObject *pyobj = NULL;
17059
17060 {
17061 #if wxUSE_UNICODE
17062 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
17063 #else
17064 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
17065 #endif
17066 }
17067 return pyobj;
17068 }
17069
17070
17071 static int _wrap_ART_FOLDER_set(PyObject *) {
17072 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
17073 return 1;
17074 }
17075
17076
17077 static PyObject *_wrap_ART_FOLDER_get(void) {
17078 PyObject *pyobj = NULL;
17079
17080 {
17081 #if wxUSE_UNICODE
17082 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
17083 #else
17084 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
17085 #endif
17086 }
17087 return pyobj;
17088 }
17089
17090
17091 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
17092 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
17093 return 1;
17094 }
17095
17096
17097 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
17098 PyObject *pyobj = NULL;
17099
17100 {
17101 #if wxUSE_UNICODE
17102 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
17103 #else
17104 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
17105 #endif
17106 }
17107 return pyobj;
17108 }
17109
17110
17111 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
17112 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
17113 return 1;
17114 }
17115
17116
17117 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
17118 PyObject *pyobj = NULL;
17119
17120 {
17121 #if wxUSE_UNICODE
17122 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
17123 #else
17124 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
17125 #endif
17126 }
17127 return pyobj;
17128 }
17129
17130
17131 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
17132 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
17133 return 1;
17134 }
17135
17136
17137 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
17138 PyObject *pyobj = NULL;
17139
17140 {
17141 #if wxUSE_UNICODE
17142 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
17143 #else
17144 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
17145 #endif
17146 }
17147 return pyobj;
17148 }
17149
17150
17151 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
17152 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
17153 return 1;
17154 }
17155
17156
17157 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
17158 PyObject *pyobj = NULL;
17159
17160 {
17161 #if wxUSE_UNICODE
17162 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
17163 #else
17164 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
17165 #endif
17166 }
17167 return pyobj;
17168 }
17169
17170
17171 static int _wrap_ART_TICK_MARK_set(PyObject *) {
17172 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
17173 return 1;
17174 }
17175
17176
17177 static PyObject *_wrap_ART_TICK_MARK_get(void) {
17178 PyObject *pyobj = NULL;
17179
17180 {
17181 #if wxUSE_UNICODE
17182 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
17183 #else
17184 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
17185 #endif
17186 }
17187 return pyobj;
17188 }
17189
17190
17191 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
17192 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
17193 return 1;
17194 }
17195
17196
17197 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
17198 PyObject *pyobj = NULL;
17199
17200 {
17201 #if wxUSE_UNICODE
17202 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
17203 #else
17204 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
17205 #endif
17206 }
17207 return pyobj;
17208 }
17209
17210
17211 static int _wrap_ART_ERROR_set(PyObject *) {
17212 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
17213 return 1;
17214 }
17215
17216
17217 static PyObject *_wrap_ART_ERROR_get(void) {
17218 PyObject *pyobj = NULL;
17219
17220 {
17221 #if wxUSE_UNICODE
17222 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
17223 #else
17224 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
17225 #endif
17226 }
17227 return pyobj;
17228 }
17229
17230
17231 static int _wrap_ART_QUESTION_set(PyObject *) {
17232 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
17233 return 1;
17234 }
17235
17236
17237 static PyObject *_wrap_ART_QUESTION_get(void) {
17238 PyObject *pyobj = NULL;
17239
17240 {
17241 #if wxUSE_UNICODE
17242 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
17243 #else
17244 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
17245 #endif
17246 }
17247 return pyobj;
17248 }
17249
17250
17251 static int _wrap_ART_WARNING_set(PyObject *) {
17252 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
17253 return 1;
17254 }
17255
17256
17257 static PyObject *_wrap_ART_WARNING_get(void) {
17258 PyObject *pyobj = NULL;
17259
17260 {
17261 #if wxUSE_UNICODE
17262 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
17263 #else
17264 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
17265 #endif
17266 }
17267 return pyobj;
17268 }
17269
17270
17271 static int _wrap_ART_INFORMATION_set(PyObject *) {
17272 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
17273 return 1;
17274 }
17275
17276
17277 static PyObject *_wrap_ART_INFORMATION_get(void) {
17278 PyObject *pyobj = NULL;
17279
17280 {
17281 #if wxUSE_UNICODE
17282 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
17283 #else
17284 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
17285 #endif
17286 }
17287 return pyobj;
17288 }
17289
17290
17291 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
17292 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
17293 return 1;
17294 }
17295
17296
17297 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
17298 PyObject *pyobj = NULL;
17299
17300 {
17301 #if wxUSE_UNICODE
17302 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
17303 #else
17304 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
17305 #endif
17306 }
17307 return pyobj;
17308 }
17309
17310
17311 static int _wrap_ART_COPY_set(PyObject *) {
17312 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
17313 return 1;
17314 }
17315
17316
17317 static PyObject *_wrap_ART_COPY_get(void) {
17318 PyObject *pyobj = NULL;
17319
17320 {
17321 #if wxUSE_UNICODE
17322 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
17323 #else
17324 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
17325 #endif
17326 }
17327 return pyobj;
17328 }
17329
17330
17331 static int _wrap_ART_CUT_set(PyObject *) {
17332 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
17333 return 1;
17334 }
17335
17336
17337 static PyObject *_wrap_ART_CUT_get(void) {
17338 PyObject *pyobj = NULL;
17339
17340 {
17341 #if wxUSE_UNICODE
17342 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
17343 #else
17344 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
17345 #endif
17346 }
17347 return pyobj;
17348 }
17349
17350
17351 static int _wrap_ART_PASTE_set(PyObject *) {
17352 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
17353 return 1;
17354 }
17355
17356
17357 static PyObject *_wrap_ART_PASTE_get(void) {
17358 PyObject *pyobj = NULL;
17359
17360 {
17361 #if wxUSE_UNICODE
17362 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
17363 #else
17364 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
17365 #endif
17366 }
17367 return pyobj;
17368 }
17369
17370
17371 static int _wrap_ART_DELETE_set(PyObject *) {
17372 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
17373 return 1;
17374 }
17375
17376
17377 static PyObject *_wrap_ART_DELETE_get(void) {
17378 PyObject *pyobj = NULL;
17379
17380 {
17381 #if wxUSE_UNICODE
17382 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
17383 #else
17384 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
17385 #endif
17386 }
17387 return pyobj;
17388 }
17389
17390
17391 static int _wrap_ART_NEW_set(PyObject *) {
17392 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW is read-only.");
17393 return 1;
17394 }
17395
17396
17397 static PyObject *_wrap_ART_NEW_get(void) {
17398 PyObject *pyobj = NULL;
17399
17400 {
17401 #if wxUSE_UNICODE
17402 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
17403 #else
17404 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
17405 #endif
17406 }
17407 return pyobj;
17408 }
17409
17410
17411 static int _wrap_ART_UNDO_set(PyObject *) {
17412 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
17413 return 1;
17414 }
17415
17416
17417 static PyObject *_wrap_ART_UNDO_get(void) {
17418 PyObject *pyobj = NULL;
17419
17420 {
17421 #if wxUSE_UNICODE
17422 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
17423 #else
17424 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
17425 #endif
17426 }
17427 return pyobj;
17428 }
17429
17430
17431 static int _wrap_ART_REDO_set(PyObject *) {
17432 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
17433 return 1;
17434 }
17435
17436
17437 static PyObject *_wrap_ART_REDO_get(void) {
17438 PyObject *pyobj = NULL;
17439
17440 {
17441 #if wxUSE_UNICODE
17442 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
17443 #else
17444 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
17445 #endif
17446 }
17447 return pyobj;
17448 }
17449
17450
17451 static int _wrap_ART_QUIT_set(PyObject *) {
17452 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
17453 return 1;
17454 }
17455
17456
17457 static PyObject *_wrap_ART_QUIT_get(void) {
17458 PyObject *pyobj = NULL;
17459
17460 {
17461 #if wxUSE_UNICODE
17462 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
17463 #else
17464 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
17465 #endif
17466 }
17467 return pyobj;
17468 }
17469
17470
17471 static int _wrap_ART_FIND_set(PyObject *) {
17472 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
17473 return 1;
17474 }
17475
17476
17477 static PyObject *_wrap_ART_FIND_get(void) {
17478 PyObject *pyobj = NULL;
17479
17480 {
17481 #if wxUSE_UNICODE
17482 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
17483 #else
17484 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
17485 #endif
17486 }
17487 return pyobj;
17488 }
17489
17490
17491 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
17492 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
17493 return 1;
17494 }
17495
17496
17497 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
17498 PyObject *pyobj = NULL;
17499
17500 {
17501 #if wxUSE_UNICODE
17502 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
17503 #else
17504 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
17505 #endif
17506 }
17507 return pyobj;
17508 }
17509
17510
17511 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17512 PyObject *resultobj = NULL;
17513 wxPyArtProvider *result;
17514 char *kwnames[] = {
17515 NULL
17516 };
17517
17518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
17519 {
17520 if (!wxPyCheckForApp()) SWIG_fail;
17521 PyThreadState* __tstate = wxPyBeginAllowThreads();
17522 result = (wxPyArtProvider *)new wxPyArtProvider();
17523
17524 wxPyEndAllowThreads(__tstate);
17525 if (PyErr_Occurred()) SWIG_fail;
17526 }
17527 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
17528 return resultobj;
17529 fail:
17530 return NULL;
17531 }
17532
17533
17534 static PyObject *_wrap_delete_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17535 PyObject *resultobj = NULL;
17536 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17537 PyObject * obj0 = 0 ;
17538 char *kwnames[] = {
17539 (char *) "self", NULL
17540 };
17541
17542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ArtProvider",kwnames,&obj0)) goto fail;
17543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17544 if (SWIG_arg_fail(1)) SWIG_fail;
17545 {
17546 PyThreadState* __tstate = wxPyBeginAllowThreads();
17547 delete arg1;
17548
17549 wxPyEndAllowThreads(__tstate);
17550 if (PyErr_Occurred()) SWIG_fail;
17551 }
17552 Py_INCREF(Py_None); resultobj = Py_None;
17553 return resultobj;
17554 fail:
17555 return NULL;
17556 }
17557
17558
17559 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
17560 PyObject *resultobj = NULL;
17561 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17562 PyObject *arg2 = (PyObject *) 0 ;
17563 PyObject *arg3 = (PyObject *) 0 ;
17564 PyObject * obj0 = 0 ;
17565 PyObject * obj1 = 0 ;
17566 PyObject * obj2 = 0 ;
17567 char *kwnames[] = {
17568 (char *) "self",(char *) "self",(char *) "_class", NULL
17569 };
17570
17571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
17572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17573 if (SWIG_arg_fail(1)) SWIG_fail;
17574 arg2 = obj1;
17575 arg3 = obj2;
17576 {
17577 PyThreadState* __tstate = wxPyBeginAllowThreads();
17578 (arg1)->_setCallbackInfo(arg2,arg3);
17579
17580 wxPyEndAllowThreads(__tstate);
17581 if (PyErr_Occurred()) SWIG_fail;
17582 }
17583 Py_INCREF(Py_None); resultobj = Py_None;
17584 return resultobj;
17585 fail:
17586 return NULL;
17587 }
17588
17589
17590 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17591 PyObject *resultobj = NULL;
17592 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17593 PyObject * obj0 = 0 ;
17594 char *kwnames[] = {
17595 (char *) "provider", NULL
17596 };
17597
17598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
17599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
17600 if (SWIG_arg_fail(1)) SWIG_fail;
17601 {
17602 PyThreadState* __tstate = wxPyBeginAllowThreads();
17603 wxPyArtProvider::PushProvider(arg1);
17604
17605 wxPyEndAllowThreads(__tstate);
17606 if (PyErr_Occurred()) SWIG_fail;
17607 }
17608 Py_INCREF(Py_None); resultobj = Py_None;
17609 return resultobj;
17610 fail:
17611 return NULL;
17612 }
17613
17614
17615 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17616 PyObject *resultobj = NULL;
17617 bool result;
17618 char *kwnames[] = {
17619 NULL
17620 };
17621
17622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
17623 {
17624 PyThreadState* __tstate = wxPyBeginAllowThreads();
17625 result = (bool)wxPyArtProvider::PopProvider();
17626
17627 wxPyEndAllowThreads(__tstate);
17628 if (PyErr_Occurred()) SWIG_fail;
17629 }
17630 {
17631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17632 }
17633 return resultobj;
17634 fail:
17635 return NULL;
17636 }
17637
17638
17639 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
17640 PyObject *resultobj = NULL;
17641 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17642 bool result;
17643 PyObject * obj0 = 0 ;
17644 char *kwnames[] = {
17645 (char *) "provider", NULL
17646 };
17647
17648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
17649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17650 if (SWIG_arg_fail(1)) SWIG_fail;
17651 {
17652 PyThreadState* __tstate = wxPyBeginAllowThreads();
17653 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
17654
17655 wxPyEndAllowThreads(__tstate);
17656 if (PyErr_Occurred()) SWIG_fail;
17657 }
17658 {
17659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17660 }
17661 return resultobj;
17662 fail:
17663 return NULL;
17664 }
17665
17666
17667 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
17668 PyObject *resultobj = NULL;
17669 wxString *arg1 = 0 ;
17670 wxString const &arg2_defvalue = wxPyART_OTHER ;
17671 wxString *arg2 = (wxString *) &arg2_defvalue ;
17672 wxSize const &arg3_defvalue = wxDefaultSize ;
17673 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
17674 wxBitmap result;
17675 bool temp1 = false ;
17676 bool temp2 = false ;
17677 wxSize temp3 ;
17678 PyObject * obj0 = 0 ;
17679 PyObject * obj1 = 0 ;
17680 PyObject * obj2 = 0 ;
17681 char *kwnames[] = {
17682 (char *) "id",(char *) "client",(char *) "size", NULL
17683 };
17684
17685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
17686 {
17687 arg1 = wxString_in_helper(obj0);
17688 if (arg1 == NULL) SWIG_fail;
17689 temp1 = true;
17690 }
17691 if (obj1) {
17692 {
17693 arg2 = wxString_in_helper(obj1);
17694 if (arg2 == NULL) SWIG_fail;
17695 temp2 = true;
17696 }
17697 }
17698 if (obj2) {
17699 {
17700 arg3 = &temp3;
17701 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
17702 }
17703 }
17704 {
17705 if (!wxPyCheckForApp()) SWIG_fail;
17706 PyThreadState* __tstate = wxPyBeginAllowThreads();
17707 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
17708
17709 wxPyEndAllowThreads(__tstate);
17710 if (PyErr_Occurred()) SWIG_fail;
17711 }
17712 {
17713 wxBitmap * resultptr;
17714 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
17715 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
17716 }
17717 {
17718 if (temp1)
17719 delete arg1;
17720 }
17721 {
17722 if (temp2)
17723 delete arg2;
17724 }
17725 return resultobj;
17726 fail:
17727 {
17728 if (temp1)
17729 delete arg1;
17730 }
17731 {
17732 if (temp2)
17733 delete arg2;
17734 }
17735 return NULL;
17736 }
17737
17738
17739 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
17740 PyObject *resultobj = NULL;
17741 wxString *arg1 = 0 ;
17742 wxString const &arg2_defvalue = wxPyART_OTHER ;
17743 wxString *arg2 = (wxString *) &arg2_defvalue ;
17744 wxSize const &arg3_defvalue = wxDefaultSize ;
17745 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
17746 wxIcon result;
17747 bool temp1 = false ;
17748 bool temp2 = false ;
17749 wxSize temp3 ;
17750 PyObject * obj0 = 0 ;
17751 PyObject * obj1 = 0 ;
17752 PyObject * obj2 = 0 ;
17753 char *kwnames[] = {
17754 (char *) "id",(char *) "client",(char *) "size", NULL
17755 };
17756
17757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
17758 {
17759 arg1 = wxString_in_helper(obj0);
17760 if (arg1 == NULL) SWIG_fail;
17761 temp1 = true;
17762 }
17763 if (obj1) {
17764 {
17765 arg2 = wxString_in_helper(obj1);
17766 if (arg2 == NULL) SWIG_fail;
17767 temp2 = true;
17768 }
17769 }
17770 if (obj2) {
17771 {
17772 arg3 = &temp3;
17773 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
17774 }
17775 }
17776 {
17777 if (!wxPyCheckForApp()) SWIG_fail;
17778 PyThreadState* __tstate = wxPyBeginAllowThreads();
17779 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
17780
17781 wxPyEndAllowThreads(__tstate);
17782 if (PyErr_Occurred()) SWIG_fail;
17783 }
17784 {
17785 wxIcon * resultptr;
17786 resultptr = new wxIcon(static_cast<wxIcon & >(result));
17787 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
17788 }
17789 {
17790 if (temp1)
17791 delete arg1;
17792 }
17793 {
17794 if (temp2)
17795 delete arg2;
17796 }
17797 return resultobj;
17798 fail:
17799 {
17800 if (temp1)
17801 delete arg1;
17802 }
17803 {
17804 if (temp2)
17805 delete arg2;
17806 }
17807 return NULL;
17808 }
17809
17810
17811 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
17812 PyObject *resultobj = NULL;
17813 wxString *arg1 = 0 ;
17814 bool arg2 = (bool) false ;
17815 wxSize result;
17816 bool temp1 = false ;
17817 PyObject * obj0 = 0 ;
17818 PyObject * obj1 = 0 ;
17819 char *kwnames[] = {
17820 (char *) "client",(char *) "platform_dependent", NULL
17821 };
17822
17823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
17824 {
17825 arg1 = wxString_in_helper(obj0);
17826 if (arg1 == NULL) SWIG_fail;
17827 temp1 = true;
17828 }
17829 if (obj1) {
17830 {
17831 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
17832 if (SWIG_arg_fail(2)) SWIG_fail;
17833 }
17834 }
17835 {
17836 PyThreadState* __tstate = wxPyBeginAllowThreads();
17837 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
17838
17839 wxPyEndAllowThreads(__tstate);
17840 if (PyErr_Occurred()) SWIG_fail;
17841 }
17842 {
17843 wxSize * resultptr;
17844 resultptr = new wxSize(static_cast<wxSize & >(result));
17845 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
17846 }
17847 {
17848 if (temp1)
17849 delete arg1;
17850 }
17851 return resultobj;
17852 fail:
17853 {
17854 if (temp1)
17855 delete arg1;
17856 }
17857 return NULL;
17858 }
17859
17860
17861 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
17862 PyObject *resultobj = NULL;
17863 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
17864 PyObject * obj0 = 0 ;
17865 char *kwnames[] = {
17866 (char *) "self", NULL
17867 };
17868
17869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
17870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
17871 if (SWIG_arg_fail(1)) SWIG_fail;
17872 {
17873 PyThreadState* __tstate = wxPyBeginAllowThreads();
17874 wxPyArtProvider_Destroy(arg1);
17875
17876 wxPyEndAllowThreads(__tstate);
17877 if (PyErr_Occurred()) SWIG_fail;
17878 }
17879 Py_INCREF(Py_None); resultobj = Py_None;
17880 return resultobj;
17881 fail:
17882 return NULL;
17883 }
17884
17885
17886 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
17887 PyObject *obj;
17888 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17889 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
17890 Py_INCREF(obj);
17891 return Py_BuildValue((char *)"");
17892 }
17893 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
17894 PyObject *resultobj = NULL;
17895 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17896 PyObject * obj0 = 0 ;
17897 char *kwnames[] = {
17898 (char *) "self", NULL
17899 };
17900
17901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
17902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17903 if (SWIG_arg_fail(1)) SWIG_fail;
17904 {
17905 PyThreadState* __tstate = wxPyBeginAllowThreads();
17906 delete arg1;
17907
17908 wxPyEndAllowThreads(__tstate);
17909 if (PyErr_Occurred()) SWIG_fail;
17910 }
17911 Py_INCREF(Py_None); resultobj = Py_None;
17912 return resultobj;
17913 fail:
17914 return NULL;
17915 }
17916
17917
17918 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
17919 PyObject *resultobj = NULL;
17920 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17921 wxConfigBase *result;
17922 PyObject * obj0 = 0 ;
17923 char *kwnames[] = {
17924 (char *) "config", NULL
17925 };
17926
17927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
17928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
17929 if (SWIG_arg_fail(1)) SWIG_fail;
17930 {
17931 PyThreadState* __tstate = wxPyBeginAllowThreads();
17932 result = (wxConfigBase *)wxConfigBase::Set(arg1);
17933
17934 wxPyEndAllowThreads(__tstate);
17935 if (PyErr_Occurred()) SWIG_fail;
17936 }
17937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17938 return resultobj;
17939 fail:
17940 return NULL;
17941 }
17942
17943
17944 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
17945 PyObject *resultobj = NULL;
17946 bool arg1 = (bool) true ;
17947 wxConfigBase *result;
17948 PyObject * obj0 = 0 ;
17949 char *kwnames[] = {
17950 (char *) "createOnDemand", NULL
17951 };
17952
17953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
17954 if (obj0) {
17955 {
17956 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
17957 if (SWIG_arg_fail(1)) SWIG_fail;
17958 }
17959 }
17960 {
17961 PyThreadState* __tstate = wxPyBeginAllowThreads();
17962 result = (wxConfigBase *)wxConfigBase::Get(arg1);
17963
17964 wxPyEndAllowThreads(__tstate);
17965 if (PyErr_Occurred()) SWIG_fail;
17966 }
17967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17968 return resultobj;
17969 fail:
17970 return NULL;
17971 }
17972
17973
17974 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
17975 PyObject *resultobj = NULL;
17976 wxConfigBase *result;
17977 char *kwnames[] = {
17978 NULL
17979 };
17980
17981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
17982 {
17983 PyThreadState* __tstate = wxPyBeginAllowThreads();
17984 result = (wxConfigBase *)wxConfigBase::Create();
17985
17986 wxPyEndAllowThreads(__tstate);
17987 if (PyErr_Occurred()) SWIG_fail;
17988 }
17989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17990 return resultobj;
17991 fail:
17992 return NULL;
17993 }
17994
17995
17996 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17997 PyObject *resultobj = NULL;
17998 char *kwnames[] = {
17999 NULL
18000 };
18001
18002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
18003 {
18004 PyThreadState* __tstate = wxPyBeginAllowThreads();
18005 wxConfigBase::DontCreateOnDemand();
18006
18007 wxPyEndAllowThreads(__tstate);
18008 if (PyErr_Occurred()) SWIG_fail;
18009 }
18010 Py_INCREF(Py_None); resultobj = Py_None;
18011 return resultobj;
18012 fail:
18013 return NULL;
18014 }
18015
18016
18017 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
18018 PyObject *resultobj = NULL;
18019 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18020 wxString *arg2 = 0 ;
18021 bool temp2 = false ;
18022 PyObject * obj0 = 0 ;
18023 PyObject * obj1 = 0 ;
18024 char *kwnames[] = {
18025 (char *) "self",(char *) "path", NULL
18026 };
18027
18028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
18029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18030 if (SWIG_arg_fail(1)) SWIG_fail;
18031 {
18032 arg2 = wxString_in_helper(obj1);
18033 if (arg2 == NULL) SWIG_fail;
18034 temp2 = true;
18035 }
18036 {
18037 PyThreadState* __tstate = wxPyBeginAllowThreads();
18038 (arg1)->SetPath((wxString const &)*arg2);
18039
18040 wxPyEndAllowThreads(__tstate);
18041 if (PyErr_Occurred()) SWIG_fail;
18042 }
18043 Py_INCREF(Py_None); resultobj = Py_None;
18044 {
18045 if (temp2)
18046 delete arg2;
18047 }
18048 return resultobj;
18049 fail:
18050 {
18051 if (temp2)
18052 delete arg2;
18053 }
18054 return NULL;
18055 }
18056
18057
18058 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
18059 PyObject *resultobj = NULL;
18060 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18061 wxString *result;
18062 PyObject * obj0 = 0 ;
18063 char *kwnames[] = {
18064 (char *) "self", NULL
18065 };
18066
18067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
18072 {
18073 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
18074 result = (wxString *) &_result_ref;
18075 }
18076
18077 wxPyEndAllowThreads(__tstate);
18078 if (PyErr_Occurred()) SWIG_fail;
18079 }
18080 {
18081 #if wxUSE_UNICODE
18082 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18083 #else
18084 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18085 #endif
18086 }
18087 return resultobj;
18088 fail:
18089 return NULL;
18090 }
18091
18092
18093 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18094 PyObject *resultobj = NULL;
18095 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18096 PyObject *result;
18097 PyObject * obj0 = 0 ;
18098 char *kwnames[] = {
18099 (char *) "self", NULL
18100 };
18101
18102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
18103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18104 if (SWIG_arg_fail(1)) SWIG_fail;
18105 {
18106 PyThreadState* __tstate = wxPyBeginAllowThreads();
18107 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
18108
18109 wxPyEndAllowThreads(__tstate);
18110 if (PyErr_Occurred()) SWIG_fail;
18111 }
18112 resultobj = result;
18113 return resultobj;
18114 fail:
18115 return NULL;
18116 }
18117
18118
18119 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18120 PyObject *resultobj = NULL;
18121 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18122 long arg2 ;
18123 PyObject *result;
18124 PyObject * obj0 = 0 ;
18125 PyObject * obj1 = 0 ;
18126 char *kwnames[] = {
18127 (char *) "self",(char *) "index", NULL
18128 };
18129
18130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
18131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18132 if (SWIG_arg_fail(1)) SWIG_fail;
18133 {
18134 arg2 = static_cast<long >(SWIG_As_long(obj1));
18135 if (SWIG_arg_fail(2)) SWIG_fail;
18136 }
18137 {
18138 PyThreadState* __tstate = wxPyBeginAllowThreads();
18139 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
18140
18141 wxPyEndAllowThreads(__tstate);
18142 if (PyErr_Occurred()) SWIG_fail;
18143 }
18144 resultobj = result;
18145 return resultobj;
18146 fail:
18147 return NULL;
18148 }
18149
18150
18151 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18152 PyObject *resultobj = NULL;
18153 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18154 PyObject *result;
18155 PyObject * obj0 = 0 ;
18156 char *kwnames[] = {
18157 (char *) "self", NULL
18158 };
18159
18160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
18161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18162 if (SWIG_arg_fail(1)) SWIG_fail;
18163 {
18164 PyThreadState* __tstate = wxPyBeginAllowThreads();
18165 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
18166
18167 wxPyEndAllowThreads(__tstate);
18168 if (PyErr_Occurred()) SWIG_fail;
18169 }
18170 resultobj = result;
18171 return resultobj;
18172 fail:
18173 return NULL;
18174 }
18175
18176
18177 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18178 PyObject *resultobj = NULL;
18179 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18180 long arg2 ;
18181 PyObject *result;
18182 PyObject * obj0 = 0 ;
18183 PyObject * obj1 = 0 ;
18184 char *kwnames[] = {
18185 (char *) "self",(char *) "index", NULL
18186 };
18187
18188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
18189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18190 if (SWIG_arg_fail(1)) SWIG_fail;
18191 {
18192 arg2 = static_cast<long >(SWIG_As_long(obj1));
18193 if (SWIG_arg_fail(2)) SWIG_fail;
18194 }
18195 {
18196 PyThreadState* __tstate = wxPyBeginAllowThreads();
18197 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
18198
18199 wxPyEndAllowThreads(__tstate);
18200 if (PyErr_Occurred()) SWIG_fail;
18201 }
18202 resultobj = result;
18203 return resultobj;
18204 fail:
18205 return NULL;
18206 }
18207
18208
18209 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
18210 PyObject *resultobj = NULL;
18211 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18212 bool arg2 = (bool) false ;
18213 size_t result;
18214 PyObject * obj0 = 0 ;
18215 PyObject * obj1 = 0 ;
18216 char *kwnames[] = {
18217 (char *) "self",(char *) "recursive", NULL
18218 };
18219
18220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
18221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18222 if (SWIG_arg_fail(1)) SWIG_fail;
18223 if (obj1) {
18224 {
18225 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18226 if (SWIG_arg_fail(2)) SWIG_fail;
18227 }
18228 }
18229 {
18230 PyThreadState* __tstate = wxPyBeginAllowThreads();
18231 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
18232
18233 wxPyEndAllowThreads(__tstate);
18234 if (PyErr_Occurred()) SWIG_fail;
18235 }
18236 {
18237 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
18238 }
18239 return resultobj;
18240 fail:
18241 return NULL;
18242 }
18243
18244
18245 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
18246 PyObject *resultobj = NULL;
18247 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18248 bool arg2 = (bool) false ;
18249 size_t result;
18250 PyObject * obj0 = 0 ;
18251 PyObject * obj1 = 0 ;
18252 char *kwnames[] = {
18253 (char *) "self",(char *) "recursive", NULL
18254 };
18255
18256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
18257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18258 if (SWIG_arg_fail(1)) SWIG_fail;
18259 if (obj1) {
18260 {
18261 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18262 if (SWIG_arg_fail(2)) SWIG_fail;
18263 }
18264 }
18265 {
18266 PyThreadState* __tstate = wxPyBeginAllowThreads();
18267 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
18268
18269 wxPyEndAllowThreads(__tstate);
18270 if (PyErr_Occurred()) SWIG_fail;
18271 }
18272 {
18273 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
18274 }
18275 return resultobj;
18276 fail:
18277 return NULL;
18278 }
18279
18280
18281 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18282 PyObject *resultobj = NULL;
18283 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18284 wxString *arg2 = 0 ;
18285 bool result;
18286 bool temp2 = false ;
18287 PyObject * obj0 = 0 ;
18288 PyObject * obj1 = 0 ;
18289 char *kwnames[] = {
18290 (char *) "self",(char *) "name", NULL
18291 };
18292
18293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
18294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18295 if (SWIG_arg_fail(1)) SWIG_fail;
18296 {
18297 arg2 = wxString_in_helper(obj1);
18298 if (arg2 == NULL) SWIG_fail;
18299 temp2 = true;
18300 }
18301 {
18302 PyThreadState* __tstate = wxPyBeginAllowThreads();
18303 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
18304
18305 wxPyEndAllowThreads(__tstate);
18306 if (PyErr_Occurred()) SWIG_fail;
18307 }
18308 {
18309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18310 }
18311 {
18312 if (temp2)
18313 delete arg2;
18314 }
18315 return resultobj;
18316 fail:
18317 {
18318 if (temp2)
18319 delete arg2;
18320 }
18321 return NULL;
18322 }
18323
18324
18325 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18326 PyObject *resultobj = NULL;
18327 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18328 wxString *arg2 = 0 ;
18329 bool result;
18330 bool temp2 = false ;
18331 PyObject * obj0 = 0 ;
18332 PyObject * obj1 = 0 ;
18333 char *kwnames[] = {
18334 (char *) "self",(char *) "name", NULL
18335 };
18336
18337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
18338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18339 if (SWIG_arg_fail(1)) SWIG_fail;
18340 {
18341 arg2 = wxString_in_helper(obj1);
18342 if (arg2 == NULL) SWIG_fail;
18343 temp2 = true;
18344 }
18345 {
18346 PyThreadState* __tstate = wxPyBeginAllowThreads();
18347 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
18348
18349 wxPyEndAllowThreads(__tstate);
18350 if (PyErr_Occurred()) SWIG_fail;
18351 }
18352 {
18353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18354 }
18355 {
18356 if (temp2)
18357 delete arg2;
18358 }
18359 return resultobj;
18360 fail:
18361 {
18362 if (temp2)
18363 delete arg2;
18364 }
18365 return NULL;
18366 }
18367
18368
18369 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
18370 PyObject *resultobj = NULL;
18371 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18372 wxString *arg2 = 0 ;
18373 bool result;
18374 bool temp2 = false ;
18375 PyObject * obj0 = 0 ;
18376 PyObject * obj1 = 0 ;
18377 char *kwnames[] = {
18378 (char *) "self",(char *) "name", NULL
18379 };
18380
18381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
18382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18383 if (SWIG_arg_fail(1)) SWIG_fail;
18384 {
18385 arg2 = wxString_in_helper(obj1);
18386 if (arg2 == NULL) SWIG_fail;
18387 temp2 = true;
18388 }
18389 {
18390 PyThreadState* __tstate = wxPyBeginAllowThreads();
18391 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
18392
18393 wxPyEndAllowThreads(__tstate);
18394 if (PyErr_Occurred()) SWIG_fail;
18395 }
18396 {
18397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18398 }
18399 {
18400 if (temp2)
18401 delete arg2;
18402 }
18403 return resultobj;
18404 fail:
18405 {
18406 if (temp2)
18407 delete arg2;
18408 }
18409 return NULL;
18410 }
18411
18412
18413 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
18414 PyObject *resultobj = NULL;
18415 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18416 wxString *arg2 = 0 ;
18417 wxConfigBase::EntryType result;
18418 bool temp2 = false ;
18419 PyObject * obj0 = 0 ;
18420 PyObject * obj1 = 0 ;
18421 char *kwnames[] = {
18422 (char *) "self",(char *) "name", NULL
18423 };
18424
18425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
18426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18427 if (SWIG_arg_fail(1)) SWIG_fail;
18428 {
18429 arg2 = wxString_in_helper(obj1);
18430 if (arg2 == NULL) SWIG_fail;
18431 temp2 = true;
18432 }
18433 {
18434 PyThreadState* __tstate = wxPyBeginAllowThreads();
18435 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
18436
18437 wxPyEndAllowThreads(__tstate);
18438 if (PyErr_Occurred()) SWIG_fail;
18439 }
18440 resultobj = SWIG_From_int((result));
18441 {
18442 if (temp2)
18443 delete arg2;
18444 }
18445 return resultobj;
18446 fail:
18447 {
18448 if (temp2)
18449 delete arg2;
18450 }
18451 return NULL;
18452 }
18453
18454
18455 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
18456 PyObject *resultobj = NULL;
18457 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18458 wxString *arg2 = 0 ;
18459 wxString const &arg3_defvalue = wxPyEmptyString ;
18460 wxString *arg3 = (wxString *) &arg3_defvalue ;
18461 wxString result;
18462 bool temp2 = false ;
18463 bool temp3 = false ;
18464 PyObject * obj0 = 0 ;
18465 PyObject * obj1 = 0 ;
18466 PyObject * obj2 = 0 ;
18467 char *kwnames[] = {
18468 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
18469 };
18470
18471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
18472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18473 if (SWIG_arg_fail(1)) SWIG_fail;
18474 {
18475 arg2 = wxString_in_helper(obj1);
18476 if (arg2 == NULL) SWIG_fail;
18477 temp2 = true;
18478 }
18479 if (obj2) {
18480 {
18481 arg3 = wxString_in_helper(obj2);
18482 if (arg3 == NULL) SWIG_fail;
18483 temp3 = true;
18484 }
18485 }
18486 {
18487 PyThreadState* __tstate = wxPyBeginAllowThreads();
18488 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
18489
18490 wxPyEndAllowThreads(__tstate);
18491 if (PyErr_Occurred()) SWIG_fail;
18492 }
18493 {
18494 #if wxUSE_UNICODE
18495 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18496 #else
18497 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18498 #endif
18499 }
18500 {
18501 if (temp2)
18502 delete arg2;
18503 }
18504 {
18505 if (temp3)
18506 delete arg3;
18507 }
18508 return resultobj;
18509 fail:
18510 {
18511 if (temp2)
18512 delete arg2;
18513 }
18514 {
18515 if (temp3)
18516 delete arg3;
18517 }
18518 return NULL;
18519 }
18520
18521
18522 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
18523 PyObject *resultobj = NULL;
18524 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18525 wxString *arg2 = 0 ;
18526 long arg3 = (long) 0 ;
18527 long result;
18528 bool temp2 = false ;
18529 PyObject * obj0 = 0 ;
18530 PyObject * obj1 = 0 ;
18531 PyObject * obj2 = 0 ;
18532 char *kwnames[] = {
18533 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
18534 };
18535
18536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
18537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18538 if (SWIG_arg_fail(1)) SWIG_fail;
18539 {
18540 arg2 = wxString_in_helper(obj1);
18541 if (arg2 == NULL) SWIG_fail;
18542 temp2 = true;
18543 }
18544 if (obj2) {
18545 {
18546 arg3 = static_cast<long >(SWIG_As_long(obj2));
18547 if (SWIG_arg_fail(3)) SWIG_fail;
18548 }
18549 }
18550 {
18551 PyThreadState* __tstate = wxPyBeginAllowThreads();
18552 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
18553
18554 wxPyEndAllowThreads(__tstate);
18555 if (PyErr_Occurred()) SWIG_fail;
18556 }
18557 {
18558 resultobj = SWIG_From_long(static_cast<long >(result));
18559 }
18560 {
18561 if (temp2)
18562 delete arg2;
18563 }
18564 return resultobj;
18565 fail:
18566 {
18567 if (temp2)
18568 delete arg2;
18569 }
18570 return NULL;
18571 }
18572
18573
18574 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
18575 PyObject *resultobj = NULL;
18576 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18577 wxString *arg2 = 0 ;
18578 double arg3 = (double) 0.0 ;
18579 double result;
18580 bool temp2 = false ;
18581 PyObject * obj0 = 0 ;
18582 PyObject * obj1 = 0 ;
18583 PyObject * obj2 = 0 ;
18584 char *kwnames[] = {
18585 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
18586 };
18587
18588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
18589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18590 if (SWIG_arg_fail(1)) SWIG_fail;
18591 {
18592 arg2 = wxString_in_helper(obj1);
18593 if (arg2 == NULL) SWIG_fail;
18594 temp2 = true;
18595 }
18596 if (obj2) {
18597 {
18598 arg3 = static_cast<double >(SWIG_As_double(obj2));
18599 if (SWIG_arg_fail(3)) SWIG_fail;
18600 }
18601 }
18602 {
18603 PyThreadState* __tstate = wxPyBeginAllowThreads();
18604 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
18605
18606 wxPyEndAllowThreads(__tstate);
18607 if (PyErr_Occurred()) SWIG_fail;
18608 }
18609 {
18610 resultobj = SWIG_From_double(static_cast<double >(result));
18611 }
18612 {
18613 if (temp2)
18614 delete arg2;
18615 }
18616 return resultobj;
18617 fail:
18618 {
18619 if (temp2)
18620 delete arg2;
18621 }
18622 return NULL;
18623 }
18624
18625
18626 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
18627 PyObject *resultobj = NULL;
18628 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18629 wxString *arg2 = 0 ;
18630 bool arg3 = (bool) false ;
18631 bool result;
18632 bool temp2 = false ;
18633 PyObject * obj0 = 0 ;
18634 PyObject * obj1 = 0 ;
18635 PyObject * obj2 = 0 ;
18636 char *kwnames[] = {
18637 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
18638 };
18639
18640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
18641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18642 if (SWIG_arg_fail(1)) SWIG_fail;
18643 {
18644 arg2 = wxString_in_helper(obj1);
18645 if (arg2 == NULL) SWIG_fail;
18646 temp2 = true;
18647 }
18648 if (obj2) {
18649 {
18650 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
18651 if (SWIG_arg_fail(3)) SWIG_fail;
18652 }
18653 }
18654 {
18655 PyThreadState* __tstate = wxPyBeginAllowThreads();
18656 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
18657
18658 wxPyEndAllowThreads(__tstate);
18659 if (PyErr_Occurred()) SWIG_fail;
18660 }
18661 {
18662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18663 }
18664 {
18665 if (temp2)
18666 delete arg2;
18667 }
18668 return resultobj;
18669 fail:
18670 {
18671 if (temp2)
18672 delete arg2;
18673 }
18674 return NULL;
18675 }
18676
18677
18678 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
18679 PyObject *resultobj = NULL;
18680 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18681 wxString *arg2 = 0 ;
18682 wxString *arg3 = 0 ;
18683 bool result;
18684 bool temp2 = false ;
18685 bool temp3 = false ;
18686 PyObject * obj0 = 0 ;
18687 PyObject * obj1 = 0 ;
18688 PyObject * obj2 = 0 ;
18689 char *kwnames[] = {
18690 (char *) "self",(char *) "key",(char *) "value", NULL
18691 };
18692
18693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
18694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18695 if (SWIG_arg_fail(1)) SWIG_fail;
18696 {
18697 arg2 = wxString_in_helper(obj1);
18698 if (arg2 == NULL) SWIG_fail;
18699 temp2 = true;
18700 }
18701 {
18702 arg3 = wxString_in_helper(obj2);
18703 if (arg3 == NULL) SWIG_fail;
18704 temp3 = true;
18705 }
18706 {
18707 PyThreadState* __tstate = wxPyBeginAllowThreads();
18708 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
18709
18710 wxPyEndAllowThreads(__tstate);
18711 if (PyErr_Occurred()) SWIG_fail;
18712 }
18713 {
18714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18715 }
18716 {
18717 if (temp2)
18718 delete arg2;
18719 }
18720 {
18721 if (temp3)
18722 delete arg3;
18723 }
18724 return resultobj;
18725 fail:
18726 {
18727 if (temp2)
18728 delete arg2;
18729 }
18730 {
18731 if (temp3)
18732 delete arg3;
18733 }
18734 return NULL;
18735 }
18736
18737
18738 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
18739 PyObject *resultobj = NULL;
18740 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18741 wxString *arg2 = 0 ;
18742 long arg3 ;
18743 bool result;
18744 bool temp2 = false ;
18745 PyObject * obj0 = 0 ;
18746 PyObject * obj1 = 0 ;
18747 PyObject * obj2 = 0 ;
18748 char *kwnames[] = {
18749 (char *) "self",(char *) "key",(char *) "value", NULL
18750 };
18751
18752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
18753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18754 if (SWIG_arg_fail(1)) SWIG_fail;
18755 {
18756 arg2 = wxString_in_helper(obj1);
18757 if (arg2 == NULL) SWIG_fail;
18758 temp2 = true;
18759 }
18760 {
18761 arg3 = static_cast<long >(SWIG_As_long(obj2));
18762 if (SWIG_arg_fail(3)) SWIG_fail;
18763 }
18764 {
18765 PyThreadState* __tstate = wxPyBeginAllowThreads();
18766 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
18767
18768 wxPyEndAllowThreads(__tstate);
18769 if (PyErr_Occurred()) SWIG_fail;
18770 }
18771 {
18772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18773 }
18774 {
18775 if (temp2)
18776 delete arg2;
18777 }
18778 return resultobj;
18779 fail:
18780 {
18781 if (temp2)
18782 delete arg2;
18783 }
18784 return NULL;
18785 }
18786
18787
18788 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
18789 PyObject *resultobj = NULL;
18790 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18791 wxString *arg2 = 0 ;
18792 double arg3 ;
18793 bool result;
18794 bool temp2 = false ;
18795 PyObject * obj0 = 0 ;
18796 PyObject * obj1 = 0 ;
18797 PyObject * obj2 = 0 ;
18798 char *kwnames[] = {
18799 (char *) "self",(char *) "key",(char *) "value", NULL
18800 };
18801
18802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
18803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18804 if (SWIG_arg_fail(1)) SWIG_fail;
18805 {
18806 arg2 = wxString_in_helper(obj1);
18807 if (arg2 == NULL) SWIG_fail;
18808 temp2 = true;
18809 }
18810 {
18811 arg3 = static_cast<double >(SWIG_As_double(obj2));
18812 if (SWIG_arg_fail(3)) SWIG_fail;
18813 }
18814 {
18815 PyThreadState* __tstate = wxPyBeginAllowThreads();
18816 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
18817
18818 wxPyEndAllowThreads(__tstate);
18819 if (PyErr_Occurred()) SWIG_fail;
18820 }
18821 {
18822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18823 }
18824 {
18825 if (temp2)
18826 delete arg2;
18827 }
18828 return resultobj;
18829 fail:
18830 {
18831 if (temp2)
18832 delete arg2;
18833 }
18834 return NULL;
18835 }
18836
18837
18838 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
18839 PyObject *resultobj = NULL;
18840 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18841 wxString *arg2 = 0 ;
18842 bool arg3 ;
18843 bool result;
18844 bool temp2 = false ;
18845 PyObject * obj0 = 0 ;
18846 PyObject * obj1 = 0 ;
18847 PyObject * obj2 = 0 ;
18848 char *kwnames[] = {
18849 (char *) "self",(char *) "key",(char *) "value", NULL
18850 };
18851
18852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
18853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18854 if (SWIG_arg_fail(1)) SWIG_fail;
18855 {
18856 arg2 = wxString_in_helper(obj1);
18857 if (arg2 == NULL) SWIG_fail;
18858 temp2 = true;
18859 }
18860 {
18861 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
18862 if (SWIG_arg_fail(3)) SWIG_fail;
18863 }
18864 {
18865 PyThreadState* __tstate = wxPyBeginAllowThreads();
18866 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
18867
18868 wxPyEndAllowThreads(__tstate);
18869 if (PyErr_Occurred()) SWIG_fail;
18870 }
18871 {
18872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18873 }
18874 {
18875 if (temp2)
18876 delete arg2;
18877 }
18878 return resultobj;
18879 fail:
18880 {
18881 if (temp2)
18882 delete arg2;
18883 }
18884 return NULL;
18885 }
18886
18887
18888 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
18889 PyObject *resultobj = NULL;
18890 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18891 bool arg2 = (bool) false ;
18892 bool result;
18893 PyObject * obj0 = 0 ;
18894 PyObject * obj1 = 0 ;
18895 char *kwnames[] = {
18896 (char *) "self",(char *) "currentOnly", NULL
18897 };
18898
18899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
18900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18901 if (SWIG_arg_fail(1)) SWIG_fail;
18902 if (obj1) {
18903 {
18904 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18905 if (SWIG_arg_fail(2)) SWIG_fail;
18906 }
18907 }
18908 {
18909 PyThreadState* __tstate = wxPyBeginAllowThreads();
18910 result = (bool)(arg1)->Flush(arg2);
18911
18912 wxPyEndAllowThreads(__tstate);
18913 if (PyErr_Occurred()) SWIG_fail;
18914 }
18915 {
18916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18917 }
18918 return resultobj;
18919 fail:
18920 return NULL;
18921 }
18922
18923
18924 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18925 PyObject *resultobj = NULL;
18926 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18927 wxString *arg2 = 0 ;
18928 wxString *arg3 = 0 ;
18929 bool result;
18930 bool temp2 = false ;
18931 bool temp3 = false ;
18932 PyObject * obj0 = 0 ;
18933 PyObject * obj1 = 0 ;
18934 PyObject * obj2 = 0 ;
18935 char *kwnames[] = {
18936 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18937 };
18938
18939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18941 if (SWIG_arg_fail(1)) SWIG_fail;
18942 {
18943 arg2 = wxString_in_helper(obj1);
18944 if (arg2 == NULL) SWIG_fail;
18945 temp2 = true;
18946 }
18947 {
18948 arg3 = wxString_in_helper(obj2);
18949 if (arg3 == NULL) SWIG_fail;
18950 temp3 = true;
18951 }
18952 {
18953 PyThreadState* __tstate = wxPyBeginAllowThreads();
18954 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
18955
18956 wxPyEndAllowThreads(__tstate);
18957 if (PyErr_Occurred()) SWIG_fail;
18958 }
18959 {
18960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18961 }
18962 {
18963 if (temp2)
18964 delete arg2;
18965 }
18966 {
18967 if (temp3)
18968 delete arg3;
18969 }
18970 return resultobj;
18971 fail:
18972 {
18973 if (temp2)
18974 delete arg2;
18975 }
18976 {
18977 if (temp3)
18978 delete arg3;
18979 }
18980 return NULL;
18981 }
18982
18983
18984 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18985 PyObject *resultobj = NULL;
18986 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18987 wxString *arg2 = 0 ;
18988 wxString *arg3 = 0 ;
18989 bool result;
18990 bool temp2 = false ;
18991 bool temp3 = false ;
18992 PyObject * obj0 = 0 ;
18993 PyObject * obj1 = 0 ;
18994 PyObject * obj2 = 0 ;
18995 char *kwnames[] = {
18996 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18997 };
18998
18999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
19000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19001 if (SWIG_arg_fail(1)) SWIG_fail;
19002 {
19003 arg2 = wxString_in_helper(obj1);
19004 if (arg2 == NULL) SWIG_fail;
19005 temp2 = true;
19006 }
19007 {
19008 arg3 = wxString_in_helper(obj2);
19009 if (arg3 == NULL) SWIG_fail;
19010 temp3 = true;
19011 }
19012 {
19013 PyThreadState* __tstate = wxPyBeginAllowThreads();
19014 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
19015
19016 wxPyEndAllowThreads(__tstate);
19017 if (PyErr_Occurred()) SWIG_fail;
19018 }
19019 {
19020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19021 }
19022 {
19023 if (temp2)
19024 delete arg2;
19025 }
19026 {
19027 if (temp3)
19028 delete arg3;
19029 }
19030 return resultobj;
19031 fail:
19032 {
19033 if (temp2)
19034 delete arg2;
19035 }
19036 {
19037 if (temp3)
19038 delete arg3;
19039 }
19040 return NULL;
19041 }
19042
19043
19044 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
19045 PyObject *resultobj = NULL;
19046 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19047 wxString *arg2 = 0 ;
19048 bool arg3 = (bool) true ;
19049 bool result;
19050 bool temp2 = false ;
19051 PyObject * obj0 = 0 ;
19052 PyObject * obj1 = 0 ;
19053 PyObject * obj2 = 0 ;
19054 char *kwnames[] = {
19055 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
19056 };
19057
19058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
19059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19060 if (SWIG_arg_fail(1)) SWIG_fail;
19061 {
19062 arg2 = wxString_in_helper(obj1);
19063 if (arg2 == NULL) SWIG_fail;
19064 temp2 = true;
19065 }
19066 if (obj2) {
19067 {
19068 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
19069 if (SWIG_arg_fail(3)) SWIG_fail;
19070 }
19071 }
19072 {
19073 PyThreadState* __tstate = wxPyBeginAllowThreads();
19074 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
19075
19076 wxPyEndAllowThreads(__tstate);
19077 if (PyErr_Occurred()) SWIG_fail;
19078 }
19079 {
19080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19081 }
19082 {
19083 if (temp2)
19084 delete arg2;
19085 }
19086 return resultobj;
19087 fail:
19088 {
19089 if (temp2)
19090 delete arg2;
19091 }
19092 return NULL;
19093 }
19094
19095
19096 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
19097 PyObject *resultobj = NULL;
19098 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19099 wxString *arg2 = 0 ;
19100 bool result;
19101 bool temp2 = false ;
19102 PyObject * obj0 = 0 ;
19103 PyObject * obj1 = 0 ;
19104 char *kwnames[] = {
19105 (char *) "self",(char *) "key", NULL
19106 };
19107
19108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
19109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19110 if (SWIG_arg_fail(1)) SWIG_fail;
19111 {
19112 arg2 = wxString_in_helper(obj1);
19113 if (arg2 == NULL) SWIG_fail;
19114 temp2 = true;
19115 }
19116 {
19117 PyThreadState* __tstate = wxPyBeginAllowThreads();
19118 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
19119
19120 wxPyEndAllowThreads(__tstate);
19121 if (PyErr_Occurred()) SWIG_fail;
19122 }
19123 {
19124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19125 }
19126 {
19127 if (temp2)
19128 delete arg2;
19129 }
19130 return resultobj;
19131 fail:
19132 {
19133 if (temp2)
19134 delete arg2;
19135 }
19136 return NULL;
19137 }
19138
19139
19140 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
19141 PyObject *resultobj = NULL;
19142 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19143 bool result;
19144 PyObject * obj0 = 0 ;
19145 char *kwnames[] = {
19146 (char *) "self", NULL
19147 };
19148
19149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
19150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19151 if (SWIG_arg_fail(1)) SWIG_fail;
19152 {
19153 PyThreadState* __tstate = wxPyBeginAllowThreads();
19154 result = (bool)(arg1)->DeleteAll();
19155
19156 wxPyEndAllowThreads(__tstate);
19157 if (PyErr_Occurred()) SWIG_fail;
19158 }
19159 {
19160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19161 }
19162 return resultobj;
19163 fail:
19164 return NULL;
19165 }
19166
19167
19168 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19169 PyObject *resultobj = NULL;
19170 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19171 bool arg2 = (bool) true ;
19172 PyObject * obj0 = 0 ;
19173 PyObject * obj1 = 0 ;
19174 char *kwnames[] = {
19175 (char *) "self",(char *) "doIt", NULL
19176 };
19177
19178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
19179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19180 if (SWIG_arg_fail(1)) SWIG_fail;
19181 if (obj1) {
19182 {
19183 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19184 if (SWIG_arg_fail(2)) SWIG_fail;
19185 }
19186 }
19187 {
19188 PyThreadState* __tstate = wxPyBeginAllowThreads();
19189 (arg1)->SetExpandEnvVars(arg2);
19190
19191 wxPyEndAllowThreads(__tstate);
19192 if (PyErr_Occurred()) SWIG_fail;
19193 }
19194 Py_INCREF(Py_None); resultobj = Py_None;
19195 return resultobj;
19196 fail:
19197 return NULL;
19198 }
19199
19200
19201 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19202 PyObject *resultobj = NULL;
19203 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19204 bool result;
19205 PyObject * obj0 = 0 ;
19206 char *kwnames[] = {
19207 (char *) "self", NULL
19208 };
19209
19210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
19211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19212 if (SWIG_arg_fail(1)) SWIG_fail;
19213 {
19214 PyThreadState* __tstate = wxPyBeginAllowThreads();
19215 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
19216
19217 wxPyEndAllowThreads(__tstate);
19218 if (PyErr_Occurred()) SWIG_fail;
19219 }
19220 {
19221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19222 }
19223 return resultobj;
19224 fail:
19225 return NULL;
19226 }
19227
19228
19229 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
19230 PyObject *resultobj = NULL;
19231 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19232 bool arg2 = (bool) true ;
19233 PyObject * obj0 = 0 ;
19234 PyObject * obj1 = 0 ;
19235 char *kwnames[] = {
19236 (char *) "self",(char *) "doIt", NULL
19237 };
19238
19239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",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 if (obj1) {
19243 {
19244 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19245 if (SWIG_arg_fail(2)) SWIG_fail;
19246 }
19247 }
19248 {
19249 PyThreadState* __tstate = wxPyBeginAllowThreads();
19250 (arg1)->SetRecordDefaults(arg2);
19251
19252 wxPyEndAllowThreads(__tstate);
19253 if (PyErr_Occurred()) SWIG_fail;
19254 }
19255 Py_INCREF(Py_None); resultobj = Py_None;
19256 return resultobj;
19257 fail:
19258 return NULL;
19259 }
19260
19261
19262 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
19263 PyObject *resultobj = NULL;
19264 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19265 bool result;
19266 PyObject * obj0 = 0 ;
19267 char *kwnames[] = {
19268 (char *) "self", NULL
19269 };
19270
19271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
19272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19273 if (SWIG_arg_fail(1)) SWIG_fail;
19274 {
19275 PyThreadState* __tstate = wxPyBeginAllowThreads();
19276 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
19277
19278 wxPyEndAllowThreads(__tstate);
19279 if (PyErr_Occurred()) SWIG_fail;
19280 }
19281 {
19282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19283 }
19284 return resultobj;
19285 fail:
19286 return NULL;
19287 }
19288
19289
19290 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19291 PyObject *resultobj = NULL;
19292 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19293 wxString *arg2 = 0 ;
19294 wxString result;
19295 bool temp2 = false ;
19296 PyObject * obj0 = 0 ;
19297 PyObject * obj1 = 0 ;
19298 char *kwnames[] = {
19299 (char *) "self",(char *) "str", NULL
19300 };
19301
19302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
19303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19304 if (SWIG_arg_fail(1)) SWIG_fail;
19305 {
19306 arg2 = wxString_in_helper(obj1);
19307 if (arg2 == NULL) SWIG_fail;
19308 temp2 = true;
19309 }
19310 {
19311 PyThreadState* __tstate = wxPyBeginAllowThreads();
19312 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
19313
19314 wxPyEndAllowThreads(__tstate);
19315 if (PyErr_Occurred()) SWIG_fail;
19316 }
19317 {
19318 #if wxUSE_UNICODE
19319 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19320 #else
19321 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19322 #endif
19323 }
19324 {
19325 if (temp2)
19326 delete arg2;
19327 }
19328 return resultobj;
19329 fail:
19330 {
19331 if (temp2)
19332 delete arg2;
19333 }
19334 return NULL;
19335 }
19336
19337
19338 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
19339 PyObject *resultobj = NULL;
19340 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19341 wxString result;
19342 PyObject * obj0 = 0 ;
19343 char *kwnames[] = {
19344 (char *) "self", NULL
19345 };
19346
19347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
19348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19349 if (SWIG_arg_fail(1)) SWIG_fail;
19350 {
19351 PyThreadState* __tstate = wxPyBeginAllowThreads();
19352 result = ((wxConfigBase const *)arg1)->GetAppName();
19353
19354 wxPyEndAllowThreads(__tstate);
19355 if (PyErr_Occurred()) SWIG_fail;
19356 }
19357 {
19358 #if wxUSE_UNICODE
19359 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19360 #else
19361 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19362 #endif
19363 }
19364 return resultobj;
19365 fail:
19366 return NULL;
19367 }
19368
19369
19370 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
19371 PyObject *resultobj = NULL;
19372 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19373 wxString result;
19374 PyObject * obj0 = 0 ;
19375 char *kwnames[] = {
19376 (char *) "self", NULL
19377 };
19378
19379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
19380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19381 if (SWIG_arg_fail(1)) SWIG_fail;
19382 {
19383 PyThreadState* __tstate = wxPyBeginAllowThreads();
19384 result = ((wxConfigBase const *)arg1)->GetVendorName();
19385
19386 wxPyEndAllowThreads(__tstate);
19387 if (PyErr_Occurred()) SWIG_fail;
19388 }
19389 {
19390 #if wxUSE_UNICODE
19391 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19392 #else
19393 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19394 #endif
19395 }
19396 return resultobj;
19397 fail:
19398 return NULL;
19399 }
19400
19401
19402 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
19403 PyObject *resultobj = NULL;
19404 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19405 wxString *arg2 = 0 ;
19406 bool temp2 = false ;
19407 PyObject * obj0 = 0 ;
19408 PyObject * obj1 = 0 ;
19409 char *kwnames[] = {
19410 (char *) "self",(char *) "appName", NULL
19411 };
19412
19413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
19414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19415 if (SWIG_arg_fail(1)) SWIG_fail;
19416 {
19417 arg2 = wxString_in_helper(obj1);
19418 if (arg2 == NULL) SWIG_fail;
19419 temp2 = true;
19420 }
19421 {
19422 PyThreadState* __tstate = wxPyBeginAllowThreads();
19423 (arg1)->SetAppName((wxString const &)*arg2);
19424
19425 wxPyEndAllowThreads(__tstate);
19426 if (PyErr_Occurred()) SWIG_fail;
19427 }
19428 Py_INCREF(Py_None); resultobj = Py_None;
19429 {
19430 if (temp2)
19431 delete arg2;
19432 }
19433 return resultobj;
19434 fail:
19435 {
19436 if (temp2)
19437 delete arg2;
19438 }
19439 return NULL;
19440 }
19441
19442
19443 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
19444 PyObject *resultobj = NULL;
19445 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19446 wxString *arg2 = 0 ;
19447 bool temp2 = false ;
19448 PyObject * obj0 = 0 ;
19449 PyObject * obj1 = 0 ;
19450 char *kwnames[] = {
19451 (char *) "self",(char *) "vendorName", NULL
19452 };
19453
19454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
19455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19456 if (SWIG_arg_fail(1)) SWIG_fail;
19457 {
19458 arg2 = wxString_in_helper(obj1);
19459 if (arg2 == NULL) SWIG_fail;
19460 temp2 = true;
19461 }
19462 {
19463 PyThreadState* __tstate = wxPyBeginAllowThreads();
19464 (arg1)->SetVendorName((wxString const &)*arg2);
19465
19466 wxPyEndAllowThreads(__tstate);
19467 if (PyErr_Occurred()) SWIG_fail;
19468 }
19469 Py_INCREF(Py_None); resultobj = Py_None;
19470 {
19471 if (temp2)
19472 delete arg2;
19473 }
19474 return resultobj;
19475 fail:
19476 {
19477 if (temp2)
19478 delete arg2;
19479 }
19480 return NULL;
19481 }
19482
19483
19484 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
19485 PyObject *resultobj = NULL;
19486 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19487 long arg2 ;
19488 PyObject * obj0 = 0 ;
19489 PyObject * obj1 = 0 ;
19490 char *kwnames[] = {
19491 (char *) "self",(char *) "style", NULL
19492 };
19493
19494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
19495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19496 if (SWIG_arg_fail(1)) SWIG_fail;
19497 {
19498 arg2 = static_cast<long >(SWIG_As_long(obj1));
19499 if (SWIG_arg_fail(2)) SWIG_fail;
19500 }
19501 {
19502 PyThreadState* __tstate = wxPyBeginAllowThreads();
19503 (arg1)->SetStyle(arg2);
19504
19505 wxPyEndAllowThreads(__tstate);
19506 if (PyErr_Occurred()) SWIG_fail;
19507 }
19508 Py_INCREF(Py_None); resultobj = Py_None;
19509 return resultobj;
19510 fail:
19511 return NULL;
19512 }
19513
19514
19515 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
19516 PyObject *resultobj = NULL;
19517 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19518 long result;
19519 PyObject * obj0 = 0 ;
19520 char *kwnames[] = {
19521 (char *) "self", NULL
19522 };
19523
19524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
19525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19526 if (SWIG_arg_fail(1)) SWIG_fail;
19527 {
19528 PyThreadState* __tstate = wxPyBeginAllowThreads();
19529 result = (long)((wxConfigBase const *)arg1)->GetStyle();
19530
19531 wxPyEndAllowThreads(__tstate);
19532 if (PyErr_Occurred()) SWIG_fail;
19533 }
19534 {
19535 resultobj = SWIG_From_long(static_cast<long >(result));
19536 }
19537 return resultobj;
19538 fail:
19539 return NULL;
19540 }
19541
19542
19543 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
19544 PyObject *obj;
19545 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19546 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
19547 Py_INCREF(obj);
19548 return Py_BuildValue((char *)"");
19549 }
19550 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
19551 PyObject *resultobj = NULL;
19552 wxString const &arg1_defvalue = wxPyEmptyString ;
19553 wxString *arg1 = (wxString *) &arg1_defvalue ;
19554 wxString const &arg2_defvalue = wxPyEmptyString ;
19555 wxString *arg2 = (wxString *) &arg2_defvalue ;
19556 wxString const &arg3_defvalue = wxPyEmptyString ;
19557 wxString *arg3 = (wxString *) &arg3_defvalue ;
19558 wxString const &arg4_defvalue = wxPyEmptyString ;
19559 wxString *arg4 = (wxString *) &arg4_defvalue ;
19560 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
19561 wxConfig *result;
19562 bool temp1 = false ;
19563 bool temp2 = false ;
19564 bool temp3 = false ;
19565 bool temp4 = false ;
19566 PyObject * obj0 = 0 ;
19567 PyObject * obj1 = 0 ;
19568 PyObject * obj2 = 0 ;
19569 PyObject * obj3 = 0 ;
19570 PyObject * obj4 = 0 ;
19571 char *kwnames[] = {
19572 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
19573 };
19574
19575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19576 if (obj0) {
19577 {
19578 arg1 = wxString_in_helper(obj0);
19579 if (arg1 == NULL) SWIG_fail;
19580 temp1 = true;
19581 }
19582 }
19583 if (obj1) {
19584 {
19585 arg2 = wxString_in_helper(obj1);
19586 if (arg2 == NULL) SWIG_fail;
19587 temp2 = true;
19588 }
19589 }
19590 if (obj2) {
19591 {
19592 arg3 = wxString_in_helper(obj2);
19593 if (arg3 == NULL) SWIG_fail;
19594 temp3 = true;
19595 }
19596 }
19597 if (obj3) {
19598 {
19599 arg4 = wxString_in_helper(obj3);
19600 if (arg4 == NULL) SWIG_fail;
19601 temp4 = true;
19602 }
19603 }
19604 if (obj4) {
19605 {
19606 arg5 = static_cast<long >(SWIG_As_long(obj4));
19607 if (SWIG_arg_fail(5)) SWIG_fail;
19608 }
19609 }
19610 {
19611 PyThreadState* __tstate = wxPyBeginAllowThreads();
19612 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
19613
19614 wxPyEndAllowThreads(__tstate);
19615 if (PyErr_Occurred()) SWIG_fail;
19616 }
19617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
19618 {
19619 if (temp1)
19620 delete arg1;
19621 }
19622 {
19623 if (temp2)
19624 delete arg2;
19625 }
19626 {
19627 if (temp3)
19628 delete arg3;
19629 }
19630 {
19631 if (temp4)
19632 delete arg4;
19633 }
19634 return resultobj;
19635 fail:
19636 {
19637 if (temp1)
19638 delete arg1;
19639 }
19640 {
19641 if (temp2)
19642 delete arg2;
19643 }
19644 {
19645 if (temp3)
19646 delete arg3;
19647 }
19648 {
19649 if (temp4)
19650 delete arg4;
19651 }
19652 return NULL;
19653 }
19654
19655
19656 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
19657 PyObject *resultobj = NULL;
19658 wxConfig *arg1 = (wxConfig *) 0 ;
19659 PyObject * obj0 = 0 ;
19660 char *kwnames[] = {
19661 (char *) "self", NULL
19662 };
19663
19664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
19665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
19666 if (SWIG_arg_fail(1)) SWIG_fail;
19667 {
19668 PyThreadState* __tstate = wxPyBeginAllowThreads();
19669 delete arg1;
19670
19671 wxPyEndAllowThreads(__tstate);
19672 if (PyErr_Occurred()) SWIG_fail;
19673 }
19674 Py_INCREF(Py_None); resultobj = Py_None;
19675 return resultobj;
19676 fail:
19677 return NULL;
19678 }
19679
19680
19681 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
19682 PyObject *obj;
19683 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19684 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
19685 Py_INCREF(obj);
19686 return Py_BuildValue((char *)"");
19687 }
19688 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
19689 PyObject *resultobj = NULL;
19690 wxString const &arg1_defvalue = wxPyEmptyString ;
19691 wxString *arg1 = (wxString *) &arg1_defvalue ;
19692 wxString const &arg2_defvalue = wxPyEmptyString ;
19693 wxString *arg2 = (wxString *) &arg2_defvalue ;
19694 wxString const &arg3_defvalue = wxPyEmptyString ;
19695 wxString *arg3 = (wxString *) &arg3_defvalue ;
19696 wxString const &arg4_defvalue = wxPyEmptyString ;
19697 wxString *arg4 = (wxString *) &arg4_defvalue ;
19698 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
19699 wxFileConfig *result;
19700 bool temp1 = false ;
19701 bool temp2 = false ;
19702 bool temp3 = false ;
19703 bool temp4 = false ;
19704 PyObject * obj0 = 0 ;
19705 PyObject * obj1 = 0 ;
19706 PyObject * obj2 = 0 ;
19707 PyObject * obj3 = 0 ;
19708 PyObject * obj4 = 0 ;
19709 char *kwnames[] = {
19710 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
19711 };
19712
19713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19714 if (obj0) {
19715 {
19716 arg1 = wxString_in_helper(obj0);
19717 if (arg1 == NULL) SWIG_fail;
19718 temp1 = true;
19719 }
19720 }
19721 if (obj1) {
19722 {
19723 arg2 = wxString_in_helper(obj1);
19724 if (arg2 == NULL) SWIG_fail;
19725 temp2 = true;
19726 }
19727 }
19728 if (obj2) {
19729 {
19730 arg3 = wxString_in_helper(obj2);
19731 if (arg3 == NULL) SWIG_fail;
19732 temp3 = true;
19733 }
19734 }
19735 if (obj3) {
19736 {
19737 arg4 = wxString_in_helper(obj3);
19738 if (arg4 == NULL) SWIG_fail;
19739 temp4 = true;
19740 }
19741 }
19742 if (obj4) {
19743 {
19744 arg5 = static_cast<long >(SWIG_As_long(obj4));
19745 if (SWIG_arg_fail(5)) SWIG_fail;
19746 }
19747 }
19748 {
19749 PyThreadState* __tstate = wxPyBeginAllowThreads();
19750 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
19751
19752 wxPyEndAllowThreads(__tstate);
19753 if (PyErr_Occurred()) SWIG_fail;
19754 }
19755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
19756 {
19757 if (temp1)
19758 delete arg1;
19759 }
19760 {
19761 if (temp2)
19762 delete arg2;
19763 }
19764 {
19765 if (temp3)
19766 delete arg3;
19767 }
19768 {
19769 if (temp4)
19770 delete arg4;
19771 }
19772 return resultobj;
19773 fail:
19774 {
19775 if (temp1)
19776 delete arg1;
19777 }
19778 {
19779 if (temp2)
19780 delete arg2;
19781 }
19782 {
19783 if (temp3)
19784 delete arg3;
19785 }
19786 {
19787 if (temp4)
19788 delete arg4;
19789 }
19790 return NULL;
19791 }
19792
19793
19794 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
19795 PyObject *resultobj = NULL;
19796 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
19797 PyObject * obj0 = 0 ;
19798 char *kwnames[] = {
19799 (char *) "self", NULL
19800 };
19801
19802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
19803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
19804 if (SWIG_arg_fail(1)) SWIG_fail;
19805 {
19806 PyThreadState* __tstate = wxPyBeginAllowThreads();
19807 delete arg1;
19808
19809 wxPyEndAllowThreads(__tstate);
19810 if (PyErr_Occurred()) SWIG_fail;
19811 }
19812 Py_INCREF(Py_None); resultobj = Py_None;
19813 return resultobj;
19814 fail:
19815 return NULL;
19816 }
19817
19818
19819 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
19820 PyObject *obj;
19821 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19822 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
19823 Py_INCREF(obj);
19824 return Py_BuildValue((char *)"");
19825 }
19826 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
19827 PyObject *resultobj = NULL;
19828 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19829 wxString *arg2 = 0 ;
19830 wxConfigPathChanger *result;
19831 bool temp2 = false ;
19832 PyObject * obj0 = 0 ;
19833 PyObject * obj1 = 0 ;
19834 char *kwnames[] = {
19835 (char *) "config",(char *) "entry", NULL
19836 };
19837
19838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
19839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
19840 if (SWIG_arg_fail(1)) SWIG_fail;
19841 {
19842 arg2 = wxString_in_helper(obj1);
19843 if (arg2 == NULL) SWIG_fail;
19844 temp2 = true;
19845 }
19846 {
19847 PyThreadState* __tstate = wxPyBeginAllowThreads();
19848 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
19849
19850 wxPyEndAllowThreads(__tstate);
19851 if (PyErr_Occurred()) SWIG_fail;
19852 }
19853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
19854 {
19855 if (temp2)
19856 delete arg2;
19857 }
19858 return resultobj;
19859 fail:
19860 {
19861 if (temp2)
19862 delete arg2;
19863 }
19864 return NULL;
19865 }
19866
19867
19868 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
19869 PyObject *resultobj = NULL;
19870 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
19871 PyObject * obj0 = 0 ;
19872 char *kwnames[] = {
19873 (char *) "self", NULL
19874 };
19875
19876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
19877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
19878 if (SWIG_arg_fail(1)) SWIG_fail;
19879 {
19880 PyThreadState* __tstate = wxPyBeginAllowThreads();
19881 delete arg1;
19882
19883 wxPyEndAllowThreads(__tstate);
19884 if (PyErr_Occurred()) SWIG_fail;
19885 }
19886 Py_INCREF(Py_None); resultobj = Py_None;
19887 return resultobj;
19888 fail:
19889 return NULL;
19890 }
19891
19892
19893 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
19894 PyObject *resultobj = NULL;
19895 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
19896 wxString *result;
19897 PyObject * obj0 = 0 ;
19898 char *kwnames[] = {
19899 (char *) "self", NULL
19900 };
19901
19902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
19903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
19904 if (SWIG_arg_fail(1)) SWIG_fail;
19905 {
19906 PyThreadState* __tstate = wxPyBeginAllowThreads();
19907 {
19908 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
19909 result = (wxString *) &_result_ref;
19910 }
19911
19912 wxPyEndAllowThreads(__tstate);
19913 if (PyErr_Occurred()) SWIG_fail;
19914 }
19915 {
19916 #if wxUSE_UNICODE
19917 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19918 #else
19919 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19920 #endif
19921 }
19922 return resultobj;
19923 fail:
19924 return NULL;
19925 }
19926
19927
19928 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
19929 PyObject *obj;
19930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19931 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
19932 Py_INCREF(obj);
19933 return Py_BuildValue((char *)"");
19934 }
19935 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
19936 PyObject *resultobj = NULL;
19937 wxString *arg1 = 0 ;
19938 wxString result;
19939 bool temp1 = false ;
19940 PyObject * obj0 = 0 ;
19941 char *kwnames[] = {
19942 (char *) "sz", NULL
19943 };
19944
19945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
19946 {
19947 arg1 = wxString_in_helper(obj0);
19948 if (arg1 == NULL) SWIG_fail;
19949 temp1 = true;
19950 }
19951 {
19952 PyThreadState* __tstate = wxPyBeginAllowThreads();
19953 result = wxExpandEnvVars((wxString const &)*arg1);
19954
19955 wxPyEndAllowThreads(__tstate);
19956 if (PyErr_Occurred()) SWIG_fail;
19957 }
19958 {
19959 #if wxUSE_UNICODE
19960 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19961 #else
19962 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19963 #endif
19964 }
19965 {
19966 if (temp1)
19967 delete arg1;
19968 }
19969 return resultobj;
19970 fail:
19971 {
19972 if (temp1)
19973 delete arg1;
19974 }
19975 return NULL;
19976 }
19977
19978
19979 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
19980 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
19981 return 1;
19982 }
19983
19984
19985 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19986 PyObject *pyobj = NULL;
19987
19988 {
19989 #if wxUSE_UNICODE
19990 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19991 #else
19992 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19993 #endif
19994 }
19995 return pyobj;
19996 }
19997
19998
19999 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
20000 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
20001 return 1;
20002 }
20003
20004
20005 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
20006 PyObject *pyobj = NULL;
20007
20008 {
20009 #if wxUSE_UNICODE
20010 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
20011 #else
20012 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
20013 #endif
20014 }
20015 return pyobj;
20016 }
20017
20018
20019 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
20020 PyObject *resultobj = NULL;
20021 wxDateTime::Country arg1 ;
20022 PyObject * obj0 = 0 ;
20023 char *kwnames[] = {
20024 (char *) "country", NULL
20025 };
20026
20027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
20028 {
20029 arg1 = static_cast<wxDateTime::Country >(SWIG_As_int(obj0));
20030 if (SWIG_arg_fail(1)) SWIG_fail;
20031 }
20032 {
20033 PyThreadState* __tstate = wxPyBeginAllowThreads();
20034 wxDateTime::SetCountry(arg1);
20035
20036 wxPyEndAllowThreads(__tstate);
20037 if (PyErr_Occurred()) SWIG_fail;
20038 }
20039 Py_INCREF(Py_None); resultobj = Py_None;
20040 return resultobj;
20041 fail:
20042 return NULL;
20043 }
20044
20045
20046 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
20047 PyObject *resultobj = NULL;
20048 wxDateTime::Country result;
20049 char *kwnames[] = {
20050 NULL
20051 };
20052
20053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
20054 {
20055 PyThreadState* __tstate = wxPyBeginAllowThreads();
20056 result = (wxDateTime::Country)wxDateTime::GetCountry();
20057
20058 wxPyEndAllowThreads(__tstate);
20059 if (PyErr_Occurred()) SWIG_fail;
20060 }
20061 resultobj = SWIG_From_int((result));
20062 return resultobj;
20063 fail:
20064 return NULL;
20065 }
20066
20067
20068 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
20069 PyObject *resultobj = NULL;
20070 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
20071 bool result;
20072 PyObject * obj0 = 0 ;
20073 char *kwnames[] = {
20074 (char *) "country", NULL
20075 };
20076
20077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
20078 if (obj0) {
20079 {
20080 arg1 = static_cast<wxDateTime::Country >(SWIG_As_int(obj0));
20081 if (SWIG_arg_fail(1)) SWIG_fail;
20082 }
20083 }
20084 {
20085 PyThreadState* __tstate = wxPyBeginAllowThreads();
20086 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
20087
20088 wxPyEndAllowThreads(__tstate);
20089 if (PyErr_Occurred()) SWIG_fail;
20090 }
20091 {
20092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20093 }
20094 return resultobj;
20095 fail:
20096 return NULL;
20097 }
20098
20099
20100 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
20101 PyObject *resultobj = NULL;
20102 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20103 int result;
20104 PyObject * obj0 = 0 ;
20105 char *kwnames[] = {
20106 (char *) "cal", NULL
20107 };
20108
20109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
20110 if (obj0) {
20111 {
20112 arg1 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj0));
20113 if (SWIG_arg_fail(1)) SWIG_fail;
20114 }
20115 }
20116 {
20117 PyThreadState* __tstate = wxPyBeginAllowThreads();
20118 result = (int)wxDateTime::GetCurrentYear(arg1);
20119
20120 wxPyEndAllowThreads(__tstate);
20121 if (PyErr_Occurred()) SWIG_fail;
20122 }
20123 {
20124 resultobj = SWIG_From_int(static_cast<int >(result));
20125 }
20126 return resultobj;
20127 fail:
20128 return NULL;
20129 }
20130
20131
20132 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
20133 PyObject *resultobj = NULL;
20134 int arg1 ;
20135 int result;
20136 PyObject * obj0 = 0 ;
20137 char *kwnames[] = {
20138 (char *) "year", NULL
20139 };
20140
20141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
20142 {
20143 arg1 = static_cast<int >(SWIG_As_int(obj0));
20144 if (SWIG_arg_fail(1)) SWIG_fail;
20145 }
20146 {
20147 PyThreadState* __tstate = wxPyBeginAllowThreads();
20148 result = (int)wxDateTime::ConvertYearToBC(arg1);
20149
20150 wxPyEndAllowThreads(__tstate);
20151 if (PyErr_Occurred()) SWIG_fail;
20152 }
20153 {
20154 resultobj = SWIG_From_int(static_cast<int >(result));
20155 }
20156 return resultobj;
20157 fail:
20158 return NULL;
20159 }
20160
20161
20162 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20163 PyObject *resultobj = NULL;
20164 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20165 wxDateTime::Month result;
20166 PyObject * obj0 = 0 ;
20167 char *kwnames[] = {
20168 (char *) "cal", NULL
20169 };
20170
20171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
20172 if (obj0) {
20173 {
20174 arg1 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj0));
20175 if (SWIG_arg_fail(1)) SWIG_fail;
20176 }
20177 }
20178 {
20179 PyThreadState* __tstate = wxPyBeginAllowThreads();
20180 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
20181
20182 wxPyEndAllowThreads(__tstate);
20183 if (PyErr_Occurred()) SWIG_fail;
20184 }
20185 resultobj = SWIG_From_int((result));
20186 return resultobj;
20187 fail:
20188 return NULL;
20189 }
20190
20191
20192 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
20193 PyObject *resultobj = NULL;
20194 int arg1 = (int) wxDateTime::Inv_Year ;
20195 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20196 bool result;
20197 PyObject * obj0 = 0 ;
20198 PyObject * obj1 = 0 ;
20199 char *kwnames[] = {
20200 (char *) "year",(char *) "cal", NULL
20201 };
20202
20203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
20204 if (obj0) {
20205 {
20206 arg1 = static_cast<int >(SWIG_As_int(obj0));
20207 if (SWIG_arg_fail(1)) SWIG_fail;
20208 }
20209 }
20210 if (obj1) {
20211 {
20212 arg2 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj1));
20213 if (SWIG_arg_fail(2)) SWIG_fail;
20214 }
20215 }
20216 {
20217 PyThreadState* __tstate = wxPyBeginAllowThreads();
20218 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
20219
20220 wxPyEndAllowThreads(__tstate);
20221 if (PyErr_Occurred()) SWIG_fail;
20222 }
20223 {
20224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20225 }
20226 return resultobj;
20227 fail:
20228 return NULL;
20229 }
20230
20231
20232 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
20233 PyObject *resultobj = NULL;
20234 int arg1 = (int) wxDateTime::Inv_Year ;
20235 int result;
20236 PyObject * obj0 = 0 ;
20237 char *kwnames[] = {
20238 (char *) "year", NULL
20239 };
20240
20241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
20242 if (obj0) {
20243 {
20244 arg1 = static_cast<int >(SWIG_As_int(obj0));
20245 if (SWIG_arg_fail(1)) SWIG_fail;
20246 }
20247 }
20248 {
20249 PyThreadState* __tstate = wxPyBeginAllowThreads();
20250 result = (int)wxDateTime::GetCentury(arg1);
20251
20252 wxPyEndAllowThreads(__tstate);
20253 if (PyErr_Occurred()) SWIG_fail;
20254 }
20255 {
20256 resultobj = SWIG_From_int(static_cast<int >(result));
20257 }
20258 return resultobj;
20259 fail:
20260 return NULL;
20261 }
20262
20263
20264 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
20265 PyObject *resultobj = NULL;
20266 int arg1 ;
20267 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20268 int result;
20269 PyObject * obj0 = 0 ;
20270 PyObject * obj1 = 0 ;
20271 char *kwnames[] = {
20272 (char *) "year",(char *) "cal", NULL
20273 };
20274
20275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
20276 {
20277 arg1 = static_cast<int >(SWIG_As_int(obj0));
20278 if (SWIG_arg_fail(1)) SWIG_fail;
20279 }
20280 if (obj1) {
20281 {
20282 arg2 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj1));
20283 if (SWIG_arg_fail(2)) SWIG_fail;
20284 }
20285 }
20286 {
20287 PyThreadState* __tstate = wxPyBeginAllowThreads();
20288 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
20289
20290 wxPyEndAllowThreads(__tstate);
20291 if (PyErr_Occurred()) SWIG_fail;
20292 }
20293 {
20294 resultobj = SWIG_From_int(static_cast<int >(result));
20295 }
20296 return resultobj;
20297 fail:
20298 return NULL;
20299 }
20300
20301
20302 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20303 PyObject *resultobj = NULL;
20304 wxDateTime::Month arg1 ;
20305 int arg2 = (int) wxDateTime::Inv_Year ;
20306 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
20307 int result;
20308 PyObject * obj0 = 0 ;
20309 PyObject * obj1 = 0 ;
20310 PyObject * obj2 = 0 ;
20311 char *kwnames[] = {
20312 (char *) "month",(char *) "year",(char *) "cal", NULL
20313 };
20314
20315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
20316 {
20317 arg1 = static_cast<wxDateTime::Month >(SWIG_As_int(obj0));
20318 if (SWIG_arg_fail(1)) SWIG_fail;
20319 }
20320 if (obj1) {
20321 {
20322 arg2 = static_cast<int >(SWIG_As_int(obj1));
20323 if (SWIG_arg_fail(2)) SWIG_fail;
20324 }
20325 }
20326 if (obj2) {
20327 {
20328 arg3 = static_cast<wxDateTime::Calendar >(SWIG_As_int(obj2));
20329 if (SWIG_arg_fail(3)) SWIG_fail;
20330 }
20331 }
20332 {
20333 PyThreadState* __tstate = wxPyBeginAllowThreads();
20334 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
20335
20336 wxPyEndAllowThreads(__tstate);
20337 if (PyErr_Occurred()) SWIG_fail;
20338 }
20339 {
20340 resultobj = SWIG_From_int(static_cast<int >(result));
20341 }
20342 return resultobj;
20343 fail:
20344 return NULL;
20345 }
20346
20347
20348 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
20349 PyObject *resultobj = NULL;
20350 wxDateTime::Month arg1 ;
20351 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
20352 wxString result;
20353 PyObject * obj0 = 0 ;
20354 PyObject * obj1 = 0 ;
20355 char *kwnames[] = {
20356 (char *) "month",(char *) "flags", NULL
20357 };
20358
20359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
20360 {
20361 arg1 = static_cast<wxDateTime::Month >(SWIG_As_int(obj0));
20362 if (SWIG_arg_fail(1)) SWIG_fail;
20363 }
20364 if (obj1) {
20365 {
20366 arg2 = static_cast<wxDateTime::NameFlags >(SWIG_As_int(obj1));
20367 if (SWIG_arg_fail(2)) SWIG_fail;
20368 }
20369 }
20370 {
20371 PyThreadState* __tstate = wxPyBeginAllowThreads();
20372 result = wxDateTime::GetMonthName(arg1,arg2);
20373
20374 wxPyEndAllowThreads(__tstate);
20375 if (PyErr_Occurred()) SWIG_fail;
20376 }
20377 {
20378 #if wxUSE_UNICODE
20379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20380 #else
20381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20382 #endif
20383 }
20384 return resultobj;
20385 fail:
20386 return NULL;
20387 }
20388
20389
20390 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
20391 PyObject *resultobj = NULL;
20392 wxDateTime::WeekDay arg1 ;
20393 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
20394 wxString result;
20395 PyObject * obj0 = 0 ;
20396 PyObject * obj1 = 0 ;
20397 char *kwnames[] = {
20398 (char *) "weekday",(char *) "flags", NULL
20399 };
20400
20401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
20402 {
20403 arg1 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj0));
20404 if (SWIG_arg_fail(1)) SWIG_fail;
20405 }
20406 if (obj1) {
20407 {
20408 arg2 = static_cast<wxDateTime::NameFlags >(SWIG_As_int(obj1));
20409 if (SWIG_arg_fail(2)) SWIG_fail;
20410 }
20411 }
20412 {
20413 PyThreadState* __tstate = wxPyBeginAllowThreads();
20414 result = wxDateTime::GetWeekDayName(arg1,arg2);
20415
20416 wxPyEndAllowThreads(__tstate);
20417 if (PyErr_Occurred()) SWIG_fail;
20418 }
20419 {
20420 #if wxUSE_UNICODE
20421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20422 #else
20423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20424 #endif
20425 }
20426 return resultobj;
20427 fail:
20428 return NULL;
20429 }
20430
20431
20432 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
20433 PyObject *resultobj = NULL;
20434 PyObject *result;
20435 char *kwnames[] = {
20436 NULL
20437 };
20438
20439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
20440 {
20441 PyThreadState* __tstate = wxPyBeginAllowThreads();
20442 result = (PyObject *)wxDateTime_GetAmPmStrings();
20443
20444 wxPyEndAllowThreads(__tstate);
20445 if (PyErr_Occurred()) SWIG_fail;
20446 }
20447 resultobj = result;
20448 return resultobj;
20449 fail:
20450 return NULL;
20451 }
20452
20453
20454 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
20455 PyObject *resultobj = NULL;
20456 int arg1 = (int) wxDateTime::Inv_Year ;
20457 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20458 bool result;
20459 PyObject * obj0 = 0 ;
20460 PyObject * obj1 = 0 ;
20461 char *kwnames[] = {
20462 (char *) "year",(char *) "country", NULL
20463 };
20464
20465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
20466 if (obj0) {
20467 {
20468 arg1 = static_cast<int >(SWIG_As_int(obj0));
20469 if (SWIG_arg_fail(1)) SWIG_fail;
20470 }
20471 }
20472 if (obj1) {
20473 {
20474 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
20475 if (SWIG_arg_fail(2)) SWIG_fail;
20476 }
20477 }
20478 {
20479 PyThreadState* __tstate = wxPyBeginAllowThreads();
20480 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
20481
20482 wxPyEndAllowThreads(__tstate);
20483 if (PyErr_Occurred()) SWIG_fail;
20484 }
20485 {
20486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20487 }
20488 return resultobj;
20489 fail:
20490 return NULL;
20491 }
20492
20493
20494 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
20495 PyObject *resultobj = NULL;
20496 int arg1 = (int) wxDateTime::Inv_Year ;
20497 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20498 wxDateTime result;
20499 PyObject * obj0 = 0 ;
20500 PyObject * obj1 = 0 ;
20501 char *kwnames[] = {
20502 (char *) "year",(char *) "country", NULL
20503 };
20504
20505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
20506 if (obj0) {
20507 {
20508 arg1 = static_cast<int >(SWIG_As_int(obj0));
20509 if (SWIG_arg_fail(1)) SWIG_fail;
20510 }
20511 }
20512 if (obj1) {
20513 {
20514 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
20515 if (SWIG_arg_fail(2)) SWIG_fail;
20516 }
20517 }
20518 {
20519 PyThreadState* __tstate = wxPyBeginAllowThreads();
20520 result = wxDateTime::GetBeginDST(arg1,arg2);
20521
20522 wxPyEndAllowThreads(__tstate);
20523 if (PyErr_Occurred()) SWIG_fail;
20524 }
20525 {
20526 wxDateTime * resultptr;
20527 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20528 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20529 }
20530 return resultobj;
20531 fail:
20532 return NULL;
20533 }
20534
20535
20536 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
20537 PyObject *resultobj = NULL;
20538 int arg1 = (int) wxDateTime::Inv_Year ;
20539 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20540 wxDateTime result;
20541 PyObject * obj0 = 0 ;
20542 PyObject * obj1 = 0 ;
20543 char *kwnames[] = {
20544 (char *) "year",(char *) "country", NULL
20545 };
20546
20547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
20548 if (obj0) {
20549 {
20550 arg1 = static_cast<int >(SWIG_As_int(obj0));
20551 if (SWIG_arg_fail(1)) SWIG_fail;
20552 }
20553 }
20554 if (obj1) {
20555 {
20556 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
20557 if (SWIG_arg_fail(2)) SWIG_fail;
20558 }
20559 }
20560 {
20561 PyThreadState* __tstate = wxPyBeginAllowThreads();
20562 result = wxDateTime::GetEndDST(arg1,arg2);
20563
20564 wxPyEndAllowThreads(__tstate);
20565 if (PyErr_Occurred()) SWIG_fail;
20566 }
20567 {
20568 wxDateTime * resultptr;
20569 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20570 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20571 }
20572 return resultobj;
20573 fail:
20574 return NULL;
20575 }
20576
20577
20578 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
20579 PyObject *resultobj = NULL;
20580 wxDateTime result;
20581 char *kwnames[] = {
20582 NULL
20583 };
20584
20585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
20586 {
20587 PyThreadState* __tstate = wxPyBeginAllowThreads();
20588 result = wxDateTime::Now();
20589
20590 wxPyEndAllowThreads(__tstate);
20591 if (PyErr_Occurred()) SWIG_fail;
20592 }
20593 {
20594 wxDateTime * resultptr;
20595 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20597 }
20598 return resultobj;
20599 fail:
20600 return NULL;
20601 }
20602
20603
20604 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
20605 PyObject *resultobj = NULL;
20606 wxDateTime result;
20607 char *kwnames[] = {
20608 NULL
20609 };
20610
20611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
20612 {
20613 PyThreadState* __tstate = wxPyBeginAllowThreads();
20614 result = wxDateTime::UNow();
20615
20616 wxPyEndAllowThreads(__tstate);
20617 if (PyErr_Occurred()) SWIG_fail;
20618 }
20619 {
20620 wxDateTime * resultptr;
20621 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20622 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20623 }
20624 return resultobj;
20625 fail:
20626 return NULL;
20627 }
20628
20629
20630 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
20631 PyObject *resultobj = NULL;
20632 wxDateTime result;
20633 char *kwnames[] = {
20634 NULL
20635 };
20636
20637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
20638 {
20639 PyThreadState* __tstate = wxPyBeginAllowThreads();
20640 result = wxDateTime::Today();
20641
20642 wxPyEndAllowThreads(__tstate);
20643 if (PyErr_Occurred()) SWIG_fail;
20644 }
20645 {
20646 wxDateTime * resultptr;
20647 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
20648 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20649 }
20650 return resultobj;
20651 fail:
20652 return NULL;
20653 }
20654
20655
20656 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20657 PyObject *resultobj = NULL;
20658 wxDateTime *result;
20659 char *kwnames[] = {
20660 NULL
20661 };
20662
20663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
20664 {
20665 PyThreadState* __tstate = wxPyBeginAllowThreads();
20666 result = (wxDateTime *)new wxDateTime();
20667
20668 wxPyEndAllowThreads(__tstate);
20669 if (PyErr_Occurred()) SWIG_fail;
20670 }
20671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20672 return resultobj;
20673 fail:
20674 return NULL;
20675 }
20676
20677
20678 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
20679 PyObject *resultobj = NULL;
20680 time_t arg1 ;
20681 wxDateTime *result;
20682 PyObject * obj0 = 0 ;
20683 char *kwnames[] = {
20684 (char *) "timet", NULL
20685 };
20686
20687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
20688 {
20689 arg1 = static_cast<time_t >(SWIG_As_unsigned_SS_int(obj0));
20690 if (SWIG_arg_fail(1)) SWIG_fail;
20691 }
20692 {
20693 PyThreadState* __tstate = wxPyBeginAllowThreads();
20694 result = (wxDateTime *)new wxDateTime(arg1);
20695
20696 wxPyEndAllowThreads(__tstate);
20697 if (PyErr_Occurred()) SWIG_fail;
20698 }
20699 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20700 return resultobj;
20701 fail:
20702 return NULL;
20703 }
20704
20705
20706 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20707 PyObject *resultobj = NULL;
20708 double arg1 ;
20709 wxDateTime *result;
20710 PyObject * obj0 = 0 ;
20711 char *kwnames[] = {
20712 (char *) "jdn", NULL
20713 };
20714
20715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
20716 {
20717 arg1 = static_cast<double >(SWIG_As_double(obj0));
20718 if (SWIG_arg_fail(1)) SWIG_fail;
20719 }
20720 {
20721 PyThreadState* __tstate = wxPyBeginAllowThreads();
20722 result = (wxDateTime *)new wxDateTime(arg1);
20723
20724 wxPyEndAllowThreads(__tstate);
20725 if (PyErr_Occurred()) SWIG_fail;
20726 }
20727 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20728 return resultobj;
20729 fail:
20730 return NULL;
20731 }
20732
20733
20734 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20735 PyObject *resultobj = NULL;
20736 int arg1 ;
20737 int arg2 = (int) 0 ;
20738 int arg3 = (int) 0 ;
20739 int arg4 = (int) 0 ;
20740 wxDateTime *result;
20741 PyObject * obj0 = 0 ;
20742 PyObject * obj1 = 0 ;
20743 PyObject * obj2 = 0 ;
20744 PyObject * obj3 = 0 ;
20745 char *kwnames[] = {
20746 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20747 };
20748
20749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20750 {
20751 arg1 = static_cast<int >(SWIG_As_int(obj0));
20752 if (SWIG_arg_fail(1)) SWIG_fail;
20753 }
20754 if (obj1) {
20755 {
20756 arg2 = static_cast<int >(SWIG_As_int(obj1));
20757 if (SWIG_arg_fail(2)) SWIG_fail;
20758 }
20759 }
20760 if (obj2) {
20761 {
20762 arg3 = static_cast<int >(SWIG_As_int(obj2));
20763 if (SWIG_arg_fail(3)) SWIG_fail;
20764 }
20765 }
20766 if (obj3) {
20767 {
20768 arg4 = static_cast<int >(SWIG_As_int(obj3));
20769 if (SWIG_arg_fail(4)) SWIG_fail;
20770 }
20771 }
20772 {
20773 PyThreadState* __tstate = wxPyBeginAllowThreads();
20774 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
20775
20776 wxPyEndAllowThreads(__tstate);
20777 if (PyErr_Occurred()) SWIG_fail;
20778 }
20779 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20780 return resultobj;
20781 fail:
20782 return NULL;
20783 }
20784
20785
20786 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
20787 PyObject *resultobj = NULL;
20788 int arg1 ;
20789 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20790 int arg3 = (int) wxDateTime::Inv_Year ;
20791 int arg4 = (int) 0 ;
20792 int arg5 = (int) 0 ;
20793 int arg6 = (int) 0 ;
20794 int arg7 = (int) 0 ;
20795 wxDateTime *result;
20796 PyObject * obj0 = 0 ;
20797 PyObject * obj1 = 0 ;
20798 PyObject * obj2 = 0 ;
20799 PyObject * obj3 = 0 ;
20800 PyObject * obj4 = 0 ;
20801 PyObject * obj5 = 0 ;
20802 PyObject * obj6 = 0 ;
20803 char *kwnames[] = {
20804 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20805 };
20806
20807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
20808 {
20809 arg1 = static_cast<int >(SWIG_As_int(obj0));
20810 if (SWIG_arg_fail(1)) SWIG_fail;
20811 }
20812 if (obj1) {
20813 {
20814 arg2 = static_cast<wxDateTime::Month >(SWIG_As_int(obj1));
20815 if (SWIG_arg_fail(2)) SWIG_fail;
20816 }
20817 }
20818 if (obj2) {
20819 {
20820 arg3 = static_cast<int >(SWIG_As_int(obj2));
20821 if (SWIG_arg_fail(3)) SWIG_fail;
20822 }
20823 }
20824 if (obj3) {
20825 {
20826 arg4 = static_cast<int >(SWIG_As_int(obj3));
20827 if (SWIG_arg_fail(4)) SWIG_fail;
20828 }
20829 }
20830 if (obj4) {
20831 {
20832 arg5 = static_cast<int >(SWIG_As_int(obj4));
20833 if (SWIG_arg_fail(5)) SWIG_fail;
20834 }
20835 }
20836 if (obj5) {
20837 {
20838 arg6 = static_cast<int >(SWIG_As_int(obj5));
20839 if (SWIG_arg_fail(6)) SWIG_fail;
20840 }
20841 }
20842 if (obj6) {
20843 {
20844 arg7 = static_cast<int >(SWIG_As_int(obj6));
20845 if (SWIG_arg_fail(7)) SWIG_fail;
20846 }
20847 }
20848 {
20849 PyThreadState* __tstate = wxPyBeginAllowThreads();
20850 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
20851
20852 wxPyEndAllowThreads(__tstate);
20853 if (PyErr_Occurred()) SWIG_fail;
20854 }
20855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
20856 return resultobj;
20857 fail:
20858 return NULL;
20859 }
20860
20861
20862 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20863 PyObject *resultobj = NULL;
20864 wxDateTime *arg1 = (wxDateTime *) 0 ;
20865 PyObject * obj0 = 0 ;
20866 char *kwnames[] = {
20867 (char *) "self", NULL
20868 };
20869
20870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
20871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20872 if (SWIG_arg_fail(1)) SWIG_fail;
20873 {
20874 PyThreadState* __tstate = wxPyBeginAllowThreads();
20875 delete arg1;
20876
20877 wxPyEndAllowThreads(__tstate);
20878 if (PyErr_Occurred()) SWIG_fail;
20879 }
20880 Py_INCREF(Py_None); resultobj = Py_None;
20881 return resultobj;
20882 fail:
20883 return NULL;
20884 }
20885
20886
20887 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
20888 PyObject *resultobj = NULL;
20889 wxDateTime *arg1 = (wxDateTime *) 0 ;
20890 wxDateTime *result;
20891 PyObject * obj0 = 0 ;
20892 char *kwnames[] = {
20893 (char *) "self", NULL
20894 };
20895
20896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
20897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20898 if (SWIG_arg_fail(1)) SWIG_fail;
20899 {
20900 PyThreadState* __tstate = wxPyBeginAllowThreads();
20901 {
20902 wxDateTime &_result_ref = (arg1)->SetToCurrent();
20903 result = (wxDateTime *) &_result_ref;
20904 }
20905
20906 wxPyEndAllowThreads(__tstate);
20907 if (PyErr_Occurred()) SWIG_fail;
20908 }
20909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20910 return resultobj;
20911 fail:
20912 return NULL;
20913 }
20914
20915
20916 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
20917 PyObject *resultobj = NULL;
20918 wxDateTime *arg1 = (wxDateTime *) 0 ;
20919 time_t arg2 ;
20920 wxDateTime *result;
20921 PyObject * obj0 = 0 ;
20922 PyObject * obj1 = 0 ;
20923 char *kwnames[] = {
20924 (char *) "self",(char *) "timet", NULL
20925 };
20926
20927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
20928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20929 if (SWIG_arg_fail(1)) SWIG_fail;
20930 {
20931 arg2 = static_cast<time_t >(SWIG_As_unsigned_SS_int(obj1));
20932 if (SWIG_arg_fail(2)) SWIG_fail;
20933 }
20934 {
20935 PyThreadState* __tstate = wxPyBeginAllowThreads();
20936 {
20937 wxDateTime &_result_ref = (arg1)->Set(arg2);
20938 result = (wxDateTime *) &_result_ref;
20939 }
20940
20941 wxPyEndAllowThreads(__tstate);
20942 if (PyErr_Occurred()) SWIG_fail;
20943 }
20944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20945 return resultobj;
20946 fail:
20947 return NULL;
20948 }
20949
20950
20951 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20952 PyObject *resultobj = NULL;
20953 wxDateTime *arg1 = (wxDateTime *) 0 ;
20954 double arg2 ;
20955 wxDateTime *result;
20956 PyObject * obj0 = 0 ;
20957 PyObject * obj1 = 0 ;
20958 char *kwnames[] = {
20959 (char *) "self",(char *) "jdn", NULL
20960 };
20961
20962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
20963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20964 if (SWIG_arg_fail(1)) SWIG_fail;
20965 {
20966 arg2 = static_cast<double >(SWIG_As_double(obj1));
20967 if (SWIG_arg_fail(2)) SWIG_fail;
20968 }
20969 {
20970 PyThreadState* __tstate = wxPyBeginAllowThreads();
20971 {
20972 wxDateTime &_result_ref = (arg1)->Set(arg2);
20973 result = (wxDateTime *) &_result_ref;
20974 }
20975
20976 wxPyEndAllowThreads(__tstate);
20977 if (PyErr_Occurred()) SWIG_fail;
20978 }
20979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20980 return resultobj;
20981 fail:
20982 return NULL;
20983 }
20984
20985
20986 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20987 PyObject *resultobj = NULL;
20988 wxDateTime *arg1 = (wxDateTime *) 0 ;
20989 int arg2 ;
20990 int arg3 = (int) 0 ;
20991 int arg4 = (int) 0 ;
20992 int arg5 = (int) 0 ;
20993 wxDateTime *result;
20994 PyObject * obj0 = 0 ;
20995 PyObject * obj1 = 0 ;
20996 PyObject * obj2 = 0 ;
20997 PyObject * obj3 = 0 ;
20998 PyObject * obj4 = 0 ;
20999 char *kwnames[] = {
21000 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
21001 };
21002
21003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21005 if (SWIG_arg_fail(1)) SWIG_fail;
21006 {
21007 arg2 = static_cast<int >(SWIG_As_int(obj1));
21008 if (SWIG_arg_fail(2)) SWIG_fail;
21009 }
21010 if (obj2) {
21011 {
21012 arg3 = static_cast<int >(SWIG_As_int(obj2));
21013 if (SWIG_arg_fail(3)) SWIG_fail;
21014 }
21015 }
21016 if (obj3) {
21017 {
21018 arg4 = static_cast<int >(SWIG_As_int(obj3));
21019 if (SWIG_arg_fail(4)) SWIG_fail;
21020 }
21021 }
21022 if (obj4) {
21023 {
21024 arg5 = static_cast<int >(SWIG_As_int(obj4));
21025 if (SWIG_arg_fail(5)) SWIG_fail;
21026 }
21027 }
21028 {
21029 PyThreadState* __tstate = wxPyBeginAllowThreads();
21030 {
21031 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
21032 result = (wxDateTime *) &_result_ref;
21033 }
21034
21035 wxPyEndAllowThreads(__tstate);
21036 if (PyErr_Occurred()) SWIG_fail;
21037 }
21038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21039 return resultobj;
21040 fail:
21041 return NULL;
21042 }
21043
21044
21045 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
21046 PyObject *resultobj = NULL;
21047 wxDateTime *arg1 = (wxDateTime *) 0 ;
21048 int arg2 ;
21049 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21050 int arg4 = (int) wxDateTime::Inv_Year ;
21051 int arg5 = (int) 0 ;
21052 int arg6 = (int) 0 ;
21053 int arg7 = (int) 0 ;
21054 int arg8 = (int) 0 ;
21055 wxDateTime *result;
21056 PyObject * obj0 = 0 ;
21057 PyObject * obj1 = 0 ;
21058 PyObject * obj2 = 0 ;
21059 PyObject * obj3 = 0 ;
21060 PyObject * obj4 = 0 ;
21061 PyObject * obj5 = 0 ;
21062 PyObject * obj6 = 0 ;
21063 PyObject * obj7 = 0 ;
21064 char *kwnames[] = {
21065 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
21066 };
21067
21068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
21069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21070 if (SWIG_arg_fail(1)) SWIG_fail;
21071 {
21072 arg2 = static_cast<int >(SWIG_As_int(obj1));
21073 if (SWIG_arg_fail(2)) SWIG_fail;
21074 }
21075 if (obj2) {
21076 {
21077 arg3 = static_cast<wxDateTime::Month >(SWIG_As_int(obj2));
21078 if (SWIG_arg_fail(3)) SWIG_fail;
21079 }
21080 }
21081 if (obj3) {
21082 {
21083 arg4 = static_cast<int >(SWIG_As_int(obj3));
21084 if (SWIG_arg_fail(4)) SWIG_fail;
21085 }
21086 }
21087 if (obj4) {
21088 {
21089 arg5 = static_cast<int >(SWIG_As_int(obj4));
21090 if (SWIG_arg_fail(5)) SWIG_fail;
21091 }
21092 }
21093 if (obj5) {
21094 {
21095 arg6 = static_cast<int >(SWIG_As_int(obj5));
21096 if (SWIG_arg_fail(6)) SWIG_fail;
21097 }
21098 }
21099 if (obj6) {
21100 {
21101 arg7 = static_cast<int >(SWIG_As_int(obj6));
21102 if (SWIG_arg_fail(7)) SWIG_fail;
21103 }
21104 }
21105 if (obj7) {
21106 {
21107 arg8 = static_cast<int >(SWIG_As_int(obj7));
21108 if (SWIG_arg_fail(8)) SWIG_fail;
21109 }
21110 }
21111 {
21112 PyThreadState* __tstate = wxPyBeginAllowThreads();
21113 {
21114 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21115 result = (wxDateTime *) &_result_ref;
21116 }
21117
21118 wxPyEndAllowThreads(__tstate);
21119 if (PyErr_Occurred()) SWIG_fail;
21120 }
21121 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21122 return resultobj;
21123 fail:
21124 return NULL;
21125 }
21126
21127
21128 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
21129 PyObject *resultobj = NULL;
21130 wxDateTime *arg1 = (wxDateTime *) 0 ;
21131 wxDateTime *result;
21132 PyObject * obj0 = 0 ;
21133 char *kwnames[] = {
21134 (char *) "self", NULL
21135 };
21136
21137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
21138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21139 if (SWIG_arg_fail(1)) SWIG_fail;
21140 {
21141 PyThreadState* __tstate = wxPyBeginAllowThreads();
21142 {
21143 wxDateTime &_result_ref = (arg1)->ResetTime();
21144 result = (wxDateTime *) &_result_ref;
21145 }
21146
21147 wxPyEndAllowThreads(__tstate);
21148 if (PyErr_Occurred()) SWIG_fail;
21149 }
21150 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21151 return resultobj;
21152 fail:
21153 return NULL;
21154 }
21155
21156
21157 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21158 PyObject *resultobj = NULL;
21159 wxDateTime *arg1 = (wxDateTime *) 0 ;
21160 int arg2 ;
21161 wxDateTime *result;
21162 PyObject * obj0 = 0 ;
21163 PyObject * obj1 = 0 ;
21164 char *kwnames[] = {
21165 (char *) "self",(char *) "year", NULL
21166 };
21167
21168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
21169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21170 if (SWIG_arg_fail(1)) SWIG_fail;
21171 {
21172 arg2 = static_cast<int >(SWIG_As_int(obj1));
21173 if (SWIG_arg_fail(2)) SWIG_fail;
21174 }
21175 {
21176 PyThreadState* __tstate = wxPyBeginAllowThreads();
21177 {
21178 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
21179 result = (wxDateTime *) &_result_ref;
21180 }
21181
21182 wxPyEndAllowThreads(__tstate);
21183 if (PyErr_Occurred()) SWIG_fail;
21184 }
21185 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21186 return resultobj;
21187 fail:
21188 return NULL;
21189 }
21190
21191
21192 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21193 PyObject *resultobj = NULL;
21194 wxDateTime *arg1 = (wxDateTime *) 0 ;
21195 wxDateTime::Month arg2 ;
21196 wxDateTime *result;
21197 PyObject * obj0 = 0 ;
21198 PyObject * obj1 = 0 ;
21199 char *kwnames[] = {
21200 (char *) "self",(char *) "month", NULL
21201 };
21202
21203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
21204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21205 if (SWIG_arg_fail(1)) SWIG_fail;
21206 {
21207 arg2 = static_cast<wxDateTime::Month >(SWIG_As_int(obj1));
21208 if (SWIG_arg_fail(2)) SWIG_fail;
21209 }
21210 {
21211 PyThreadState* __tstate = wxPyBeginAllowThreads();
21212 {
21213 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
21214 result = (wxDateTime *) &_result_ref;
21215 }
21216
21217 wxPyEndAllowThreads(__tstate);
21218 if (PyErr_Occurred()) SWIG_fail;
21219 }
21220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21221 return resultobj;
21222 fail:
21223 return NULL;
21224 }
21225
21226
21227 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21228 PyObject *resultobj = NULL;
21229 wxDateTime *arg1 = (wxDateTime *) 0 ;
21230 int arg2 ;
21231 wxDateTime *result;
21232 PyObject * obj0 = 0 ;
21233 PyObject * obj1 = 0 ;
21234 char *kwnames[] = {
21235 (char *) "self",(char *) "day", NULL
21236 };
21237
21238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
21239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21240 if (SWIG_arg_fail(1)) SWIG_fail;
21241 {
21242 arg2 = static_cast<int >(SWIG_As_int(obj1));
21243 if (SWIG_arg_fail(2)) SWIG_fail;
21244 }
21245 {
21246 PyThreadState* __tstate = wxPyBeginAllowThreads();
21247 {
21248 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
21249 result = (wxDateTime *) &_result_ref;
21250 }
21251
21252 wxPyEndAllowThreads(__tstate);
21253 if (PyErr_Occurred()) SWIG_fail;
21254 }
21255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21256 return resultobj;
21257 fail:
21258 return NULL;
21259 }
21260
21261
21262 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21263 PyObject *resultobj = NULL;
21264 wxDateTime *arg1 = (wxDateTime *) 0 ;
21265 int arg2 ;
21266 wxDateTime *result;
21267 PyObject * obj0 = 0 ;
21268 PyObject * obj1 = 0 ;
21269 char *kwnames[] = {
21270 (char *) "self",(char *) "hour", NULL
21271 };
21272
21273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
21274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21275 if (SWIG_arg_fail(1)) SWIG_fail;
21276 {
21277 arg2 = static_cast<int >(SWIG_As_int(obj1));
21278 if (SWIG_arg_fail(2)) SWIG_fail;
21279 }
21280 {
21281 PyThreadState* __tstate = wxPyBeginAllowThreads();
21282 {
21283 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
21284 result = (wxDateTime *) &_result_ref;
21285 }
21286
21287 wxPyEndAllowThreads(__tstate);
21288 if (PyErr_Occurred()) SWIG_fail;
21289 }
21290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21291 return resultobj;
21292 fail:
21293 return NULL;
21294 }
21295
21296
21297 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21298 PyObject *resultobj = NULL;
21299 wxDateTime *arg1 = (wxDateTime *) 0 ;
21300 int arg2 ;
21301 wxDateTime *result;
21302 PyObject * obj0 = 0 ;
21303 PyObject * obj1 = 0 ;
21304 char *kwnames[] = {
21305 (char *) "self",(char *) "minute", NULL
21306 };
21307
21308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
21309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21310 if (SWIG_arg_fail(1)) SWIG_fail;
21311 {
21312 arg2 = static_cast<int >(SWIG_As_int(obj1));
21313 if (SWIG_arg_fail(2)) SWIG_fail;
21314 }
21315 {
21316 PyThreadState* __tstate = wxPyBeginAllowThreads();
21317 {
21318 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
21319 result = (wxDateTime *) &_result_ref;
21320 }
21321
21322 wxPyEndAllowThreads(__tstate);
21323 if (PyErr_Occurred()) SWIG_fail;
21324 }
21325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21326 return resultobj;
21327 fail:
21328 return NULL;
21329 }
21330
21331
21332 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21333 PyObject *resultobj = NULL;
21334 wxDateTime *arg1 = (wxDateTime *) 0 ;
21335 int arg2 ;
21336 wxDateTime *result;
21337 PyObject * obj0 = 0 ;
21338 PyObject * obj1 = 0 ;
21339 char *kwnames[] = {
21340 (char *) "self",(char *) "second", NULL
21341 };
21342
21343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
21344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21345 if (SWIG_arg_fail(1)) SWIG_fail;
21346 {
21347 arg2 = static_cast<int >(SWIG_As_int(obj1));
21348 if (SWIG_arg_fail(2)) SWIG_fail;
21349 }
21350 {
21351 PyThreadState* __tstate = wxPyBeginAllowThreads();
21352 {
21353 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
21354 result = (wxDateTime *) &_result_ref;
21355 }
21356
21357 wxPyEndAllowThreads(__tstate);
21358 if (PyErr_Occurred()) SWIG_fail;
21359 }
21360 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21361 return resultobj;
21362 fail:
21363 return NULL;
21364 }
21365
21366
21367 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21368 PyObject *resultobj = NULL;
21369 wxDateTime *arg1 = (wxDateTime *) 0 ;
21370 int arg2 ;
21371 wxDateTime *result;
21372 PyObject * obj0 = 0 ;
21373 PyObject * obj1 = 0 ;
21374 char *kwnames[] = {
21375 (char *) "self",(char *) "millisecond", NULL
21376 };
21377
21378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21380 if (SWIG_arg_fail(1)) SWIG_fail;
21381 {
21382 arg2 = static_cast<int >(SWIG_As_int(obj1));
21383 if (SWIG_arg_fail(2)) SWIG_fail;
21384 }
21385 {
21386 PyThreadState* __tstate = wxPyBeginAllowThreads();
21387 {
21388 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
21389 result = (wxDateTime *) &_result_ref;
21390 }
21391
21392 wxPyEndAllowThreads(__tstate);
21393 if (PyErr_Occurred()) SWIG_fail;
21394 }
21395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21396 return resultobj;
21397 fail:
21398 return NULL;
21399 }
21400
21401
21402 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21403 PyObject *resultobj = NULL;
21404 wxDateTime *arg1 = (wxDateTime *) 0 ;
21405 wxDateTime::WeekDay arg2 ;
21406 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21407 wxDateTime *result;
21408 PyObject * obj0 = 0 ;
21409 PyObject * obj1 = 0 ;
21410 PyObject * obj2 = 0 ;
21411 char *kwnames[] = {
21412 (char *) "self",(char *) "weekday",(char *) "flags", NULL
21413 };
21414
21415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
21416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21417 if (SWIG_arg_fail(1)) SWIG_fail;
21418 {
21419 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21420 if (SWIG_arg_fail(2)) SWIG_fail;
21421 }
21422 if (obj2) {
21423 {
21424 arg3 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj2));
21425 if (SWIG_arg_fail(3)) SWIG_fail;
21426 }
21427 }
21428 {
21429 PyThreadState* __tstate = wxPyBeginAllowThreads();
21430 {
21431 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
21432 result = (wxDateTime *) &_result_ref;
21433 }
21434
21435 wxPyEndAllowThreads(__tstate);
21436 if (PyErr_Occurred()) SWIG_fail;
21437 }
21438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21439 return resultobj;
21440 fail:
21441 return NULL;
21442 }
21443
21444
21445 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21446 PyObject *resultobj = NULL;
21447 wxDateTime *arg1 = (wxDateTime *) 0 ;
21448 wxDateTime::WeekDay arg2 ;
21449 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21450 wxDateTime result;
21451 PyObject * obj0 = 0 ;
21452 PyObject * obj1 = 0 ;
21453 PyObject * obj2 = 0 ;
21454 char *kwnames[] = {
21455 (char *) "self",(char *) "weekday",(char *) "flags", NULL
21456 };
21457
21458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
21459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21460 if (SWIG_arg_fail(1)) SWIG_fail;
21461 {
21462 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21463 if (SWIG_arg_fail(2)) SWIG_fail;
21464 }
21465 if (obj2) {
21466 {
21467 arg3 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj2));
21468 if (SWIG_arg_fail(3)) SWIG_fail;
21469 }
21470 }
21471 {
21472 PyThreadState* __tstate = wxPyBeginAllowThreads();
21473 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
21474
21475 wxPyEndAllowThreads(__tstate);
21476 if (PyErr_Occurred()) SWIG_fail;
21477 }
21478 {
21479 wxDateTime * resultptr;
21480 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21481 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21482 }
21483 return resultobj;
21484 fail:
21485 return NULL;
21486 }
21487
21488
21489 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21490 PyObject *resultobj = NULL;
21491 wxDateTime *arg1 = (wxDateTime *) 0 ;
21492 wxDateTime::WeekDay arg2 ;
21493 wxDateTime *result;
21494 PyObject * obj0 = 0 ;
21495 PyObject * obj1 = 0 ;
21496 char *kwnames[] = {
21497 (char *) "self",(char *) "weekday", NULL
21498 };
21499
21500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
21501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21502 if (SWIG_arg_fail(1)) SWIG_fail;
21503 {
21504 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21505 if (SWIG_arg_fail(2)) SWIG_fail;
21506 }
21507 {
21508 PyThreadState* __tstate = wxPyBeginAllowThreads();
21509 {
21510 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
21511 result = (wxDateTime *) &_result_ref;
21512 }
21513
21514 wxPyEndAllowThreads(__tstate);
21515 if (PyErr_Occurred()) SWIG_fail;
21516 }
21517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21518 return resultobj;
21519 fail:
21520 return NULL;
21521 }
21522
21523
21524 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21525 PyObject *resultobj = NULL;
21526 wxDateTime *arg1 = (wxDateTime *) 0 ;
21527 wxDateTime::WeekDay arg2 ;
21528 wxDateTime result;
21529 PyObject * obj0 = 0 ;
21530 PyObject * obj1 = 0 ;
21531 char *kwnames[] = {
21532 (char *) "self",(char *) "weekday", NULL
21533 };
21534
21535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
21536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21537 if (SWIG_arg_fail(1)) SWIG_fail;
21538 {
21539 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21540 if (SWIG_arg_fail(2)) SWIG_fail;
21541 }
21542 {
21543 PyThreadState* __tstate = wxPyBeginAllowThreads();
21544 result = (arg1)->GetNextWeekDay(arg2);
21545
21546 wxPyEndAllowThreads(__tstate);
21547 if (PyErr_Occurred()) SWIG_fail;
21548 }
21549 {
21550 wxDateTime * resultptr;
21551 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21552 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21553 }
21554 return resultobj;
21555 fail:
21556 return NULL;
21557 }
21558
21559
21560 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21561 PyObject *resultobj = NULL;
21562 wxDateTime *arg1 = (wxDateTime *) 0 ;
21563 wxDateTime::WeekDay arg2 ;
21564 wxDateTime *result;
21565 PyObject * obj0 = 0 ;
21566 PyObject * obj1 = 0 ;
21567 char *kwnames[] = {
21568 (char *) "self",(char *) "weekday", NULL
21569 };
21570
21571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
21572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21573 if (SWIG_arg_fail(1)) SWIG_fail;
21574 {
21575 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21576 if (SWIG_arg_fail(2)) SWIG_fail;
21577 }
21578 {
21579 PyThreadState* __tstate = wxPyBeginAllowThreads();
21580 {
21581 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
21582 result = (wxDateTime *) &_result_ref;
21583 }
21584
21585 wxPyEndAllowThreads(__tstate);
21586 if (PyErr_Occurred()) SWIG_fail;
21587 }
21588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21589 return resultobj;
21590 fail:
21591 return NULL;
21592 }
21593
21594
21595 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21596 PyObject *resultobj = NULL;
21597 wxDateTime *arg1 = (wxDateTime *) 0 ;
21598 wxDateTime::WeekDay arg2 ;
21599 wxDateTime result;
21600 PyObject * obj0 = 0 ;
21601 PyObject * obj1 = 0 ;
21602 char *kwnames[] = {
21603 (char *) "self",(char *) "weekday", NULL
21604 };
21605
21606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
21607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21608 if (SWIG_arg_fail(1)) SWIG_fail;
21609 {
21610 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21611 if (SWIG_arg_fail(2)) SWIG_fail;
21612 }
21613 {
21614 PyThreadState* __tstate = wxPyBeginAllowThreads();
21615 result = (arg1)->GetPrevWeekDay(arg2);
21616
21617 wxPyEndAllowThreads(__tstate);
21618 if (PyErr_Occurred()) SWIG_fail;
21619 }
21620 {
21621 wxDateTime * resultptr;
21622 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21623 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21624 }
21625 return resultobj;
21626 fail:
21627 return NULL;
21628 }
21629
21630
21631 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21632 PyObject *resultobj = NULL;
21633 wxDateTime *arg1 = (wxDateTime *) 0 ;
21634 wxDateTime::WeekDay arg2 ;
21635 int arg3 = (int) 1 ;
21636 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21637 int arg5 = (int) wxDateTime::Inv_Year ;
21638 bool result;
21639 PyObject * obj0 = 0 ;
21640 PyObject * obj1 = 0 ;
21641 PyObject * obj2 = 0 ;
21642 PyObject * obj3 = 0 ;
21643 PyObject * obj4 = 0 ;
21644 char *kwnames[] = {
21645 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
21646 };
21647
21648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
21649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21650 if (SWIG_arg_fail(1)) SWIG_fail;
21651 {
21652 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21653 if (SWIG_arg_fail(2)) SWIG_fail;
21654 }
21655 if (obj2) {
21656 {
21657 arg3 = static_cast<int >(SWIG_As_int(obj2));
21658 if (SWIG_arg_fail(3)) SWIG_fail;
21659 }
21660 }
21661 if (obj3) {
21662 {
21663 arg4 = static_cast<wxDateTime::Month >(SWIG_As_int(obj3));
21664 if (SWIG_arg_fail(4)) SWIG_fail;
21665 }
21666 }
21667 if (obj4) {
21668 {
21669 arg5 = static_cast<int >(SWIG_As_int(obj4));
21670 if (SWIG_arg_fail(5)) SWIG_fail;
21671 }
21672 }
21673 {
21674 PyThreadState* __tstate = wxPyBeginAllowThreads();
21675 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
21676
21677 wxPyEndAllowThreads(__tstate);
21678 if (PyErr_Occurred()) SWIG_fail;
21679 }
21680 {
21681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21682 }
21683 return resultobj;
21684 fail:
21685 return NULL;
21686 }
21687
21688
21689 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21690 PyObject *resultobj = NULL;
21691 wxDateTime *arg1 = (wxDateTime *) 0 ;
21692 wxDateTime::WeekDay arg2 ;
21693 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21694 int arg4 = (int) wxDateTime::Inv_Year ;
21695 bool result;
21696 PyObject * obj0 = 0 ;
21697 PyObject * obj1 = 0 ;
21698 PyObject * obj2 = 0 ;
21699 PyObject * obj3 = 0 ;
21700 char *kwnames[] = {
21701 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
21702 };
21703
21704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21706 if (SWIG_arg_fail(1)) SWIG_fail;
21707 {
21708 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21709 if (SWIG_arg_fail(2)) SWIG_fail;
21710 }
21711 if (obj2) {
21712 {
21713 arg3 = static_cast<wxDateTime::Month >(SWIG_As_int(obj2));
21714 if (SWIG_arg_fail(3)) SWIG_fail;
21715 }
21716 }
21717 if (obj3) {
21718 {
21719 arg4 = static_cast<int >(SWIG_As_int(obj3));
21720 if (SWIG_arg_fail(4)) SWIG_fail;
21721 }
21722 }
21723 {
21724 PyThreadState* __tstate = wxPyBeginAllowThreads();
21725 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
21726
21727 wxPyEndAllowThreads(__tstate);
21728 if (PyErr_Occurred()) SWIG_fail;
21729 }
21730 {
21731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21732 }
21733 return resultobj;
21734 fail:
21735 return NULL;
21736 }
21737
21738
21739 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21740 PyObject *resultobj = NULL;
21741 wxDateTime *arg1 = (wxDateTime *) 0 ;
21742 wxDateTime::WeekDay arg2 ;
21743 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21744 int arg4 = (int) wxDateTime::Inv_Year ;
21745 wxDateTime result;
21746 PyObject * obj0 = 0 ;
21747 PyObject * obj1 = 0 ;
21748 PyObject * obj2 = 0 ;
21749 PyObject * obj3 = 0 ;
21750 char *kwnames[] = {
21751 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
21752 };
21753
21754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21756 if (SWIG_arg_fail(1)) SWIG_fail;
21757 {
21758 arg2 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj1));
21759 if (SWIG_arg_fail(2)) SWIG_fail;
21760 }
21761 if (obj2) {
21762 {
21763 arg3 = static_cast<wxDateTime::Month >(SWIG_As_int(obj2));
21764 if (SWIG_arg_fail(3)) SWIG_fail;
21765 }
21766 }
21767 if (obj3) {
21768 {
21769 arg4 = static_cast<int >(SWIG_As_int(obj3));
21770 if (SWIG_arg_fail(4)) SWIG_fail;
21771 }
21772 }
21773 {
21774 PyThreadState* __tstate = wxPyBeginAllowThreads();
21775 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
21776
21777 wxPyEndAllowThreads(__tstate);
21778 if (PyErr_Occurred()) SWIG_fail;
21779 }
21780 {
21781 wxDateTime * resultptr;
21782 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21783 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21784 }
21785 return resultobj;
21786 fail:
21787 return NULL;
21788 }
21789
21790
21791 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21792 PyObject *resultobj = NULL;
21793 wxDateTime *arg1 = (wxDateTime *) 0 ;
21794 int arg2 ;
21795 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21796 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21797 bool result;
21798 PyObject * obj0 = 0 ;
21799 PyObject * obj1 = 0 ;
21800 PyObject * obj2 = 0 ;
21801 PyObject * obj3 = 0 ;
21802 char *kwnames[] = {
21803 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
21804 };
21805
21806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21808 if (SWIG_arg_fail(1)) SWIG_fail;
21809 {
21810 arg2 = static_cast<int >(SWIG_As_int(obj1));
21811 if (SWIG_arg_fail(2)) SWIG_fail;
21812 }
21813 if (obj2) {
21814 {
21815 arg3 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj2));
21816 if (SWIG_arg_fail(3)) SWIG_fail;
21817 }
21818 }
21819 if (obj3) {
21820 {
21821 arg4 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj3));
21822 if (SWIG_arg_fail(4)) SWIG_fail;
21823 }
21824 }
21825 {
21826 PyThreadState* __tstate = wxPyBeginAllowThreads();
21827 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
21828
21829 wxPyEndAllowThreads(__tstate);
21830 if (PyErr_Occurred()) SWIG_fail;
21831 }
21832 {
21833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21834 }
21835 return resultobj;
21836 fail:
21837 return NULL;
21838 }
21839
21840
21841 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
21842 PyObject *resultobj = NULL;
21843 wxDateTime *arg1 = (wxDateTime *) 0 ;
21844 int arg2 ;
21845 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21846 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21847 wxDateTime result;
21848 PyObject * obj0 = 0 ;
21849 PyObject * obj1 = 0 ;
21850 PyObject * obj2 = 0 ;
21851 PyObject * obj3 = 0 ;
21852 char *kwnames[] = {
21853 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
21854 };
21855
21856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
21857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21858 if (SWIG_arg_fail(1)) SWIG_fail;
21859 {
21860 arg2 = static_cast<int >(SWIG_As_int(obj1));
21861 if (SWIG_arg_fail(2)) SWIG_fail;
21862 }
21863 if (obj2) {
21864 {
21865 arg3 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj2));
21866 if (SWIG_arg_fail(3)) SWIG_fail;
21867 }
21868 }
21869 if (obj3) {
21870 {
21871 arg4 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj3));
21872 if (SWIG_arg_fail(4)) SWIG_fail;
21873 }
21874 }
21875 {
21876 PyThreadState* __tstate = wxPyBeginAllowThreads();
21877 result = (arg1)->GetWeek(arg2,arg3,arg4);
21878
21879 wxPyEndAllowThreads(__tstate);
21880 if (PyErr_Occurred()) SWIG_fail;
21881 }
21882 {
21883 wxDateTime * resultptr;
21884 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21885 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21886 }
21887 return resultobj;
21888 fail:
21889 return NULL;
21890 }
21891
21892
21893 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21894 PyObject *resultobj = NULL;
21895 int arg1 ;
21896 int arg2 ;
21897 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
21898 wxDateTime result;
21899 PyObject * obj0 = 0 ;
21900 PyObject * obj1 = 0 ;
21901 PyObject * obj2 = 0 ;
21902 char *kwnames[] = {
21903 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
21904 };
21905
21906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21907 {
21908 arg1 = static_cast<int >(SWIG_As_int(obj0));
21909 if (SWIG_arg_fail(1)) SWIG_fail;
21910 }
21911 {
21912 arg2 = static_cast<int >(SWIG_As_int(obj1));
21913 if (SWIG_arg_fail(2)) SWIG_fail;
21914 }
21915 if (obj2) {
21916 {
21917 arg3 = static_cast<wxDateTime::WeekDay >(SWIG_As_int(obj2));
21918 if (SWIG_arg_fail(3)) SWIG_fail;
21919 }
21920 }
21921 {
21922 PyThreadState* __tstate = wxPyBeginAllowThreads();
21923 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
21924
21925 wxPyEndAllowThreads(__tstate);
21926 if (PyErr_Occurred()) SWIG_fail;
21927 }
21928 {
21929 wxDateTime * resultptr;
21930 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
21931 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21932 }
21933 return resultobj;
21934 fail:
21935 return NULL;
21936 }
21937
21938
21939 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21940 PyObject *resultobj = NULL;
21941 wxDateTime *arg1 = (wxDateTime *) 0 ;
21942 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21943 int arg3 = (int) wxDateTime::Inv_Year ;
21944 wxDateTime *result;
21945 PyObject * obj0 = 0 ;
21946 PyObject * obj1 = 0 ;
21947 PyObject * obj2 = 0 ;
21948 char *kwnames[] = {
21949 (char *) "self",(char *) "month",(char *) "year", NULL
21950 };
21951
21952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21954 if (SWIG_arg_fail(1)) SWIG_fail;
21955 if (obj1) {
21956 {
21957 arg2 = static_cast<wxDateTime::Month >(SWIG_As_int(obj1));
21958 if (SWIG_arg_fail(2)) SWIG_fail;
21959 }
21960 }
21961 if (obj2) {
21962 {
21963 arg3 = static_cast<int >(SWIG_As_int(obj2));
21964 if (SWIG_arg_fail(3)) SWIG_fail;
21965 }
21966 }
21967 {
21968 PyThreadState* __tstate = wxPyBeginAllowThreads();
21969 {
21970 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
21971 result = (wxDateTime *) &_result_ref;
21972 }
21973
21974 wxPyEndAllowThreads(__tstate);
21975 if (PyErr_Occurred()) SWIG_fail;
21976 }
21977 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21978 return resultobj;
21979 fail:
21980 return NULL;
21981 }
21982
21983
21984 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21985 PyObject *resultobj = NULL;
21986 wxDateTime *arg1 = (wxDateTime *) 0 ;
21987 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21988 int arg3 = (int) wxDateTime::Inv_Year ;
21989 wxDateTime result;
21990 PyObject * obj0 = 0 ;
21991 PyObject * obj1 = 0 ;
21992 PyObject * obj2 = 0 ;
21993 char *kwnames[] = {
21994 (char *) "self",(char *) "month",(char *) "year", NULL
21995 };
21996
21997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21999 if (SWIG_arg_fail(1)) SWIG_fail;
22000 if (obj1) {
22001 {
22002 arg2 = static_cast<wxDateTime::Month >(SWIG_As_int(obj1));
22003 if (SWIG_arg_fail(2)) SWIG_fail;
22004 }
22005 }
22006 if (obj2) {
22007 {
22008 arg3 = static_cast<int >(SWIG_As_int(obj2));
22009 if (SWIG_arg_fail(3)) SWIG_fail;
22010 }
22011 }
22012 {
22013 PyThreadState* __tstate = wxPyBeginAllowThreads();
22014 result = (arg1)->GetLastMonthDay(arg2,arg3);
22015
22016 wxPyEndAllowThreads(__tstate);
22017 if (PyErr_Occurred()) SWIG_fail;
22018 }
22019 {
22020 wxDateTime * resultptr;
22021 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22022 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22023 }
22024 return resultobj;
22025 fail:
22026 return NULL;
22027 }
22028
22029
22030 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
22031 PyObject *resultobj = NULL;
22032 wxDateTime *arg1 = (wxDateTime *) 0 ;
22033 int arg2 ;
22034 wxDateTime *result;
22035 PyObject * obj0 = 0 ;
22036 PyObject * obj1 = 0 ;
22037 char *kwnames[] = {
22038 (char *) "self",(char *) "yday", NULL
22039 };
22040
22041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
22042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22043 if (SWIG_arg_fail(1)) SWIG_fail;
22044 {
22045 arg2 = static_cast<int >(SWIG_As_int(obj1));
22046 if (SWIG_arg_fail(2)) SWIG_fail;
22047 }
22048 {
22049 PyThreadState* __tstate = wxPyBeginAllowThreads();
22050 {
22051 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
22052 result = (wxDateTime *) &_result_ref;
22053 }
22054
22055 wxPyEndAllowThreads(__tstate);
22056 if (PyErr_Occurred()) SWIG_fail;
22057 }
22058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22059 return resultobj;
22060 fail:
22061 return NULL;
22062 }
22063
22064
22065 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
22066 PyObject *resultobj = NULL;
22067 wxDateTime *arg1 = (wxDateTime *) 0 ;
22068 int arg2 ;
22069 wxDateTime result;
22070 PyObject * obj0 = 0 ;
22071 PyObject * obj1 = 0 ;
22072 char *kwnames[] = {
22073 (char *) "self",(char *) "yday", NULL
22074 };
22075
22076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
22077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22078 if (SWIG_arg_fail(1)) SWIG_fail;
22079 {
22080 arg2 = static_cast<int >(SWIG_As_int(obj1));
22081 if (SWIG_arg_fail(2)) SWIG_fail;
22082 }
22083 {
22084 PyThreadState* __tstate = wxPyBeginAllowThreads();
22085 result = (arg1)->GetYearDay(arg2);
22086
22087 wxPyEndAllowThreads(__tstate);
22088 if (PyErr_Occurred()) SWIG_fail;
22089 }
22090 {
22091 wxDateTime * resultptr;
22092 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22093 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22094 }
22095 return resultobj;
22096 fail:
22097 return NULL;
22098 }
22099
22100
22101 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
22102 PyObject *resultobj = NULL;
22103 wxDateTime *arg1 = (wxDateTime *) 0 ;
22104 double result;
22105 PyObject * obj0 = 0 ;
22106 char *kwnames[] = {
22107 (char *) "self", NULL
22108 };
22109
22110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
22111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22112 if (SWIG_arg_fail(1)) SWIG_fail;
22113 {
22114 PyThreadState* __tstate = wxPyBeginAllowThreads();
22115 result = (double)(arg1)->GetJulianDayNumber();
22116
22117 wxPyEndAllowThreads(__tstate);
22118 if (PyErr_Occurred()) SWIG_fail;
22119 }
22120 {
22121 resultobj = SWIG_From_double(static_cast<double >(result));
22122 }
22123 return resultobj;
22124 fail:
22125 return NULL;
22126 }
22127
22128
22129 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
22130 PyObject *resultobj = NULL;
22131 wxDateTime *arg1 = (wxDateTime *) 0 ;
22132 double result;
22133 PyObject * obj0 = 0 ;
22134 char *kwnames[] = {
22135 (char *) "self", NULL
22136 };
22137
22138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
22139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22140 if (SWIG_arg_fail(1)) SWIG_fail;
22141 {
22142 PyThreadState* __tstate = wxPyBeginAllowThreads();
22143 result = (double)(arg1)->GetJDN();
22144
22145 wxPyEndAllowThreads(__tstate);
22146 if (PyErr_Occurred()) SWIG_fail;
22147 }
22148 {
22149 resultobj = SWIG_From_double(static_cast<double >(result));
22150 }
22151 return resultobj;
22152 fail:
22153 return NULL;
22154 }
22155
22156
22157 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
22158 PyObject *resultobj = NULL;
22159 wxDateTime *arg1 = (wxDateTime *) 0 ;
22160 double result;
22161 PyObject * obj0 = 0 ;
22162 char *kwnames[] = {
22163 (char *) "self", NULL
22164 };
22165
22166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
22167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22168 if (SWIG_arg_fail(1)) SWIG_fail;
22169 {
22170 PyThreadState* __tstate = wxPyBeginAllowThreads();
22171 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
22172
22173 wxPyEndAllowThreads(__tstate);
22174 if (PyErr_Occurred()) SWIG_fail;
22175 }
22176 {
22177 resultobj = SWIG_From_double(static_cast<double >(result));
22178 }
22179 return resultobj;
22180 fail:
22181 return NULL;
22182 }
22183
22184
22185 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
22186 PyObject *resultobj = NULL;
22187 wxDateTime *arg1 = (wxDateTime *) 0 ;
22188 double result;
22189 PyObject * obj0 = 0 ;
22190 char *kwnames[] = {
22191 (char *) "self", NULL
22192 };
22193
22194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
22195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22196 if (SWIG_arg_fail(1)) SWIG_fail;
22197 {
22198 PyThreadState* __tstate = wxPyBeginAllowThreads();
22199 result = (double)(arg1)->GetMJD();
22200
22201 wxPyEndAllowThreads(__tstate);
22202 if (PyErr_Occurred()) SWIG_fail;
22203 }
22204 {
22205 resultobj = SWIG_From_double(static_cast<double >(result));
22206 }
22207 return resultobj;
22208 fail:
22209 return NULL;
22210 }
22211
22212
22213 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
22214 PyObject *resultobj = NULL;
22215 wxDateTime *arg1 = (wxDateTime *) 0 ;
22216 double result;
22217 PyObject * obj0 = 0 ;
22218 char *kwnames[] = {
22219 (char *) "self", NULL
22220 };
22221
22222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
22223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22224 if (SWIG_arg_fail(1)) SWIG_fail;
22225 {
22226 PyThreadState* __tstate = wxPyBeginAllowThreads();
22227 result = (double)(arg1)->GetRataDie();
22228
22229 wxPyEndAllowThreads(__tstate);
22230 if (PyErr_Occurred()) SWIG_fail;
22231 }
22232 {
22233 resultobj = SWIG_From_double(static_cast<double >(result));
22234 }
22235 return resultobj;
22236 fail:
22237 return NULL;
22238 }
22239
22240
22241 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
22242 PyObject *resultobj = NULL;
22243 wxDateTime *arg1 = (wxDateTime *) 0 ;
22244 wxDateTime::TimeZone *arg2 = 0 ;
22245 bool arg3 = (bool) false ;
22246 wxDateTime result;
22247 bool temp2 = false ;
22248 PyObject * obj0 = 0 ;
22249 PyObject * obj1 = 0 ;
22250 PyObject * obj2 = 0 ;
22251 char *kwnames[] = {
22252 (char *) "self",(char *) "tz",(char *) "noDST", NULL
22253 };
22254
22255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
22256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22257 if (SWIG_arg_fail(1)) SWIG_fail;
22258 {
22259 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22260 temp2 = true;
22261 }
22262 if (obj2) {
22263 {
22264 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
22265 if (SWIG_arg_fail(3)) SWIG_fail;
22266 }
22267 }
22268 {
22269 PyThreadState* __tstate = wxPyBeginAllowThreads();
22270 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
22271
22272 wxPyEndAllowThreads(__tstate);
22273 if (PyErr_Occurred()) SWIG_fail;
22274 }
22275 {
22276 wxDateTime * resultptr;
22277 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22278 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22279 }
22280 {
22281 if (temp2) delete arg2;
22282 }
22283 return resultobj;
22284 fail:
22285 {
22286 if (temp2) delete arg2;
22287 }
22288 return NULL;
22289 }
22290
22291
22292 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
22293 PyObject *resultobj = NULL;
22294 wxDateTime *arg1 = (wxDateTime *) 0 ;
22295 wxDateTime::TimeZone *arg2 = 0 ;
22296 bool arg3 = (bool) false ;
22297 wxDateTime *result;
22298 bool temp2 = false ;
22299 PyObject * obj0 = 0 ;
22300 PyObject * obj1 = 0 ;
22301 PyObject * obj2 = 0 ;
22302 char *kwnames[] = {
22303 (char *) "self",(char *) "tz",(char *) "noDST", NULL
22304 };
22305
22306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
22307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22308 if (SWIG_arg_fail(1)) SWIG_fail;
22309 {
22310 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22311 temp2 = true;
22312 }
22313 if (obj2) {
22314 {
22315 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
22316 if (SWIG_arg_fail(3)) SWIG_fail;
22317 }
22318 }
22319 {
22320 PyThreadState* __tstate = wxPyBeginAllowThreads();
22321 {
22322 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
22323 result = (wxDateTime *) &_result_ref;
22324 }
22325
22326 wxPyEndAllowThreads(__tstate);
22327 if (PyErr_Occurred()) SWIG_fail;
22328 }
22329 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22330 {
22331 if (temp2) delete arg2;
22332 }
22333 return resultobj;
22334 fail:
22335 {
22336 if (temp2) delete arg2;
22337 }
22338 return NULL;
22339 }
22340
22341
22342 static PyObject *_wrap_DateTime_FromTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
22343 PyObject *resultobj = NULL;
22344 wxDateTime *arg1 = (wxDateTime *) 0 ;
22345 wxDateTime::TimeZone *arg2 = 0 ;
22346 bool arg3 = (bool) false ;
22347 wxDateTime result;
22348 bool temp2 = false ;
22349 PyObject * obj0 = 0 ;
22350 PyObject * obj1 = 0 ;
22351 PyObject * obj2 = 0 ;
22352 char *kwnames[] = {
22353 (char *) "self",(char *) "tz",(char *) "noDST", NULL
22354 };
22355
22356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
22357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22358 if (SWIG_arg_fail(1)) SWIG_fail;
22359 {
22360 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22361 temp2 = true;
22362 }
22363 if (obj2) {
22364 {
22365 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
22366 if (SWIG_arg_fail(3)) SWIG_fail;
22367 }
22368 }
22369 {
22370 PyThreadState* __tstate = wxPyBeginAllowThreads();
22371 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
22372
22373 wxPyEndAllowThreads(__tstate);
22374 if (PyErr_Occurred()) SWIG_fail;
22375 }
22376 {
22377 wxDateTime * resultptr;
22378 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22379 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22380 }
22381 {
22382 if (temp2) delete arg2;
22383 }
22384 return resultobj;
22385 fail:
22386 {
22387 if (temp2) delete arg2;
22388 }
22389 return NULL;
22390 }
22391
22392
22393 static PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
22394 PyObject *resultobj = NULL;
22395 wxDateTime *arg1 = (wxDateTime *) 0 ;
22396 wxDateTime::TimeZone *arg2 = 0 ;
22397 bool arg3 = (bool) false ;
22398 wxDateTime *result;
22399 bool temp2 = false ;
22400 PyObject * obj0 = 0 ;
22401 PyObject * obj1 = 0 ;
22402 PyObject * obj2 = 0 ;
22403 char *kwnames[] = {
22404 (char *) "self",(char *) "tz",(char *) "noDST", NULL
22405 };
22406
22407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
22408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22409 if (SWIG_arg_fail(1)) SWIG_fail;
22410 {
22411 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22412 temp2 = true;
22413 }
22414 if (obj2) {
22415 {
22416 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
22417 if (SWIG_arg_fail(3)) SWIG_fail;
22418 }
22419 }
22420 {
22421 PyThreadState* __tstate = wxPyBeginAllowThreads();
22422 {
22423 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
22424 result = (wxDateTime *) &_result_ref;
22425 }
22426
22427 wxPyEndAllowThreads(__tstate);
22428 if (PyErr_Occurred()) SWIG_fail;
22429 }
22430 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22431 {
22432 if (temp2) delete arg2;
22433 }
22434 return resultobj;
22435 fail:
22436 {
22437 if (temp2) delete arg2;
22438 }
22439 return NULL;
22440 }
22441
22442
22443 static PyObject *_wrap_DateTime_ToUTC(PyObject *, PyObject *args, PyObject *kwargs) {
22444 PyObject *resultobj = NULL;
22445 wxDateTime *arg1 = (wxDateTime *) 0 ;
22446 bool arg2 = (bool) false ;
22447 wxDateTime result;
22448 PyObject * obj0 = 0 ;
22449 PyObject * obj1 = 0 ;
22450 char *kwnames[] = {
22451 (char *) "self",(char *) "noDST", NULL
22452 };
22453
22454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) goto fail;
22455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22456 if (SWIG_arg_fail(1)) SWIG_fail;
22457 if (obj1) {
22458 {
22459 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22460 if (SWIG_arg_fail(2)) SWIG_fail;
22461 }
22462 }
22463 {
22464 PyThreadState* __tstate = wxPyBeginAllowThreads();
22465 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
22466
22467 wxPyEndAllowThreads(__tstate);
22468 if (PyErr_Occurred()) SWIG_fail;
22469 }
22470 {
22471 wxDateTime * resultptr;
22472 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22473 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22474 }
22475 return resultobj;
22476 fail:
22477 return NULL;
22478 }
22479
22480
22481 static PyObject *_wrap_DateTime_MakeUTC(PyObject *, PyObject *args, PyObject *kwargs) {
22482 PyObject *resultobj = NULL;
22483 wxDateTime *arg1 = (wxDateTime *) 0 ;
22484 bool arg2 = (bool) false ;
22485 wxDateTime *result;
22486 PyObject * obj0 = 0 ;
22487 PyObject * obj1 = 0 ;
22488 char *kwnames[] = {
22489 (char *) "self",(char *) "noDST", NULL
22490 };
22491
22492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) goto fail;
22493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22494 if (SWIG_arg_fail(1)) SWIG_fail;
22495 if (obj1) {
22496 {
22497 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22498 if (SWIG_arg_fail(2)) SWIG_fail;
22499 }
22500 }
22501 {
22502 PyThreadState* __tstate = wxPyBeginAllowThreads();
22503 {
22504 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
22505 result = (wxDateTime *) &_result_ref;
22506 }
22507
22508 wxPyEndAllowThreads(__tstate);
22509 if (PyErr_Occurred()) SWIG_fail;
22510 }
22511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22512 return resultobj;
22513 fail:
22514 return NULL;
22515 }
22516
22517
22518 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
22519 PyObject *resultobj = NULL;
22520 wxDateTime *arg1 = (wxDateTime *) 0 ;
22521 bool arg2 = (bool) false ;
22522 wxDateTime result;
22523 PyObject * obj0 = 0 ;
22524 PyObject * obj1 = 0 ;
22525 char *kwnames[] = {
22526 (char *) "self",(char *) "noDST", NULL
22527 };
22528
22529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
22530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22531 if (SWIG_arg_fail(1)) SWIG_fail;
22532 if (obj1) {
22533 {
22534 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22535 if (SWIG_arg_fail(2)) SWIG_fail;
22536 }
22537 }
22538 {
22539 PyThreadState* __tstate = wxPyBeginAllowThreads();
22540 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
22541
22542 wxPyEndAllowThreads(__tstate);
22543 if (PyErr_Occurred()) SWIG_fail;
22544 }
22545 {
22546 wxDateTime * resultptr;
22547 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22548 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22549 }
22550 return resultobj;
22551 fail:
22552 return NULL;
22553 }
22554
22555
22556 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
22557 PyObject *resultobj = NULL;
22558 wxDateTime *arg1 = (wxDateTime *) 0 ;
22559 bool arg2 = (bool) false ;
22560 wxDateTime *result;
22561 PyObject * obj0 = 0 ;
22562 PyObject * obj1 = 0 ;
22563 char *kwnames[] = {
22564 (char *) "self",(char *) "noDST", NULL
22565 };
22566
22567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
22568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22569 if (SWIG_arg_fail(1)) SWIG_fail;
22570 if (obj1) {
22571 {
22572 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22573 if (SWIG_arg_fail(2)) SWIG_fail;
22574 }
22575 }
22576 {
22577 PyThreadState* __tstate = wxPyBeginAllowThreads();
22578 {
22579 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
22580 result = (wxDateTime *) &_result_ref;
22581 }
22582
22583 wxPyEndAllowThreads(__tstate);
22584 if (PyErr_Occurred()) SWIG_fail;
22585 }
22586 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22587 return resultobj;
22588 fail:
22589 return NULL;
22590 }
22591
22592
22593 static PyObject *_wrap_DateTime_FromUTC(PyObject *, PyObject *args, PyObject *kwargs) {
22594 PyObject *resultobj = NULL;
22595 wxDateTime *arg1 = (wxDateTime *) 0 ;
22596 bool arg2 = (bool) false ;
22597 wxDateTime result;
22598 PyObject * obj0 = 0 ;
22599 PyObject * obj1 = 0 ;
22600 char *kwnames[] = {
22601 (char *) "self",(char *) "noDST", NULL
22602 };
22603
22604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) goto fail;
22605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22606 if (SWIG_arg_fail(1)) SWIG_fail;
22607 if (obj1) {
22608 {
22609 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22610 if (SWIG_arg_fail(2)) SWIG_fail;
22611 }
22612 }
22613 {
22614 PyThreadState* __tstate = wxPyBeginAllowThreads();
22615 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
22616
22617 wxPyEndAllowThreads(__tstate);
22618 if (PyErr_Occurred()) SWIG_fail;
22619 }
22620 {
22621 wxDateTime * resultptr;
22622 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
22623 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22624 }
22625 return resultobj;
22626 fail:
22627 return NULL;
22628 }
22629
22630
22631 static PyObject *_wrap_DateTime_MakeFromUTC(PyObject *, PyObject *args, PyObject *kwargs) {
22632 PyObject *resultobj = NULL;
22633 wxDateTime *arg1 = (wxDateTime *) 0 ;
22634 bool arg2 = (bool) false ;
22635 wxDateTime *result;
22636 PyObject * obj0 = 0 ;
22637 PyObject * obj1 = 0 ;
22638 char *kwnames[] = {
22639 (char *) "self",(char *) "noDST", NULL
22640 };
22641
22642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) goto fail;
22643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22644 if (SWIG_arg_fail(1)) SWIG_fail;
22645 if (obj1) {
22646 {
22647 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22648 if (SWIG_arg_fail(2)) SWIG_fail;
22649 }
22650 }
22651 {
22652 PyThreadState* __tstate = wxPyBeginAllowThreads();
22653 {
22654 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
22655 result = (wxDateTime *) &_result_ref;
22656 }
22657
22658 wxPyEndAllowThreads(__tstate);
22659 if (PyErr_Occurred()) SWIG_fail;
22660 }
22661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22662 return resultobj;
22663 fail:
22664 return NULL;
22665 }
22666
22667
22668 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
22669 PyObject *resultobj = NULL;
22670 wxDateTime *arg1 = (wxDateTime *) 0 ;
22671 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22672 int result;
22673 PyObject * obj0 = 0 ;
22674 PyObject * obj1 = 0 ;
22675 char *kwnames[] = {
22676 (char *) "self",(char *) "country", NULL
22677 };
22678
22679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
22680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22681 if (SWIG_arg_fail(1)) SWIG_fail;
22682 if (obj1) {
22683 {
22684 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
22685 if (SWIG_arg_fail(2)) SWIG_fail;
22686 }
22687 }
22688 {
22689 PyThreadState* __tstate = wxPyBeginAllowThreads();
22690 result = (int)(arg1)->IsDST(arg2);
22691
22692 wxPyEndAllowThreads(__tstate);
22693 if (PyErr_Occurred()) SWIG_fail;
22694 }
22695 {
22696 resultobj = SWIG_From_int(static_cast<int >(result));
22697 }
22698 return resultobj;
22699 fail:
22700 return NULL;
22701 }
22702
22703
22704 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
22705 PyObject *resultobj = NULL;
22706 wxDateTime *arg1 = (wxDateTime *) 0 ;
22707 bool result;
22708 PyObject * obj0 = 0 ;
22709 char *kwnames[] = {
22710 (char *) "self", NULL
22711 };
22712
22713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
22714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22715 if (SWIG_arg_fail(1)) SWIG_fail;
22716 {
22717 PyThreadState* __tstate = wxPyBeginAllowThreads();
22718 result = (bool)((wxDateTime const *)arg1)->IsValid();
22719
22720 wxPyEndAllowThreads(__tstate);
22721 if (PyErr_Occurred()) SWIG_fail;
22722 }
22723 {
22724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22725 }
22726 return resultobj;
22727 fail:
22728 return NULL;
22729 }
22730
22731
22732 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
22733 PyObject *resultobj = NULL;
22734 wxDateTime *arg1 = (wxDateTime *) 0 ;
22735 time_t result;
22736 PyObject * obj0 = 0 ;
22737 char *kwnames[] = {
22738 (char *) "self", NULL
22739 };
22740
22741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
22742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22743 if (SWIG_arg_fail(1)) SWIG_fail;
22744 {
22745 PyThreadState* __tstate = wxPyBeginAllowThreads();
22746 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
22747
22748 wxPyEndAllowThreads(__tstate);
22749 if (PyErr_Occurred()) SWIG_fail;
22750 }
22751 {
22752 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
22753 }
22754 return resultobj;
22755 fail:
22756 return NULL;
22757 }
22758
22759
22760 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
22761 PyObject *resultobj = NULL;
22762 wxDateTime *arg1 = (wxDateTime *) 0 ;
22763 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22764 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22765 int result;
22766 bool temp2 = false ;
22767 PyObject * obj0 = 0 ;
22768 PyObject * obj1 = 0 ;
22769 char *kwnames[] = {
22770 (char *) "self",(char *) "tz", NULL
22771 };
22772
22773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
22774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22775 if (SWIG_arg_fail(1)) SWIG_fail;
22776 if (obj1) {
22777 {
22778 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22779 temp2 = true;
22780 }
22781 }
22782 {
22783 PyThreadState* __tstate = wxPyBeginAllowThreads();
22784 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
22785
22786 wxPyEndAllowThreads(__tstate);
22787 if (PyErr_Occurred()) SWIG_fail;
22788 }
22789 {
22790 resultobj = SWIG_From_int(static_cast<int >(result));
22791 }
22792 {
22793 if (temp2) delete arg2;
22794 }
22795 return resultobj;
22796 fail:
22797 {
22798 if (temp2) delete arg2;
22799 }
22800 return NULL;
22801 }
22802
22803
22804 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
22805 PyObject *resultobj = NULL;
22806 wxDateTime *arg1 = (wxDateTime *) 0 ;
22807 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22808 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22809 wxDateTime::Month result;
22810 bool temp2 = false ;
22811 PyObject * obj0 = 0 ;
22812 PyObject * obj1 = 0 ;
22813 char *kwnames[] = {
22814 (char *) "self",(char *) "tz", NULL
22815 };
22816
22817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
22818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22819 if (SWIG_arg_fail(1)) SWIG_fail;
22820 if (obj1) {
22821 {
22822 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22823 temp2 = true;
22824 }
22825 }
22826 {
22827 PyThreadState* __tstate = wxPyBeginAllowThreads();
22828 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
22829
22830 wxPyEndAllowThreads(__tstate);
22831 if (PyErr_Occurred()) SWIG_fail;
22832 }
22833 resultobj = SWIG_From_int((result));
22834 {
22835 if (temp2) delete arg2;
22836 }
22837 return resultobj;
22838 fail:
22839 {
22840 if (temp2) delete arg2;
22841 }
22842 return NULL;
22843 }
22844
22845
22846 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
22847 PyObject *resultobj = NULL;
22848 wxDateTime *arg1 = (wxDateTime *) 0 ;
22849 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22850 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22851 int result;
22852 bool temp2 = false ;
22853 PyObject * obj0 = 0 ;
22854 PyObject * obj1 = 0 ;
22855 char *kwnames[] = {
22856 (char *) "self",(char *) "tz", NULL
22857 };
22858
22859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
22860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22861 if (SWIG_arg_fail(1)) SWIG_fail;
22862 if (obj1) {
22863 {
22864 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22865 temp2 = true;
22866 }
22867 }
22868 {
22869 PyThreadState* __tstate = wxPyBeginAllowThreads();
22870 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
22871
22872 wxPyEndAllowThreads(__tstate);
22873 if (PyErr_Occurred()) SWIG_fail;
22874 }
22875 {
22876 resultobj = SWIG_From_int(static_cast<int >(result));
22877 }
22878 {
22879 if (temp2) delete arg2;
22880 }
22881 return resultobj;
22882 fail:
22883 {
22884 if (temp2) delete arg2;
22885 }
22886 return NULL;
22887 }
22888
22889
22890 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
22891 PyObject *resultobj = NULL;
22892 wxDateTime *arg1 = (wxDateTime *) 0 ;
22893 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22894 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22895 wxDateTime::WeekDay result;
22896 bool temp2 = false ;
22897 PyObject * obj0 = 0 ;
22898 PyObject * obj1 = 0 ;
22899 char *kwnames[] = {
22900 (char *) "self",(char *) "tz", NULL
22901 };
22902
22903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
22904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22905 if (SWIG_arg_fail(1)) SWIG_fail;
22906 if (obj1) {
22907 {
22908 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22909 temp2 = true;
22910 }
22911 }
22912 {
22913 PyThreadState* __tstate = wxPyBeginAllowThreads();
22914 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
22915
22916 wxPyEndAllowThreads(__tstate);
22917 if (PyErr_Occurred()) SWIG_fail;
22918 }
22919 resultobj = SWIG_From_int((result));
22920 {
22921 if (temp2) delete arg2;
22922 }
22923 return resultobj;
22924 fail:
22925 {
22926 if (temp2) delete arg2;
22927 }
22928 return NULL;
22929 }
22930
22931
22932 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
22933 PyObject *resultobj = NULL;
22934 wxDateTime *arg1 = (wxDateTime *) 0 ;
22935 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22936 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22937 int result;
22938 bool temp2 = false ;
22939 PyObject * obj0 = 0 ;
22940 PyObject * obj1 = 0 ;
22941 char *kwnames[] = {
22942 (char *) "self",(char *) "tz", NULL
22943 };
22944
22945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
22946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22947 if (SWIG_arg_fail(1)) SWIG_fail;
22948 if (obj1) {
22949 {
22950 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22951 temp2 = true;
22952 }
22953 }
22954 {
22955 PyThreadState* __tstate = wxPyBeginAllowThreads();
22956 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
22957
22958 wxPyEndAllowThreads(__tstate);
22959 if (PyErr_Occurred()) SWIG_fail;
22960 }
22961 {
22962 resultobj = SWIG_From_int(static_cast<int >(result));
22963 }
22964 {
22965 if (temp2) delete arg2;
22966 }
22967 return resultobj;
22968 fail:
22969 {
22970 if (temp2) delete arg2;
22971 }
22972 return NULL;
22973 }
22974
22975
22976 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
22977 PyObject *resultobj = NULL;
22978 wxDateTime *arg1 = (wxDateTime *) 0 ;
22979 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
22980 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
22981 int result;
22982 bool temp2 = false ;
22983 PyObject * obj0 = 0 ;
22984 PyObject * obj1 = 0 ;
22985 char *kwnames[] = {
22986 (char *) "self",(char *) "tz", NULL
22987 };
22988
22989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
22990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22991 if (SWIG_arg_fail(1)) SWIG_fail;
22992 if (obj1) {
22993 {
22994 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
22995 temp2 = true;
22996 }
22997 }
22998 {
22999 PyThreadState* __tstate = wxPyBeginAllowThreads();
23000 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
23001
23002 wxPyEndAllowThreads(__tstate);
23003 if (PyErr_Occurred()) SWIG_fail;
23004 }
23005 {
23006 resultobj = SWIG_From_int(static_cast<int >(result));
23007 }
23008 {
23009 if (temp2) delete arg2;
23010 }
23011 return resultobj;
23012 fail:
23013 {
23014 if (temp2) delete arg2;
23015 }
23016 return NULL;
23017 }
23018
23019
23020 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
23021 PyObject *resultobj = NULL;
23022 wxDateTime *arg1 = (wxDateTime *) 0 ;
23023 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
23024 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
23025 int result;
23026 bool temp2 = false ;
23027 PyObject * obj0 = 0 ;
23028 PyObject * obj1 = 0 ;
23029 char *kwnames[] = {
23030 (char *) "self",(char *) "tz", NULL
23031 };
23032
23033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
23034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23035 if (SWIG_arg_fail(1)) SWIG_fail;
23036 if (obj1) {
23037 {
23038 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
23039 temp2 = true;
23040 }
23041 }
23042 {
23043 PyThreadState* __tstate = wxPyBeginAllowThreads();
23044 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
23045
23046 wxPyEndAllowThreads(__tstate);
23047 if (PyErr_Occurred()) SWIG_fail;
23048 }
23049 {
23050 resultobj = SWIG_From_int(static_cast<int >(result));
23051 }
23052 {
23053 if (temp2) delete arg2;
23054 }
23055 return resultobj;
23056 fail:
23057 {
23058 if (temp2) delete arg2;
23059 }
23060 return NULL;
23061 }
23062
23063
23064 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
23065 PyObject *resultobj = NULL;
23066 wxDateTime *arg1 = (wxDateTime *) 0 ;
23067 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
23068 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
23069 int result;
23070 bool temp2 = false ;
23071 PyObject * obj0 = 0 ;
23072 PyObject * obj1 = 0 ;
23073 char *kwnames[] = {
23074 (char *) "self",(char *) "tz", NULL
23075 };
23076
23077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
23078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23079 if (SWIG_arg_fail(1)) SWIG_fail;
23080 if (obj1) {
23081 {
23082 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
23083 temp2 = true;
23084 }
23085 }
23086 {
23087 PyThreadState* __tstate = wxPyBeginAllowThreads();
23088 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
23089
23090 wxPyEndAllowThreads(__tstate);
23091 if (PyErr_Occurred()) SWIG_fail;
23092 }
23093 {
23094 resultobj = SWIG_From_int(static_cast<int >(result));
23095 }
23096 {
23097 if (temp2) delete arg2;
23098 }
23099 return resultobj;
23100 fail:
23101 {
23102 if (temp2) delete arg2;
23103 }
23104 return NULL;
23105 }
23106
23107
23108 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
23109 PyObject *resultobj = NULL;
23110 wxDateTime *arg1 = (wxDateTime *) 0 ;
23111 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
23112 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
23113 int result;
23114 bool temp2 = false ;
23115 PyObject * obj0 = 0 ;
23116 PyObject * obj1 = 0 ;
23117 char *kwnames[] = {
23118 (char *) "self",(char *) "tz", NULL
23119 };
23120
23121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
23122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23123 if (SWIG_arg_fail(1)) SWIG_fail;
23124 if (obj1) {
23125 {
23126 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
23127 temp2 = true;
23128 }
23129 }
23130 {
23131 PyThreadState* __tstate = wxPyBeginAllowThreads();
23132 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
23133
23134 wxPyEndAllowThreads(__tstate);
23135 if (PyErr_Occurred()) SWIG_fail;
23136 }
23137 {
23138 resultobj = SWIG_From_int(static_cast<int >(result));
23139 }
23140 {
23141 if (temp2) delete arg2;
23142 }
23143 return resultobj;
23144 fail:
23145 {
23146 if (temp2) delete arg2;
23147 }
23148 return NULL;
23149 }
23150
23151
23152 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
23153 PyObject *resultobj = NULL;
23154 wxDateTime *arg1 = (wxDateTime *) 0 ;
23155 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23156 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23157 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23158 int result;
23159 bool temp3 = false ;
23160 PyObject * obj0 = 0 ;
23161 PyObject * obj1 = 0 ;
23162 PyObject * obj2 = 0 ;
23163 char *kwnames[] = {
23164 (char *) "self",(char *) "flags",(char *) "tz", NULL
23165 };
23166
23167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
23168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23169 if (SWIG_arg_fail(1)) SWIG_fail;
23170 if (obj1) {
23171 {
23172 arg2 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj1));
23173 if (SWIG_arg_fail(2)) SWIG_fail;
23174 }
23175 }
23176 if (obj2) {
23177 {
23178 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23179 temp3 = true;
23180 }
23181 }
23182 {
23183 PyThreadState* __tstate = wxPyBeginAllowThreads();
23184 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
23185
23186 wxPyEndAllowThreads(__tstate);
23187 if (PyErr_Occurred()) SWIG_fail;
23188 }
23189 {
23190 resultobj = SWIG_From_int(static_cast<int >(result));
23191 }
23192 {
23193 if (temp3) delete arg3;
23194 }
23195 return resultobj;
23196 fail:
23197 {
23198 if (temp3) delete arg3;
23199 }
23200 return NULL;
23201 }
23202
23203
23204 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
23205 PyObject *resultobj = NULL;
23206 wxDateTime *arg1 = (wxDateTime *) 0 ;
23207 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23208 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23209 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23210 int result;
23211 bool temp3 = false ;
23212 PyObject * obj0 = 0 ;
23213 PyObject * obj1 = 0 ;
23214 PyObject * obj2 = 0 ;
23215 char *kwnames[] = {
23216 (char *) "self",(char *) "flags",(char *) "tz", NULL
23217 };
23218
23219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
23220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23221 if (SWIG_arg_fail(1)) SWIG_fail;
23222 if (obj1) {
23223 {
23224 arg2 = static_cast<wxDateTime::WeekFlags >(SWIG_As_int(obj1));
23225 if (SWIG_arg_fail(2)) SWIG_fail;
23226 }
23227 }
23228 if (obj2) {
23229 {
23230 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23231 temp3 = true;
23232 }
23233 }
23234 {
23235 PyThreadState* __tstate = wxPyBeginAllowThreads();
23236 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
23237
23238 wxPyEndAllowThreads(__tstate);
23239 if (PyErr_Occurred()) SWIG_fail;
23240 }
23241 {
23242 resultobj = SWIG_From_int(static_cast<int >(result));
23243 }
23244 {
23245 if (temp3) delete arg3;
23246 }
23247 return resultobj;
23248 fail:
23249 {
23250 if (temp3) delete arg3;
23251 }
23252 return NULL;
23253 }
23254
23255
23256 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
23257 PyObject *resultobj = NULL;
23258 wxDateTime *arg1 = (wxDateTime *) 0 ;
23259 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23260 bool result;
23261 PyObject * obj0 = 0 ;
23262 PyObject * obj1 = 0 ;
23263 char *kwnames[] = {
23264 (char *) "self",(char *) "country", NULL
23265 };
23266
23267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
23268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23269 if (SWIG_arg_fail(1)) SWIG_fail;
23270 if (obj1) {
23271 {
23272 arg2 = static_cast<wxDateTime::Country >(SWIG_As_int(obj1));
23273 if (SWIG_arg_fail(2)) SWIG_fail;
23274 }
23275 }
23276 {
23277 PyThreadState* __tstate = wxPyBeginAllowThreads();
23278 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
23279
23280 wxPyEndAllowThreads(__tstate);
23281 if (PyErr_Occurred()) SWIG_fail;
23282 }
23283 {
23284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23285 }
23286 return resultobj;
23287 fail:
23288 return NULL;
23289 }
23290
23291
23292 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
23293 PyObject *resultobj = NULL;
23294 wxDateTime *arg1 = (wxDateTime *) 0 ;
23295 wxDateTime *arg2 = 0 ;
23296 bool result;
23297 PyObject * obj0 = 0 ;
23298 PyObject * obj1 = 0 ;
23299 char *kwnames[] = {
23300 (char *) "self",(char *) "datetime", NULL
23301 };
23302
23303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
23304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23305 if (SWIG_arg_fail(1)) SWIG_fail;
23306 {
23307 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23308 if (SWIG_arg_fail(2)) SWIG_fail;
23309 if (arg2 == NULL) {
23310 SWIG_null_ref("wxDateTime");
23311 }
23312 if (SWIG_arg_fail(2)) SWIG_fail;
23313 }
23314 {
23315 PyThreadState* __tstate = wxPyBeginAllowThreads();
23316 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
23317
23318 wxPyEndAllowThreads(__tstate);
23319 if (PyErr_Occurred()) SWIG_fail;
23320 }
23321 {
23322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23323 }
23324 return resultobj;
23325 fail:
23326 return NULL;
23327 }
23328
23329
23330 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
23331 PyObject *resultobj = NULL;
23332 wxDateTime *arg1 = (wxDateTime *) 0 ;
23333 wxDateTime *arg2 = 0 ;
23334 bool result;
23335 PyObject * obj0 = 0 ;
23336 PyObject * obj1 = 0 ;
23337 char *kwnames[] = {
23338 (char *) "self",(char *) "datetime", NULL
23339 };
23340
23341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
23342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23343 if (SWIG_arg_fail(1)) SWIG_fail;
23344 {
23345 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23346 if (SWIG_arg_fail(2)) SWIG_fail;
23347 if (arg2 == NULL) {
23348 SWIG_null_ref("wxDateTime");
23349 }
23350 if (SWIG_arg_fail(2)) SWIG_fail;
23351 }
23352 {
23353 PyThreadState* __tstate = wxPyBeginAllowThreads();
23354 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
23355
23356 wxPyEndAllowThreads(__tstate);
23357 if (PyErr_Occurred()) SWIG_fail;
23358 }
23359 {
23360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23361 }
23362 return resultobj;
23363 fail:
23364 return NULL;
23365 }
23366
23367
23368 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
23369 PyObject *resultobj = NULL;
23370 wxDateTime *arg1 = (wxDateTime *) 0 ;
23371 wxDateTime *arg2 = 0 ;
23372 bool result;
23373 PyObject * obj0 = 0 ;
23374 PyObject * obj1 = 0 ;
23375 char *kwnames[] = {
23376 (char *) "self",(char *) "datetime", NULL
23377 };
23378
23379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
23380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23381 if (SWIG_arg_fail(1)) SWIG_fail;
23382 {
23383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23384 if (SWIG_arg_fail(2)) SWIG_fail;
23385 if (arg2 == NULL) {
23386 SWIG_null_ref("wxDateTime");
23387 }
23388 if (SWIG_arg_fail(2)) SWIG_fail;
23389 }
23390 {
23391 PyThreadState* __tstate = wxPyBeginAllowThreads();
23392 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
23393
23394 wxPyEndAllowThreads(__tstate);
23395 if (PyErr_Occurred()) SWIG_fail;
23396 }
23397 {
23398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23399 }
23400 return resultobj;
23401 fail:
23402 return NULL;
23403 }
23404
23405
23406 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
23407 PyObject *resultobj = NULL;
23408 wxDateTime *arg1 = (wxDateTime *) 0 ;
23409 wxDateTime *arg2 = 0 ;
23410 wxDateTime *arg3 = 0 ;
23411 bool result;
23412 PyObject * obj0 = 0 ;
23413 PyObject * obj1 = 0 ;
23414 PyObject * obj2 = 0 ;
23415 char *kwnames[] = {
23416 (char *) "self",(char *) "t1",(char *) "t2", NULL
23417 };
23418
23419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
23420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23421 if (SWIG_arg_fail(1)) SWIG_fail;
23422 {
23423 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23424 if (SWIG_arg_fail(2)) SWIG_fail;
23425 if (arg2 == NULL) {
23426 SWIG_null_ref("wxDateTime");
23427 }
23428 if (SWIG_arg_fail(2)) SWIG_fail;
23429 }
23430 {
23431 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23432 if (SWIG_arg_fail(3)) SWIG_fail;
23433 if (arg3 == NULL) {
23434 SWIG_null_ref("wxDateTime");
23435 }
23436 if (SWIG_arg_fail(3)) SWIG_fail;
23437 }
23438 {
23439 PyThreadState* __tstate = wxPyBeginAllowThreads();
23440 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
23441
23442 wxPyEndAllowThreads(__tstate);
23443 if (PyErr_Occurred()) SWIG_fail;
23444 }
23445 {
23446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23447 }
23448 return resultobj;
23449 fail:
23450 return NULL;
23451 }
23452
23453
23454 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
23455 PyObject *resultobj = NULL;
23456 wxDateTime *arg1 = (wxDateTime *) 0 ;
23457 wxDateTime *arg2 = 0 ;
23458 wxDateTime *arg3 = 0 ;
23459 bool result;
23460 PyObject * obj0 = 0 ;
23461 PyObject * obj1 = 0 ;
23462 PyObject * obj2 = 0 ;
23463 char *kwnames[] = {
23464 (char *) "self",(char *) "t1",(char *) "t2", NULL
23465 };
23466
23467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
23468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23469 if (SWIG_arg_fail(1)) SWIG_fail;
23470 {
23471 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23472 if (SWIG_arg_fail(2)) SWIG_fail;
23473 if (arg2 == NULL) {
23474 SWIG_null_ref("wxDateTime");
23475 }
23476 if (SWIG_arg_fail(2)) SWIG_fail;
23477 }
23478 {
23479 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23480 if (SWIG_arg_fail(3)) SWIG_fail;
23481 if (arg3 == NULL) {
23482 SWIG_null_ref("wxDateTime");
23483 }
23484 if (SWIG_arg_fail(3)) SWIG_fail;
23485 }
23486 {
23487 PyThreadState* __tstate = wxPyBeginAllowThreads();
23488 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
23489
23490 wxPyEndAllowThreads(__tstate);
23491 if (PyErr_Occurred()) SWIG_fail;
23492 }
23493 {
23494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23495 }
23496 return resultobj;
23497 fail:
23498 return NULL;
23499 }
23500
23501
23502 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
23503 PyObject *resultobj = NULL;
23504 wxDateTime *arg1 = (wxDateTime *) 0 ;
23505 wxDateTime *arg2 = 0 ;
23506 bool result;
23507 PyObject * obj0 = 0 ;
23508 PyObject * obj1 = 0 ;
23509 char *kwnames[] = {
23510 (char *) "self",(char *) "dt", NULL
23511 };
23512
23513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
23514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23515 if (SWIG_arg_fail(1)) SWIG_fail;
23516 {
23517 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23518 if (SWIG_arg_fail(2)) SWIG_fail;
23519 if (arg2 == NULL) {
23520 SWIG_null_ref("wxDateTime");
23521 }
23522 if (SWIG_arg_fail(2)) SWIG_fail;
23523 }
23524 {
23525 PyThreadState* __tstate = wxPyBeginAllowThreads();
23526 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
23527
23528 wxPyEndAllowThreads(__tstate);
23529 if (PyErr_Occurred()) SWIG_fail;
23530 }
23531 {
23532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23533 }
23534 return resultobj;
23535 fail:
23536 return NULL;
23537 }
23538
23539
23540 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
23541 PyObject *resultobj = NULL;
23542 wxDateTime *arg1 = (wxDateTime *) 0 ;
23543 wxDateTime *arg2 = 0 ;
23544 bool result;
23545 PyObject * obj0 = 0 ;
23546 PyObject * obj1 = 0 ;
23547 char *kwnames[] = {
23548 (char *) "self",(char *) "dt", NULL
23549 };
23550
23551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
23552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23553 if (SWIG_arg_fail(1)) SWIG_fail;
23554 {
23555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23556 if (SWIG_arg_fail(2)) SWIG_fail;
23557 if (arg2 == NULL) {
23558 SWIG_null_ref("wxDateTime");
23559 }
23560 if (SWIG_arg_fail(2)) SWIG_fail;
23561 }
23562 {
23563 PyThreadState* __tstate = wxPyBeginAllowThreads();
23564 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
23565
23566 wxPyEndAllowThreads(__tstate);
23567 if (PyErr_Occurred()) SWIG_fail;
23568 }
23569 {
23570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23571 }
23572 return resultobj;
23573 fail:
23574 return NULL;
23575 }
23576
23577
23578 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
23579 PyObject *resultobj = NULL;
23580 wxDateTime *arg1 = (wxDateTime *) 0 ;
23581 wxDateTime *arg2 = 0 ;
23582 wxTimeSpan *arg3 = 0 ;
23583 bool result;
23584 PyObject * obj0 = 0 ;
23585 PyObject * obj1 = 0 ;
23586 PyObject * obj2 = 0 ;
23587 char *kwnames[] = {
23588 (char *) "self",(char *) "dt",(char *) "ts", NULL
23589 };
23590
23591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
23592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23593 if (SWIG_arg_fail(1)) SWIG_fail;
23594 {
23595 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23596 if (SWIG_arg_fail(2)) SWIG_fail;
23597 if (arg2 == NULL) {
23598 SWIG_null_ref("wxDateTime");
23599 }
23600 if (SWIG_arg_fail(2)) SWIG_fail;
23601 }
23602 {
23603 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23604 if (SWIG_arg_fail(3)) SWIG_fail;
23605 if (arg3 == NULL) {
23606 SWIG_null_ref("wxTimeSpan");
23607 }
23608 if (SWIG_arg_fail(3)) SWIG_fail;
23609 }
23610 {
23611 PyThreadState* __tstate = wxPyBeginAllowThreads();
23612 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
23613
23614 wxPyEndAllowThreads(__tstate);
23615 if (PyErr_Occurred()) SWIG_fail;
23616 }
23617 {
23618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23619 }
23620 return resultobj;
23621 fail:
23622 return NULL;
23623 }
23624
23625
23626 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
23627 PyObject *resultobj = NULL;
23628 wxDateTime *arg1 = (wxDateTime *) 0 ;
23629 wxTimeSpan *arg2 = 0 ;
23630 wxDateTime *result;
23631 PyObject * obj0 = 0 ;
23632 PyObject * obj1 = 0 ;
23633 char *kwnames[] = {
23634 (char *) "self",(char *) "diff", NULL
23635 };
23636
23637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
23638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23639 if (SWIG_arg_fail(1)) SWIG_fail;
23640 {
23641 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23642 if (SWIG_arg_fail(2)) SWIG_fail;
23643 if (arg2 == NULL) {
23644 SWIG_null_ref("wxTimeSpan");
23645 }
23646 if (SWIG_arg_fail(2)) SWIG_fail;
23647 }
23648 {
23649 PyThreadState* __tstate = wxPyBeginAllowThreads();
23650 {
23651 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
23652 result = (wxDateTime *) &_result_ref;
23653 }
23654
23655 wxPyEndAllowThreads(__tstate);
23656 if (PyErr_Occurred()) SWIG_fail;
23657 }
23658 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23659 return resultobj;
23660 fail:
23661 return NULL;
23662 }
23663
23664
23665 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
23666 PyObject *resultobj = NULL;
23667 wxDateTime *arg1 = (wxDateTime *) 0 ;
23668 wxDateSpan *arg2 = 0 ;
23669 wxDateTime *result;
23670 PyObject * obj0 = 0 ;
23671 PyObject * obj1 = 0 ;
23672 char *kwnames[] = {
23673 (char *) "self",(char *) "diff", NULL
23674 };
23675
23676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
23677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23678 if (SWIG_arg_fail(1)) SWIG_fail;
23679 {
23680 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23681 if (SWIG_arg_fail(2)) SWIG_fail;
23682 if (arg2 == NULL) {
23683 SWIG_null_ref("wxDateSpan");
23684 }
23685 if (SWIG_arg_fail(2)) SWIG_fail;
23686 }
23687 {
23688 PyThreadState* __tstate = wxPyBeginAllowThreads();
23689 {
23690 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
23691 result = (wxDateTime *) &_result_ref;
23692 }
23693
23694 wxPyEndAllowThreads(__tstate);
23695 if (PyErr_Occurred()) SWIG_fail;
23696 }
23697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23698 return resultobj;
23699 fail:
23700 return NULL;
23701 }
23702
23703
23704 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
23705 PyObject *resultobj = NULL;
23706 wxDateTime *arg1 = (wxDateTime *) 0 ;
23707 wxTimeSpan *arg2 = 0 ;
23708 wxDateTime *result;
23709 PyObject * obj0 = 0 ;
23710 PyObject * obj1 = 0 ;
23711 char *kwnames[] = {
23712 (char *) "self",(char *) "diff", NULL
23713 };
23714
23715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
23716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23717 if (SWIG_arg_fail(1)) SWIG_fail;
23718 {
23719 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23720 if (SWIG_arg_fail(2)) SWIG_fail;
23721 if (arg2 == NULL) {
23722 SWIG_null_ref("wxTimeSpan");
23723 }
23724 if (SWIG_arg_fail(2)) SWIG_fail;
23725 }
23726 {
23727 PyThreadState* __tstate = wxPyBeginAllowThreads();
23728 {
23729 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
23730 result = (wxDateTime *) &_result_ref;
23731 }
23732
23733 wxPyEndAllowThreads(__tstate);
23734 if (PyErr_Occurred()) SWIG_fail;
23735 }
23736 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23737 return resultobj;
23738 fail:
23739 return NULL;
23740 }
23741
23742
23743 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
23744 PyObject *resultobj = NULL;
23745 wxDateTime *arg1 = (wxDateTime *) 0 ;
23746 wxDateSpan *arg2 = 0 ;
23747 wxDateTime *result;
23748 PyObject * obj0 = 0 ;
23749 PyObject * obj1 = 0 ;
23750 char *kwnames[] = {
23751 (char *) "self",(char *) "diff", NULL
23752 };
23753
23754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
23755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23756 if (SWIG_arg_fail(1)) SWIG_fail;
23757 {
23758 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23759 if (SWIG_arg_fail(2)) SWIG_fail;
23760 if (arg2 == NULL) {
23761 SWIG_null_ref("wxDateSpan");
23762 }
23763 if (SWIG_arg_fail(2)) SWIG_fail;
23764 }
23765 {
23766 PyThreadState* __tstate = wxPyBeginAllowThreads();
23767 {
23768 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
23769 result = (wxDateTime *) &_result_ref;
23770 }
23771
23772 wxPyEndAllowThreads(__tstate);
23773 if (PyErr_Occurred()) SWIG_fail;
23774 }
23775 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23776 return resultobj;
23777 fail:
23778 return NULL;
23779 }
23780
23781
23782 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
23783 PyObject *resultobj = NULL;
23784 wxDateTime *arg1 = (wxDateTime *) 0 ;
23785 wxDateTime *arg2 = 0 ;
23786 wxTimeSpan result;
23787 PyObject * obj0 = 0 ;
23788 PyObject * obj1 = 0 ;
23789 char *kwnames[] = {
23790 (char *) "self",(char *) "dt", NULL
23791 };
23792
23793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
23794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23795 if (SWIG_arg_fail(1)) SWIG_fail;
23796 {
23797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23798 if (SWIG_arg_fail(2)) SWIG_fail;
23799 if (arg2 == NULL) {
23800 SWIG_null_ref("wxDateTime");
23801 }
23802 if (SWIG_arg_fail(2)) SWIG_fail;
23803 }
23804 {
23805 PyThreadState* __tstate = wxPyBeginAllowThreads();
23806 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
23807
23808 wxPyEndAllowThreads(__tstate);
23809 if (PyErr_Occurred()) SWIG_fail;
23810 }
23811 {
23812 wxTimeSpan * resultptr;
23813 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
23814 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23815 }
23816 return resultobj;
23817 fail:
23818 return NULL;
23819 }
23820
23821
23822 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
23823 PyObject *resultobj = NULL;
23824 wxDateTime *arg1 = (wxDateTime *) 0 ;
23825 wxTimeSpan *arg2 = 0 ;
23826 wxDateTime *result;
23827 PyObject * obj0 = 0 ;
23828 PyObject * obj1 = 0 ;
23829
23830 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
23831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23832 if (SWIG_arg_fail(1)) SWIG_fail;
23833 {
23834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23835 if (SWIG_arg_fail(2)) SWIG_fail;
23836 if (arg2 == NULL) {
23837 SWIG_null_ref("wxTimeSpan");
23838 }
23839 if (SWIG_arg_fail(2)) SWIG_fail;
23840 }
23841 {
23842 PyThreadState* __tstate = wxPyBeginAllowThreads();
23843 {
23844 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
23845 result = (wxDateTime *) &_result_ref;
23846 }
23847
23848 wxPyEndAllowThreads(__tstate);
23849 if (PyErr_Occurred()) SWIG_fail;
23850 }
23851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
23852 return resultobj;
23853 fail:
23854 return NULL;
23855 }
23856
23857
23858 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
23859 PyObject *resultobj = NULL;
23860 wxDateTime *arg1 = (wxDateTime *) 0 ;
23861 wxDateSpan *arg2 = 0 ;
23862 wxDateTime *result;
23863 PyObject * obj0 = 0 ;
23864 PyObject * obj1 = 0 ;
23865
23866 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
23867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23868 if (SWIG_arg_fail(1)) SWIG_fail;
23869 {
23870 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23871 if (SWIG_arg_fail(2)) SWIG_fail;
23872 if (arg2 == NULL) {
23873 SWIG_null_ref("wxDateSpan");
23874 }
23875 if (SWIG_arg_fail(2)) SWIG_fail;
23876 }
23877 {
23878 PyThreadState* __tstate = wxPyBeginAllowThreads();
23879 {
23880 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
23881 result = (wxDateTime *) &_result_ref;
23882 }
23883
23884 wxPyEndAllowThreads(__tstate);
23885 if (PyErr_Occurred()) SWIG_fail;
23886 }
23887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
23888 return resultobj;
23889 fail:
23890 return NULL;
23891 }
23892
23893
23894 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
23895 int argc;
23896 PyObject *argv[3];
23897 int ii;
23898
23899 argc = PyObject_Length(args);
23900 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23901 argv[ii] = PyTuple_GetItem(args,ii);
23902 }
23903 if (argc == 2) {
23904 int _v;
23905 {
23906 void *ptr;
23907 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23908 _v = 0;
23909 PyErr_Clear();
23910 } else {
23911 _v = 1;
23912 }
23913 }
23914 if (_v) {
23915 {
23916 void *ptr = 0;
23917 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23918 _v = 0;
23919 PyErr_Clear();
23920 } else {
23921 _v = (ptr != 0);
23922 }
23923 }
23924 if (_v) {
23925 return _wrap_DateTime___iadd____SWIG_0(self,args);
23926 }
23927 }
23928 }
23929 if (argc == 2) {
23930 int _v;
23931 {
23932 void *ptr;
23933 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23934 _v = 0;
23935 PyErr_Clear();
23936 } else {
23937 _v = 1;
23938 }
23939 }
23940 if (_v) {
23941 {
23942 void *ptr = 0;
23943 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23944 _v = 0;
23945 PyErr_Clear();
23946 } else {
23947 _v = (ptr != 0);
23948 }
23949 }
23950 if (_v) {
23951 return _wrap_DateTime___iadd____SWIG_1(self,args);
23952 }
23953 }
23954 }
23955
23956 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
23957 return NULL;
23958 }
23959
23960
23961 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
23962 PyObject *resultobj = NULL;
23963 wxDateTime *arg1 = (wxDateTime *) 0 ;
23964 wxTimeSpan *arg2 = 0 ;
23965 wxDateTime *result;
23966 PyObject * obj0 = 0 ;
23967 PyObject * obj1 = 0 ;
23968
23969 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
23970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23971 if (SWIG_arg_fail(1)) SWIG_fail;
23972 {
23973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23974 if (SWIG_arg_fail(2)) SWIG_fail;
23975 if (arg2 == NULL) {
23976 SWIG_null_ref("wxTimeSpan");
23977 }
23978 if (SWIG_arg_fail(2)) SWIG_fail;
23979 }
23980 {
23981 PyThreadState* __tstate = wxPyBeginAllowThreads();
23982 {
23983 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
23984 result = (wxDateTime *) &_result_ref;
23985 }
23986
23987 wxPyEndAllowThreads(__tstate);
23988 if (PyErr_Occurred()) SWIG_fail;
23989 }
23990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
23991 return resultobj;
23992 fail:
23993 return NULL;
23994 }
23995
23996
23997 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
23998 PyObject *resultobj = NULL;
23999 wxDateTime *arg1 = (wxDateTime *) 0 ;
24000 wxDateSpan *arg2 = 0 ;
24001 wxDateTime *result;
24002 PyObject * obj0 = 0 ;
24003 PyObject * obj1 = 0 ;
24004
24005 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
24006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24007 if (SWIG_arg_fail(1)) SWIG_fail;
24008 {
24009 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
24010 if (SWIG_arg_fail(2)) SWIG_fail;
24011 if (arg2 == NULL) {
24012 SWIG_null_ref("wxDateSpan");
24013 }
24014 if (SWIG_arg_fail(2)) SWIG_fail;
24015 }
24016 {
24017 PyThreadState* __tstate = wxPyBeginAllowThreads();
24018 {
24019 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
24020 result = (wxDateTime *) &_result_ref;
24021 }
24022
24023 wxPyEndAllowThreads(__tstate);
24024 if (PyErr_Occurred()) SWIG_fail;
24025 }
24026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
24027 return resultobj;
24028 fail:
24029 return NULL;
24030 }
24031
24032
24033 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
24034 int argc;
24035 PyObject *argv[3];
24036 int ii;
24037
24038 argc = PyObject_Length(args);
24039 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
24040 argv[ii] = PyTuple_GetItem(args,ii);
24041 }
24042 if (argc == 2) {
24043 int _v;
24044 {
24045 void *ptr;
24046 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24047 _v = 0;
24048 PyErr_Clear();
24049 } else {
24050 _v = 1;
24051 }
24052 }
24053 if (_v) {
24054 {
24055 void *ptr = 0;
24056 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
24057 _v = 0;
24058 PyErr_Clear();
24059 } else {
24060 _v = (ptr != 0);
24061 }
24062 }
24063 if (_v) {
24064 return _wrap_DateTime___isub____SWIG_0(self,args);
24065 }
24066 }
24067 }
24068 if (argc == 2) {
24069 int _v;
24070 {
24071 void *ptr;
24072 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24073 _v = 0;
24074 PyErr_Clear();
24075 } else {
24076 _v = 1;
24077 }
24078 }
24079 if (_v) {
24080 {
24081 void *ptr = 0;
24082 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
24083 _v = 0;
24084 PyErr_Clear();
24085 } else {
24086 _v = (ptr != 0);
24087 }
24088 }
24089 if (_v) {
24090 return _wrap_DateTime___isub____SWIG_1(self,args);
24091 }
24092 }
24093 }
24094
24095 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
24096 return NULL;
24097 }
24098
24099
24100 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
24101 PyObject *resultobj = NULL;
24102 wxDateTime *arg1 = (wxDateTime *) 0 ;
24103 wxTimeSpan *arg2 = 0 ;
24104 wxDateTime result;
24105 PyObject * obj0 = 0 ;
24106 PyObject * obj1 = 0 ;
24107
24108 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
24109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24110 if (SWIG_arg_fail(1)) SWIG_fail;
24111 {
24112 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24113 if (SWIG_arg_fail(2)) SWIG_fail;
24114 if (arg2 == NULL) {
24115 SWIG_null_ref("wxTimeSpan");
24116 }
24117 if (SWIG_arg_fail(2)) SWIG_fail;
24118 }
24119 {
24120 PyThreadState* __tstate = wxPyBeginAllowThreads();
24121 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
24122
24123 wxPyEndAllowThreads(__tstate);
24124 if (PyErr_Occurred()) SWIG_fail;
24125 }
24126 {
24127 wxDateTime * resultptr;
24128 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
24129 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
24130 }
24131 return resultobj;
24132 fail:
24133 return NULL;
24134 }
24135
24136
24137 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
24138 PyObject *resultobj = NULL;
24139 wxDateTime *arg1 = (wxDateTime *) 0 ;
24140 wxDateSpan *arg2 = 0 ;
24141 wxDateTime result;
24142 PyObject * obj0 = 0 ;
24143 PyObject * obj1 = 0 ;
24144
24145 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
24146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24147 if (SWIG_arg_fail(1)) SWIG_fail;
24148 {
24149 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
24150 if (SWIG_arg_fail(2)) SWIG_fail;
24151 if (arg2 == NULL) {
24152 SWIG_null_ref("wxDateSpan");
24153 }
24154 if (SWIG_arg_fail(2)) SWIG_fail;
24155 }
24156 {
24157 PyThreadState* __tstate = wxPyBeginAllowThreads();
24158 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
24159
24160 wxPyEndAllowThreads(__tstate);
24161 if (PyErr_Occurred()) SWIG_fail;
24162 }
24163 {
24164 wxDateTime * resultptr;
24165 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
24166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
24167 }
24168 return resultobj;
24169 fail:
24170 return NULL;
24171 }
24172
24173
24174 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
24175 int argc;
24176 PyObject *argv[3];
24177 int ii;
24178
24179 argc = PyObject_Length(args);
24180 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
24181 argv[ii] = PyTuple_GetItem(args,ii);
24182 }
24183 if (argc == 2) {
24184 int _v;
24185 {
24186 void *ptr;
24187 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24188 _v = 0;
24189 PyErr_Clear();
24190 } else {
24191 _v = 1;
24192 }
24193 }
24194 if (_v) {
24195 {
24196 void *ptr = 0;
24197 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
24198 _v = 0;
24199 PyErr_Clear();
24200 } else {
24201 _v = (ptr != 0);
24202 }
24203 }
24204 if (_v) {
24205 return _wrap_DateTime___add____SWIG_0(self,args);
24206 }
24207 }
24208 }
24209 if (argc == 2) {
24210 int _v;
24211 {
24212 void *ptr;
24213 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24214 _v = 0;
24215 PyErr_Clear();
24216 } else {
24217 _v = 1;
24218 }
24219 }
24220 if (_v) {
24221 {
24222 void *ptr = 0;
24223 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
24224 _v = 0;
24225 PyErr_Clear();
24226 } else {
24227 _v = (ptr != 0);
24228 }
24229 }
24230 if (_v) {
24231 return _wrap_DateTime___add____SWIG_1(self,args);
24232 }
24233 }
24234 }
24235
24236 Py_INCREF(Py_NotImplemented);
24237 return Py_NotImplemented;
24238 }
24239
24240
24241 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
24242 PyObject *resultobj = NULL;
24243 wxDateTime *arg1 = (wxDateTime *) 0 ;
24244 wxDateTime *arg2 = 0 ;
24245 wxTimeSpan result;
24246 PyObject * obj0 = 0 ;
24247 PyObject * obj1 = 0 ;
24248
24249 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
24250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24251 if (SWIG_arg_fail(1)) SWIG_fail;
24252 {
24253 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24254 if (SWIG_arg_fail(2)) SWIG_fail;
24255 if (arg2 == NULL) {
24256 SWIG_null_ref("wxDateTime");
24257 }
24258 if (SWIG_arg_fail(2)) SWIG_fail;
24259 }
24260 {
24261 PyThreadState* __tstate = wxPyBeginAllowThreads();
24262 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
24263
24264 wxPyEndAllowThreads(__tstate);
24265 if (PyErr_Occurred()) SWIG_fail;
24266 }
24267 {
24268 wxTimeSpan * resultptr;
24269 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
24270 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24271 }
24272 return resultobj;
24273 fail:
24274 return NULL;
24275 }
24276
24277
24278 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
24279 PyObject *resultobj = NULL;
24280 wxDateTime *arg1 = (wxDateTime *) 0 ;
24281 wxTimeSpan *arg2 = 0 ;
24282 wxDateTime result;
24283 PyObject * obj0 = 0 ;
24284 PyObject * obj1 = 0 ;
24285
24286 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
24287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24288 if (SWIG_arg_fail(1)) SWIG_fail;
24289 {
24290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24291 if (SWIG_arg_fail(2)) SWIG_fail;
24292 if (arg2 == NULL) {
24293 SWIG_null_ref("wxTimeSpan");
24294 }
24295 if (SWIG_arg_fail(2)) SWIG_fail;
24296 }
24297 {
24298 PyThreadState* __tstate = wxPyBeginAllowThreads();
24299 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
24300
24301 wxPyEndAllowThreads(__tstate);
24302 if (PyErr_Occurred()) SWIG_fail;
24303 }
24304 {
24305 wxDateTime * resultptr;
24306 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
24307 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
24308 }
24309 return resultobj;
24310 fail:
24311 return NULL;
24312 }
24313
24314
24315 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
24316 PyObject *resultobj = NULL;
24317 wxDateTime *arg1 = (wxDateTime *) 0 ;
24318 wxDateSpan *arg2 = 0 ;
24319 wxDateTime result;
24320 PyObject * obj0 = 0 ;
24321 PyObject * obj1 = 0 ;
24322
24323 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
24324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24325 if (SWIG_arg_fail(1)) SWIG_fail;
24326 {
24327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
24328 if (SWIG_arg_fail(2)) SWIG_fail;
24329 if (arg2 == NULL) {
24330 SWIG_null_ref("wxDateSpan");
24331 }
24332 if (SWIG_arg_fail(2)) SWIG_fail;
24333 }
24334 {
24335 PyThreadState* __tstate = wxPyBeginAllowThreads();
24336 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
24337
24338 wxPyEndAllowThreads(__tstate);
24339 if (PyErr_Occurred()) SWIG_fail;
24340 }
24341 {
24342 wxDateTime * resultptr;
24343 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
24344 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
24345 }
24346 return resultobj;
24347 fail:
24348 return NULL;
24349 }
24350
24351
24352 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
24353 int argc;
24354 PyObject *argv[3];
24355 int ii;
24356
24357 argc = PyObject_Length(args);
24358 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
24359 argv[ii] = PyTuple_GetItem(args,ii);
24360 }
24361 if (argc == 2) {
24362 int _v;
24363 {
24364 void *ptr;
24365 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24366 _v = 0;
24367 PyErr_Clear();
24368 } else {
24369 _v = 1;
24370 }
24371 }
24372 if (_v) {
24373 {
24374 void *ptr = 0;
24375 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24376 _v = 0;
24377 PyErr_Clear();
24378 } else {
24379 _v = (ptr != 0);
24380 }
24381 }
24382 if (_v) {
24383 return _wrap_DateTime___sub____SWIG_0(self,args);
24384 }
24385 }
24386 }
24387 if (argc == 2) {
24388 int _v;
24389 {
24390 void *ptr;
24391 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24392 _v = 0;
24393 PyErr_Clear();
24394 } else {
24395 _v = 1;
24396 }
24397 }
24398 if (_v) {
24399 {
24400 void *ptr = 0;
24401 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
24402 _v = 0;
24403 PyErr_Clear();
24404 } else {
24405 _v = (ptr != 0);
24406 }
24407 }
24408 if (_v) {
24409 return _wrap_DateTime___sub____SWIG_1(self,args);
24410 }
24411 }
24412 }
24413 if (argc == 2) {
24414 int _v;
24415 {
24416 void *ptr;
24417 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
24418 _v = 0;
24419 PyErr_Clear();
24420 } else {
24421 _v = 1;
24422 }
24423 }
24424 if (_v) {
24425 {
24426 void *ptr = 0;
24427 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
24428 _v = 0;
24429 PyErr_Clear();
24430 } else {
24431 _v = (ptr != 0);
24432 }
24433 }
24434 if (_v) {
24435 return _wrap_DateTime___sub____SWIG_2(self,args);
24436 }
24437 }
24438 }
24439
24440 Py_INCREF(Py_NotImplemented);
24441 return Py_NotImplemented;
24442 }
24443
24444
24445 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24446 PyObject *resultobj = NULL;
24447 wxDateTime *arg1 = (wxDateTime *) 0 ;
24448 wxDateTime *arg2 = (wxDateTime *) 0 ;
24449 bool result;
24450 PyObject * obj0 = 0 ;
24451 PyObject * obj1 = 0 ;
24452 char *kwnames[] = {
24453 (char *) "self",(char *) "other", NULL
24454 };
24455
24456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
24457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24458 if (SWIG_arg_fail(1)) SWIG_fail;
24459 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24460 if (SWIG_arg_fail(2)) SWIG_fail;
24461 {
24462 PyThreadState* __tstate = wxPyBeginAllowThreads();
24463 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
24464
24465 wxPyEndAllowThreads(__tstate);
24466 if (PyErr_Occurred()) SWIG_fail;
24467 }
24468 {
24469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24470 }
24471 return resultobj;
24472 fail:
24473 return NULL;
24474 }
24475
24476
24477 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24478 PyObject *resultobj = NULL;
24479 wxDateTime *arg1 = (wxDateTime *) 0 ;
24480 wxDateTime *arg2 = (wxDateTime *) 0 ;
24481 bool result;
24482 PyObject * obj0 = 0 ;
24483 PyObject * obj1 = 0 ;
24484 char *kwnames[] = {
24485 (char *) "self",(char *) "other", NULL
24486 };
24487
24488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
24489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24490 if (SWIG_arg_fail(1)) SWIG_fail;
24491 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24492 if (SWIG_arg_fail(2)) SWIG_fail;
24493 {
24494 PyThreadState* __tstate = wxPyBeginAllowThreads();
24495 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
24496
24497 wxPyEndAllowThreads(__tstate);
24498 if (PyErr_Occurred()) SWIG_fail;
24499 }
24500 {
24501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24502 }
24503 return resultobj;
24504 fail:
24505 return NULL;
24506 }
24507
24508
24509 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24510 PyObject *resultobj = NULL;
24511 wxDateTime *arg1 = (wxDateTime *) 0 ;
24512 wxDateTime *arg2 = (wxDateTime *) 0 ;
24513 bool result;
24514 PyObject * obj0 = 0 ;
24515 PyObject * obj1 = 0 ;
24516 char *kwnames[] = {
24517 (char *) "self",(char *) "other", NULL
24518 };
24519
24520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
24521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24522 if (SWIG_arg_fail(1)) SWIG_fail;
24523 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24524 if (SWIG_arg_fail(2)) SWIG_fail;
24525 {
24526 PyThreadState* __tstate = wxPyBeginAllowThreads();
24527 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
24528
24529 wxPyEndAllowThreads(__tstate);
24530 if (PyErr_Occurred()) SWIG_fail;
24531 }
24532 {
24533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24534 }
24535 return resultobj;
24536 fail:
24537 return NULL;
24538 }
24539
24540
24541 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24542 PyObject *resultobj = NULL;
24543 wxDateTime *arg1 = (wxDateTime *) 0 ;
24544 wxDateTime *arg2 = (wxDateTime *) 0 ;
24545 bool result;
24546 PyObject * obj0 = 0 ;
24547 PyObject * obj1 = 0 ;
24548 char *kwnames[] = {
24549 (char *) "self",(char *) "other", NULL
24550 };
24551
24552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
24553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24554 if (SWIG_arg_fail(1)) SWIG_fail;
24555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24556 if (SWIG_arg_fail(2)) SWIG_fail;
24557 {
24558 PyThreadState* __tstate = wxPyBeginAllowThreads();
24559 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
24560
24561 wxPyEndAllowThreads(__tstate);
24562 if (PyErr_Occurred()) SWIG_fail;
24563 }
24564 {
24565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24566 }
24567 return resultobj;
24568 fail:
24569 return NULL;
24570 }
24571
24572
24573 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24574 PyObject *resultobj = NULL;
24575 wxDateTime *arg1 = (wxDateTime *) 0 ;
24576 wxDateTime *arg2 = (wxDateTime *) 0 ;
24577 bool result;
24578 PyObject * obj0 = 0 ;
24579 PyObject * obj1 = 0 ;
24580 char *kwnames[] = {
24581 (char *) "self",(char *) "other", NULL
24582 };
24583
24584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
24585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24586 if (SWIG_arg_fail(1)) SWIG_fail;
24587 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24588 if (SWIG_arg_fail(2)) SWIG_fail;
24589 {
24590 PyThreadState* __tstate = wxPyBeginAllowThreads();
24591 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
24592
24593 wxPyEndAllowThreads(__tstate);
24594 if (PyErr_Occurred()) SWIG_fail;
24595 }
24596 {
24597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24598 }
24599 return resultobj;
24600 fail:
24601 return NULL;
24602 }
24603
24604
24605 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24606 PyObject *resultobj = NULL;
24607 wxDateTime *arg1 = (wxDateTime *) 0 ;
24608 wxDateTime *arg2 = (wxDateTime *) 0 ;
24609 bool result;
24610 PyObject * obj0 = 0 ;
24611 PyObject * obj1 = 0 ;
24612 char *kwnames[] = {
24613 (char *) "self",(char *) "other", NULL
24614 };
24615
24616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
24617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24618 if (SWIG_arg_fail(1)) SWIG_fail;
24619 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24620 if (SWIG_arg_fail(2)) SWIG_fail;
24621 {
24622 PyThreadState* __tstate = wxPyBeginAllowThreads();
24623 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
24624
24625 wxPyEndAllowThreads(__tstate);
24626 if (PyErr_Occurred()) SWIG_fail;
24627 }
24628 {
24629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24630 }
24631 return resultobj;
24632 fail:
24633 return NULL;
24634 }
24635
24636
24637 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
24638 PyObject *resultobj = NULL;
24639 wxDateTime *arg1 = (wxDateTime *) 0 ;
24640 wxString *arg2 = 0 ;
24641 int result;
24642 bool temp2 = false ;
24643 PyObject * obj0 = 0 ;
24644 PyObject * obj1 = 0 ;
24645 char *kwnames[] = {
24646 (char *) "self",(char *) "date", NULL
24647 };
24648
24649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
24650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24651 if (SWIG_arg_fail(1)) SWIG_fail;
24652 {
24653 arg2 = wxString_in_helper(obj1);
24654 if (arg2 == NULL) SWIG_fail;
24655 temp2 = true;
24656 }
24657 {
24658 PyThreadState* __tstate = wxPyBeginAllowThreads();
24659 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
24660
24661 wxPyEndAllowThreads(__tstate);
24662 if (PyErr_Occurred()) SWIG_fail;
24663 }
24664 {
24665 resultobj = SWIG_From_int(static_cast<int >(result));
24666 }
24667 {
24668 if (temp2)
24669 delete arg2;
24670 }
24671 return resultobj;
24672 fail:
24673 {
24674 if (temp2)
24675 delete arg2;
24676 }
24677 return NULL;
24678 }
24679
24680
24681 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
24682 PyObject *resultobj = NULL;
24683 wxDateTime *arg1 = (wxDateTime *) 0 ;
24684 wxString *arg2 = 0 ;
24685 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
24686 wxString *arg3 = (wxString *) &arg3_defvalue ;
24687 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
24688 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
24689 int result;
24690 bool temp2 = false ;
24691 bool temp3 = false ;
24692 PyObject * obj0 = 0 ;
24693 PyObject * obj1 = 0 ;
24694 PyObject * obj2 = 0 ;
24695 PyObject * obj3 = 0 ;
24696 char *kwnames[] = {
24697 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
24698 };
24699
24700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24702 if (SWIG_arg_fail(1)) SWIG_fail;
24703 {
24704 arg2 = wxString_in_helper(obj1);
24705 if (arg2 == NULL) SWIG_fail;
24706 temp2 = true;
24707 }
24708 if (obj2) {
24709 {
24710 arg3 = wxString_in_helper(obj2);
24711 if (arg3 == NULL) SWIG_fail;
24712 temp3 = true;
24713 }
24714 }
24715 if (obj3) {
24716 {
24717 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24718 if (SWIG_arg_fail(4)) SWIG_fail;
24719 if (arg4 == NULL) {
24720 SWIG_null_ref("wxDateTime");
24721 }
24722 if (SWIG_arg_fail(4)) SWIG_fail;
24723 }
24724 }
24725 {
24726 PyThreadState* __tstate = wxPyBeginAllowThreads();
24727 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
24728
24729 wxPyEndAllowThreads(__tstate);
24730 if (PyErr_Occurred()) SWIG_fail;
24731 }
24732 {
24733 resultobj = SWIG_From_int(static_cast<int >(result));
24734 }
24735 {
24736 if (temp2)
24737 delete arg2;
24738 }
24739 {
24740 if (temp3)
24741 delete arg3;
24742 }
24743 return resultobj;
24744 fail:
24745 {
24746 if (temp2)
24747 delete arg2;
24748 }
24749 {
24750 if (temp3)
24751 delete arg3;
24752 }
24753 return NULL;
24754 }
24755
24756
24757 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
24758 PyObject *resultobj = NULL;
24759 wxDateTime *arg1 = (wxDateTime *) 0 ;
24760 wxString *arg2 = 0 ;
24761 int result;
24762 bool temp2 = false ;
24763 PyObject * obj0 = 0 ;
24764 PyObject * obj1 = 0 ;
24765 char *kwnames[] = {
24766 (char *) "self",(char *) "datetime", NULL
24767 };
24768
24769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
24770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24771 if (SWIG_arg_fail(1)) SWIG_fail;
24772 {
24773 arg2 = wxString_in_helper(obj1);
24774 if (arg2 == NULL) SWIG_fail;
24775 temp2 = true;
24776 }
24777 {
24778 PyThreadState* __tstate = wxPyBeginAllowThreads();
24779 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
24780
24781 wxPyEndAllowThreads(__tstate);
24782 if (PyErr_Occurred()) SWIG_fail;
24783 }
24784 {
24785 resultobj = SWIG_From_int(static_cast<int >(result));
24786 }
24787 {
24788 if (temp2)
24789 delete arg2;
24790 }
24791 return resultobj;
24792 fail:
24793 {
24794 if (temp2)
24795 delete arg2;
24796 }
24797 return NULL;
24798 }
24799
24800
24801 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
24802 PyObject *resultobj = NULL;
24803 wxDateTime *arg1 = (wxDateTime *) 0 ;
24804 wxString *arg2 = 0 ;
24805 int result;
24806 bool temp2 = false ;
24807 PyObject * obj0 = 0 ;
24808 PyObject * obj1 = 0 ;
24809 char *kwnames[] = {
24810 (char *) "self",(char *) "date", NULL
24811 };
24812
24813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
24814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24815 if (SWIG_arg_fail(1)) SWIG_fail;
24816 {
24817 arg2 = wxString_in_helper(obj1);
24818 if (arg2 == NULL) SWIG_fail;
24819 temp2 = true;
24820 }
24821 {
24822 PyThreadState* __tstate = wxPyBeginAllowThreads();
24823 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
24824
24825 wxPyEndAllowThreads(__tstate);
24826 if (PyErr_Occurred()) SWIG_fail;
24827 }
24828 {
24829 resultobj = SWIG_From_int(static_cast<int >(result));
24830 }
24831 {
24832 if (temp2)
24833 delete arg2;
24834 }
24835 return resultobj;
24836 fail:
24837 {
24838 if (temp2)
24839 delete arg2;
24840 }
24841 return NULL;
24842 }
24843
24844
24845 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
24846 PyObject *resultobj = NULL;
24847 wxDateTime *arg1 = (wxDateTime *) 0 ;
24848 wxString *arg2 = 0 ;
24849 int result;
24850 bool temp2 = false ;
24851 PyObject * obj0 = 0 ;
24852 PyObject * obj1 = 0 ;
24853 char *kwnames[] = {
24854 (char *) "self",(char *) "time", NULL
24855 };
24856
24857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
24858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24859 if (SWIG_arg_fail(1)) SWIG_fail;
24860 {
24861 arg2 = wxString_in_helper(obj1);
24862 if (arg2 == NULL) SWIG_fail;
24863 temp2 = true;
24864 }
24865 {
24866 PyThreadState* __tstate = wxPyBeginAllowThreads();
24867 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
24868
24869 wxPyEndAllowThreads(__tstate);
24870 if (PyErr_Occurred()) SWIG_fail;
24871 }
24872 {
24873 resultobj = SWIG_From_int(static_cast<int >(result));
24874 }
24875 {
24876 if (temp2)
24877 delete arg2;
24878 }
24879 return resultobj;
24880 fail:
24881 {
24882 if (temp2)
24883 delete arg2;
24884 }
24885 return NULL;
24886 }
24887
24888
24889 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
24890 PyObject *resultobj = NULL;
24891 wxDateTime *arg1 = (wxDateTime *) 0 ;
24892 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
24893 wxString *arg2 = (wxString *) &arg2_defvalue ;
24894 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
24895 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
24896 wxString result;
24897 bool temp2 = false ;
24898 bool temp3 = false ;
24899 PyObject * obj0 = 0 ;
24900 PyObject * obj1 = 0 ;
24901 PyObject * obj2 = 0 ;
24902 char *kwnames[] = {
24903 (char *) "self",(char *) "format",(char *) "tz", NULL
24904 };
24905
24906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
24907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24908 if (SWIG_arg_fail(1)) SWIG_fail;
24909 if (obj1) {
24910 {
24911 arg2 = wxString_in_helper(obj1);
24912 if (arg2 == NULL) SWIG_fail;
24913 temp2 = true;
24914 }
24915 }
24916 if (obj2) {
24917 {
24918 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
24919 temp3 = true;
24920 }
24921 }
24922 {
24923 PyThreadState* __tstate = wxPyBeginAllowThreads();
24924 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
24925
24926 wxPyEndAllowThreads(__tstate);
24927 if (PyErr_Occurred()) SWIG_fail;
24928 }
24929 {
24930 #if wxUSE_UNICODE
24931 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24932 #else
24933 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24934 #endif
24935 }
24936 {
24937 if (temp2)
24938 delete arg2;
24939 }
24940 {
24941 if (temp3) delete arg3;
24942 }
24943 return resultobj;
24944 fail:
24945 {
24946 if (temp2)
24947 delete arg2;
24948 }
24949 {
24950 if (temp3) delete arg3;
24951 }
24952 return NULL;
24953 }
24954
24955
24956 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
24957 PyObject *resultobj = NULL;
24958 wxDateTime *arg1 = (wxDateTime *) 0 ;
24959 wxString result;
24960 PyObject * obj0 = 0 ;
24961 char *kwnames[] = {
24962 (char *) "self", NULL
24963 };
24964
24965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
24966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24967 if (SWIG_arg_fail(1)) SWIG_fail;
24968 {
24969 PyThreadState* __tstate = wxPyBeginAllowThreads();
24970 result = ((wxDateTime const *)arg1)->FormatDate();
24971
24972 wxPyEndAllowThreads(__tstate);
24973 if (PyErr_Occurred()) SWIG_fail;
24974 }
24975 {
24976 #if wxUSE_UNICODE
24977 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24978 #else
24979 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24980 #endif
24981 }
24982 return resultobj;
24983 fail:
24984 return NULL;
24985 }
24986
24987
24988 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
24989 PyObject *resultobj = NULL;
24990 wxDateTime *arg1 = (wxDateTime *) 0 ;
24991 wxString result;
24992 PyObject * obj0 = 0 ;
24993 char *kwnames[] = {
24994 (char *) "self", NULL
24995 };
24996
24997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
24998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
24999 if (SWIG_arg_fail(1)) SWIG_fail;
25000 {
25001 PyThreadState* __tstate = wxPyBeginAllowThreads();
25002 result = ((wxDateTime const *)arg1)->FormatTime();
25003
25004 wxPyEndAllowThreads(__tstate);
25005 if (PyErr_Occurred()) SWIG_fail;
25006 }
25007 {
25008 #if wxUSE_UNICODE
25009 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25010 #else
25011 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25012 #endif
25013 }
25014 return resultobj;
25015 fail:
25016 return NULL;
25017 }
25018
25019
25020 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
25021 PyObject *resultobj = NULL;
25022 wxDateTime *arg1 = (wxDateTime *) 0 ;
25023 wxString result;
25024 PyObject * obj0 = 0 ;
25025 char *kwnames[] = {
25026 (char *) "self", NULL
25027 };
25028
25029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
25030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
25031 if (SWIG_arg_fail(1)) SWIG_fail;
25032 {
25033 PyThreadState* __tstate = wxPyBeginAllowThreads();
25034 result = ((wxDateTime const *)arg1)->FormatISODate();
25035
25036 wxPyEndAllowThreads(__tstate);
25037 if (PyErr_Occurred()) SWIG_fail;
25038 }
25039 {
25040 #if wxUSE_UNICODE
25041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25042 #else
25043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25044 #endif
25045 }
25046 return resultobj;
25047 fail:
25048 return NULL;
25049 }
25050
25051
25052 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
25053 PyObject *resultobj = NULL;
25054 wxDateTime *arg1 = (wxDateTime *) 0 ;
25055 wxString result;
25056 PyObject * obj0 = 0 ;
25057 char *kwnames[] = {
25058 (char *) "self", NULL
25059 };
25060
25061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
25062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
25063 if (SWIG_arg_fail(1)) SWIG_fail;
25064 {
25065 PyThreadState* __tstate = wxPyBeginAllowThreads();
25066 result = ((wxDateTime const *)arg1)->FormatISOTime();
25067
25068 wxPyEndAllowThreads(__tstate);
25069 if (PyErr_Occurred()) SWIG_fail;
25070 }
25071 {
25072 #if wxUSE_UNICODE
25073 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25074 #else
25075 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25076 #endif
25077 }
25078 return resultobj;
25079 fail:
25080 return NULL;
25081 }
25082
25083
25084 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
25085 PyObject *obj;
25086 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25087 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
25088 Py_INCREF(obj);
25089 return Py_BuildValue((char *)"");
25090 }
25091 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
25092 PyObject *resultobj = NULL;
25093 long arg1 ;
25094 wxTimeSpan result;
25095 PyObject * obj0 = 0 ;
25096 char *kwnames[] = {
25097 (char *) "sec", NULL
25098 };
25099
25100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
25101 {
25102 arg1 = static_cast<long >(SWIG_As_long(obj0));
25103 if (SWIG_arg_fail(1)) SWIG_fail;
25104 }
25105 {
25106 PyThreadState* __tstate = wxPyBeginAllowThreads();
25107 result = wxTimeSpan::Seconds(arg1);
25108
25109 wxPyEndAllowThreads(__tstate);
25110 if (PyErr_Occurred()) SWIG_fail;
25111 }
25112 {
25113 wxTimeSpan * resultptr;
25114 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25115 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25116 }
25117 return resultobj;
25118 fail:
25119 return NULL;
25120 }
25121
25122
25123 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
25124 PyObject *resultobj = NULL;
25125 wxTimeSpan result;
25126 char *kwnames[] = {
25127 NULL
25128 };
25129
25130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
25131 {
25132 PyThreadState* __tstate = wxPyBeginAllowThreads();
25133 result = wxTimeSpan::Second();
25134
25135 wxPyEndAllowThreads(__tstate);
25136 if (PyErr_Occurred()) SWIG_fail;
25137 }
25138 {
25139 wxTimeSpan * resultptr;
25140 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25141 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25142 }
25143 return resultobj;
25144 fail:
25145 return NULL;
25146 }
25147
25148
25149 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
25150 PyObject *resultobj = NULL;
25151 long arg1 ;
25152 wxTimeSpan result;
25153 PyObject * obj0 = 0 ;
25154 char *kwnames[] = {
25155 (char *) "min", NULL
25156 };
25157
25158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
25159 {
25160 arg1 = static_cast<long >(SWIG_As_long(obj0));
25161 if (SWIG_arg_fail(1)) SWIG_fail;
25162 }
25163 {
25164 PyThreadState* __tstate = wxPyBeginAllowThreads();
25165 result = wxTimeSpan::Minutes(arg1);
25166
25167 wxPyEndAllowThreads(__tstate);
25168 if (PyErr_Occurred()) SWIG_fail;
25169 }
25170 {
25171 wxTimeSpan * resultptr;
25172 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25173 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25174 }
25175 return resultobj;
25176 fail:
25177 return NULL;
25178 }
25179
25180
25181 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
25182 PyObject *resultobj = NULL;
25183 wxTimeSpan result;
25184 char *kwnames[] = {
25185 NULL
25186 };
25187
25188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
25189 {
25190 PyThreadState* __tstate = wxPyBeginAllowThreads();
25191 result = wxTimeSpan::Minute();
25192
25193 wxPyEndAllowThreads(__tstate);
25194 if (PyErr_Occurred()) SWIG_fail;
25195 }
25196 {
25197 wxTimeSpan * resultptr;
25198 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25199 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25200 }
25201 return resultobj;
25202 fail:
25203 return NULL;
25204 }
25205
25206
25207 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
25208 PyObject *resultobj = NULL;
25209 long arg1 ;
25210 wxTimeSpan result;
25211 PyObject * obj0 = 0 ;
25212 char *kwnames[] = {
25213 (char *) "hours", NULL
25214 };
25215
25216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
25217 {
25218 arg1 = static_cast<long >(SWIG_As_long(obj0));
25219 if (SWIG_arg_fail(1)) SWIG_fail;
25220 }
25221 {
25222 PyThreadState* __tstate = wxPyBeginAllowThreads();
25223 result = wxTimeSpan::Hours(arg1);
25224
25225 wxPyEndAllowThreads(__tstate);
25226 if (PyErr_Occurred()) SWIG_fail;
25227 }
25228 {
25229 wxTimeSpan * resultptr;
25230 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25231 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25232 }
25233 return resultobj;
25234 fail:
25235 return NULL;
25236 }
25237
25238
25239 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
25240 PyObject *resultobj = NULL;
25241 wxTimeSpan result;
25242 char *kwnames[] = {
25243 NULL
25244 };
25245
25246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
25247 {
25248 PyThreadState* __tstate = wxPyBeginAllowThreads();
25249 result = wxTimeSpan::Hour();
25250
25251 wxPyEndAllowThreads(__tstate);
25252 if (PyErr_Occurred()) SWIG_fail;
25253 }
25254 {
25255 wxTimeSpan * resultptr;
25256 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25257 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25258 }
25259 return resultobj;
25260 fail:
25261 return NULL;
25262 }
25263
25264
25265 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25266 PyObject *resultobj = NULL;
25267 long arg1 ;
25268 wxTimeSpan result;
25269 PyObject * obj0 = 0 ;
25270 char *kwnames[] = {
25271 (char *) "days", NULL
25272 };
25273
25274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
25275 {
25276 arg1 = static_cast<long >(SWIG_As_long(obj0));
25277 if (SWIG_arg_fail(1)) SWIG_fail;
25278 }
25279 {
25280 PyThreadState* __tstate = wxPyBeginAllowThreads();
25281 result = wxTimeSpan::Days(arg1);
25282
25283 wxPyEndAllowThreads(__tstate);
25284 if (PyErr_Occurred()) SWIG_fail;
25285 }
25286 {
25287 wxTimeSpan * resultptr;
25288 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25289 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25290 }
25291 return resultobj;
25292 fail:
25293 return NULL;
25294 }
25295
25296
25297 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25298 PyObject *resultobj = NULL;
25299 wxTimeSpan result;
25300 char *kwnames[] = {
25301 NULL
25302 };
25303
25304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
25305 {
25306 PyThreadState* __tstate = wxPyBeginAllowThreads();
25307 result = wxTimeSpan::Day();
25308
25309 wxPyEndAllowThreads(__tstate);
25310 if (PyErr_Occurred()) SWIG_fail;
25311 }
25312 {
25313 wxTimeSpan * resultptr;
25314 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25315 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25316 }
25317 return resultobj;
25318 fail:
25319 return NULL;
25320 }
25321
25322
25323 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25324 PyObject *resultobj = NULL;
25325 long arg1 ;
25326 wxTimeSpan result;
25327 PyObject * obj0 = 0 ;
25328 char *kwnames[] = {
25329 (char *) "days", NULL
25330 };
25331
25332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
25333 {
25334 arg1 = static_cast<long >(SWIG_As_long(obj0));
25335 if (SWIG_arg_fail(1)) SWIG_fail;
25336 }
25337 {
25338 PyThreadState* __tstate = wxPyBeginAllowThreads();
25339 result = wxTimeSpan::Weeks(arg1);
25340
25341 wxPyEndAllowThreads(__tstate);
25342 if (PyErr_Occurred()) SWIG_fail;
25343 }
25344 {
25345 wxTimeSpan * resultptr;
25346 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25347 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25348 }
25349 return resultobj;
25350 fail:
25351 return NULL;
25352 }
25353
25354
25355 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25356 PyObject *resultobj = NULL;
25357 wxTimeSpan result;
25358 char *kwnames[] = {
25359 NULL
25360 };
25361
25362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
25363 {
25364 PyThreadState* __tstate = wxPyBeginAllowThreads();
25365 result = wxTimeSpan::Week();
25366
25367 wxPyEndAllowThreads(__tstate);
25368 if (PyErr_Occurred()) SWIG_fail;
25369 }
25370 {
25371 wxTimeSpan * resultptr;
25372 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25373 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25374 }
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25382 PyObject *resultobj = NULL;
25383 long arg1 = (long) 0 ;
25384 long arg2 = (long) 0 ;
25385 long arg3 = (long) 0 ;
25386 long arg4 = (long) 0 ;
25387 wxTimeSpan *result;
25388 PyObject * obj0 = 0 ;
25389 PyObject * obj1 = 0 ;
25390 PyObject * obj2 = 0 ;
25391 PyObject * obj3 = 0 ;
25392 char *kwnames[] = {
25393 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
25394 };
25395
25396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25397 if (obj0) {
25398 {
25399 arg1 = static_cast<long >(SWIG_As_long(obj0));
25400 if (SWIG_arg_fail(1)) SWIG_fail;
25401 }
25402 }
25403 if (obj1) {
25404 {
25405 arg2 = static_cast<long >(SWIG_As_long(obj1));
25406 if (SWIG_arg_fail(2)) SWIG_fail;
25407 }
25408 }
25409 if (obj2) {
25410 {
25411 arg3 = static_cast<long >(SWIG_As_long(obj2));
25412 if (SWIG_arg_fail(3)) SWIG_fail;
25413 }
25414 }
25415 if (obj3) {
25416 {
25417 arg4 = static_cast<long >(SWIG_As_long(obj3));
25418 if (SWIG_arg_fail(4)) SWIG_fail;
25419 }
25420 }
25421 {
25422 PyThreadState* __tstate = wxPyBeginAllowThreads();
25423 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
25424
25425 wxPyEndAllowThreads(__tstate);
25426 if (PyErr_Occurred()) SWIG_fail;
25427 }
25428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
25429 return resultobj;
25430 fail:
25431 return NULL;
25432 }
25433
25434
25435 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25436 PyObject *resultobj = NULL;
25437 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25438 PyObject * obj0 = 0 ;
25439 char *kwnames[] = {
25440 (char *) "self", NULL
25441 };
25442
25443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
25444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25445 if (SWIG_arg_fail(1)) SWIG_fail;
25446 {
25447 PyThreadState* __tstate = wxPyBeginAllowThreads();
25448 delete arg1;
25449
25450 wxPyEndAllowThreads(__tstate);
25451 if (PyErr_Occurred()) SWIG_fail;
25452 }
25453 Py_INCREF(Py_None); resultobj = Py_None;
25454 return resultobj;
25455 fail:
25456 return NULL;
25457 }
25458
25459
25460 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25461 PyObject *resultobj = NULL;
25462 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25463 wxTimeSpan *arg2 = 0 ;
25464 wxTimeSpan *result;
25465 PyObject * obj0 = 0 ;
25466 PyObject * obj1 = 0 ;
25467 char *kwnames[] = {
25468 (char *) "self",(char *) "diff", NULL
25469 };
25470
25471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25473 if (SWIG_arg_fail(1)) SWIG_fail;
25474 {
25475 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25476 if (SWIG_arg_fail(2)) SWIG_fail;
25477 if (arg2 == NULL) {
25478 SWIG_null_ref("wxTimeSpan");
25479 }
25480 if (SWIG_arg_fail(2)) SWIG_fail;
25481 }
25482 {
25483 PyThreadState* __tstate = wxPyBeginAllowThreads();
25484 {
25485 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25486 result = (wxTimeSpan *) &_result_ref;
25487 }
25488
25489 wxPyEndAllowThreads(__tstate);
25490 if (PyErr_Occurred()) SWIG_fail;
25491 }
25492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25493 return resultobj;
25494 fail:
25495 return NULL;
25496 }
25497
25498
25499 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25500 PyObject *resultobj = NULL;
25501 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25502 wxTimeSpan *arg2 = 0 ;
25503 wxTimeSpan *result;
25504 PyObject * obj0 = 0 ;
25505 PyObject * obj1 = 0 ;
25506 char *kwnames[] = {
25507 (char *) "self",(char *) "diff", NULL
25508 };
25509
25510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25512 if (SWIG_arg_fail(1)) SWIG_fail;
25513 {
25514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25515 if (SWIG_arg_fail(2)) SWIG_fail;
25516 if (arg2 == NULL) {
25517 SWIG_null_ref("wxTimeSpan");
25518 }
25519 if (SWIG_arg_fail(2)) SWIG_fail;
25520 }
25521 {
25522 PyThreadState* __tstate = wxPyBeginAllowThreads();
25523 {
25524 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
25525 result = (wxTimeSpan *) &_result_ref;
25526 }
25527
25528 wxPyEndAllowThreads(__tstate);
25529 if (PyErr_Occurred()) SWIG_fail;
25530 }
25531 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25532 return resultobj;
25533 fail:
25534 return NULL;
25535 }
25536
25537
25538 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25539 PyObject *resultobj = NULL;
25540 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25541 int arg2 ;
25542 wxTimeSpan *result;
25543 PyObject * obj0 = 0 ;
25544 PyObject * obj1 = 0 ;
25545 char *kwnames[] = {
25546 (char *) "self",(char *) "n", NULL
25547 };
25548
25549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25551 if (SWIG_arg_fail(1)) SWIG_fail;
25552 {
25553 arg2 = static_cast<int >(SWIG_As_int(obj1));
25554 if (SWIG_arg_fail(2)) SWIG_fail;
25555 }
25556 {
25557 PyThreadState* __tstate = wxPyBeginAllowThreads();
25558 {
25559 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
25560 result = (wxTimeSpan *) &_result_ref;
25561 }
25562
25563 wxPyEndAllowThreads(__tstate);
25564 if (PyErr_Occurred()) SWIG_fail;
25565 }
25566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25567 return resultobj;
25568 fail:
25569 return NULL;
25570 }
25571
25572
25573 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25574 PyObject *resultobj = NULL;
25575 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25576 wxTimeSpan *result;
25577 PyObject * obj0 = 0 ;
25578 char *kwnames[] = {
25579 (char *) "self", NULL
25580 };
25581
25582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
25583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25584 if (SWIG_arg_fail(1)) SWIG_fail;
25585 {
25586 PyThreadState* __tstate = wxPyBeginAllowThreads();
25587 {
25588 wxTimeSpan &_result_ref = (arg1)->Neg();
25589 result = (wxTimeSpan *) &_result_ref;
25590 }
25591
25592 wxPyEndAllowThreads(__tstate);
25593 if (PyErr_Occurred()) SWIG_fail;
25594 }
25595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25596 return resultobj;
25597 fail:
25598 return NULL;
25599 }
25600
25601
25602 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
25603 PyObject *resultobj = NULL;
25604 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25605 wxTimeSpan result;
25606 PyObject * obj0 = 0 ;
25607 char *kwnames[] = {
25608 (char *) "self", NULL
25609 };
25610
25611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
25612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25613 if (SWIG_arg_fail(1)) SWIG_fail;
25614 {
25615 PyThreadState* __tstate = wxPyBeginAllowThreads();
25616 result = ((wxTimeSpan const *)arg1)->Abs();
25617
25618 wxPyEndAllowThreads(__tstate);
25619 if (PyErr_Occurred()) SWIG_fail;
25620 }
25621 {
25622 wxTimeSpan * resultptr;
25623 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25625 }
25626 return resultobj;
25627 fail:
25628 return NULL;
25629 }
25630
25631
25632 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25633 PyObject *resultobj = NULL;
25634 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25635 wxTimeSpan *arg2 = 0 ;
25636 wxTimeSpan *result;
25637 PyObject * obj0 = 0 ;
25638 PyObject * obj1 = 0 ;
25639 char *kwnames[] = {
25640 (char *) "self",(char *) "diff", NULL
25641 };
25642
25643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25645 if (SWIG_arg_fail(1)) SWIG_fail;
25646 {
25647 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25648 if (SWIG_arg_fail(2)) SWIG_fail;
25649 if (arg2 == NULL) {
25650 SWIG_null_ref("wxTimeSpan");
25651 }
25652 if (SWIG_arg_fail(2)) SWIG_fail;
25653 }
25654 {
25655 PyThreadState* __tstate = wxPyBeginAllowThreads();
25656 {
25657 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
25658 result = (wxTimeSpan *) &_result_ref;
25659 }
25660
25661 wxPyEndAllowThreads(__tstate);
25662 if (PyErr_Occurred()) SWIG_fail;
25663 }
25664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
25665 return resultobj;
25666 fail:
25667 return NULL;
25668 }
25669
25670
25671 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25672 PyObject *resultobj = NULL;
25673 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25674 wxTimeSpan *arg2 = 0 ;
25675 wxTimeSpan *result;
25676 PyObject * obj0 = 0 ;
25677 PyObject * obj1 = 0 ;
25678 char *kwnames[] = {
25679 (char *) "self",(char *) "diff", NULL
25680 };
25681
25682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25684 if (SWIG_arg_fail(1)) SWIG_fail;
25685 {
25686 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25687 if (SWIG_arg_fail(2)) SWIG_fail;
25688 if (arg2 == NULL) {
25689 SWIG_null_ref("wxTimeSpan");
25690 }
25691 if (SWIG_arg_fail(2)) SWIG_fail;
25692 }
25693 {
25694 PyThreadState* __tstate = wxPyBeginAllowThreads();
25695 {
25696 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
25697 result = (wxTimeSpan *) &_result_ref;
25698 }
25699
25700 wxPyEndAllowThreads(__tstate);
25701 if (PyErr_Occurred()) SWIG_fail;
25702 }
25703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
25704 return resultobj;
25705 fail:
25706 return NULL;
25707 }
25708
25709
25710 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
25711 PyObject *resultobj = NULL;
25712 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25713 int arg2 ;
25714 wxTimeSpan *result;
25715 PyObject * obj0 = 0 ;
25716 PyObject * obj1 = 0 ;
25717 char *kwnames[] = {
25718 (char *) "self",(char *) "n", NULL
25719 };
25720
25721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
25722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25723 if (SWIG_arg_fail(1)) SWIG_fail;
25724 {
25725 arg2 = static_cast<int >(SWIG_As_int(obj1));
25726 if (SWIG_arg_fail(2)) SWIG_fail;
25727 }
25728 {
25729 PyThreadState* __tstate = wxPyBeginAllowThreads();
25730 {
25731 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
25732 result = (wxTimeSpan *) &_result_ref;
25733 }
25734
25735 wxPyEndAllowThreads(__tstate);
25736 if (PyErr_Occurred()) SWIG_fail;
25737 }
25738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
25739 return resultobj;
25740 fail:
25741 return NULL;
25742 }
25743
25744
25745 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25746 PyObject *resultobj = NULL;
25747 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25748 wxTimeSpan *result;
25749 PyObject * obj0 = 0 ;
25750 char *kwnames[] = {
25751 (char *) "self", NULL
25752 };
25753
25754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
25755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25756 if (SWIG_arg_fail(1)) SWIG_fail;
25757 {
25758 PyThreadState* __tstate = wxPyBeginAllowThreads();
25759 {
25760 wxTimeSpan &_result_ref = (arg1)->operator -();
25761 result = (wxTimeSpan *) &_result_ref;
25762 }
25763
25764 wxPyEndAllowThreads(__tstate);
25765 if (PyErr_Occurred()) SWIG_fail;
25766 }
25767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
25768 return resultobj;
25769 fail:
25770 return NULL;
25771 }
25772
25773
25774 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
25775 PyObject *resultobj = NULL;
25776 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25777 wxTimeSpan *arg2 = 0 ;
25778 wxTimeSpan result;
25779 PyObject * obj0 = 0 ;
25780 PyObject * obj1 = 0 ;
25781 char *kwnames[] = {
25782 (char *) "self",(char *) "other", NULL
25783 };
25784
25785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
25786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25787 if (SWIG_arg_fail(1)) SWIG_fail;
25788 {
25789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25790 if (SWIG_arg_fail(2)) SWIG_fail;
25791 if (arg2 == NULL) {
25792 SWIG_null_ref("wxTimeSpan");
25793 }
25794 if (SWIG_arg_fail(2)) SWIG_fail;
25795 }
25796 {
25797 PyThreadState* __tstate = wxPyBeginAllowThreads();
25798 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
25799
25800 wxPyEndAllowThreads(__tstate);
25801 if (PyErr_Occurred()) SWIG_fail;
25802 }
25803 {
25804 wxTimeSpan * resultptr;
25805 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25806 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25807 }
25808 return resultobj;
25809 fail:
25810 return NULL;
25811 }
25812
25813
25814 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
25815 PyObject *resultobj = NULL;
25816 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25817 wxTimeSpan *arg2 = 0 ;
25818 wxTimeSpan result;
25819 PyObject * obj0 = 0 ;
25820 PyObject * obj1 = 0 ;
25821 char *kwnames[] = {
25822 (char *) "self",(char *) "other", NULL
25823 };
25824
25825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
25826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25827 if (SWIG_arg_fail(1)) SWIG_fail;
25828 {
25829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25830 if (SWIG_arg_fail(2)) SWIG_fail;
25831 if (arg2 == NULL) {
25832 SWIG_null_ref("wxTimeSpan");
25833 }
25834 if (SWIG_arg_fail(2)) SWIG_fail;
25835 }
25836 {
25837 PyThreadState* __tstate = wxPyBeginAllowThreads();
25838 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
25839
25840 wxPyEndAllowThreads(__tstate);
25841 if (PyErr_Occurred()) SWIG_fail;
25842 }
25843 {
25844 wxTimeSpan * resultptr;
25845 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25846 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25847 }
25848 return resultobj;
25849 fail:
25850 return NULL;
25851 }
25852
25853
25854 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
25855 PyObject *resultobj = NULL;
25856 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25857 int arg2 ;
25858 wxTimeSpan result;
25859 PyObject * obj0 = 0 ;
25860 PyObject * obj1 = 0 ;
25861 char *kwnames[] = {
25862 (char *) "self",(char *) "n", NULL
25863 };
25864
25865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
25866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25867 if (SWIG_arg_fail(1)) SWIG_fail;
25868 {
25869 arg2 = static_cast<int >(SWIG_As_int(obj1));
25870 if (SWIG_arg_fail(2)) SWIG_fail;
25871 }
25872 {
25873 PyThreadState* __tstate = wxPyBeginAllowThreads();
25874 result = wxTimeSpan___mul__(arg1,arg2);
25875
25876 wxPyEndAllowThreads(__tstate);
25877 if (PyErr_Occurred()) SWIG_fail;
25878 }
25879 {
25880 wxTimeSpan * resultptr;
25881 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25882 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25883 }
25884 return resultobj;
25885 fail:
25886 return NULL;
25887 }
25888
25889
25890 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
25891 PyObject *resultobj = NULL;
25892 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25893 int arg2 ;
25894 wxTimeSpan result;
25895 PyObject * obj0 = 0 ;
25896 PyObject * obj1 = 0 ;
25897 char *kwnames[] = {
25898 (char *) "self",(char *) "n", NULL
25899 };
25900
25901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
25902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25903 if (SWIG_arg_fail(1)) SWIG_fail;
25904 {
25905 arg2 = static_cast<int >(SWIG_As_int(obj1));
25906 if (SWIG_arg_fail(2)) SWIG_fail;
25907 }
25908 {
25909 PyThreadState* __tstate = wxPyBeginAllowThreads();
25910 result = wxTimeSpan___rmul__(arg1,arg2);
25911
25912 wxPyEndAllowThreads(__tstate);
25913 if (PyErr_Occurred()) SWIG_fail;
25914 }
25915 {
25916 wxTimeSpan * resultptr;
25917 resultptr = new wxTimeSpan(static_cast<wxTimeSpan & >(result));
25918 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
25919 }
25920 return resultobj;
25921 fail:
25922 return NULL;
25923 }
25924
25925
25926 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
25927 PyObject *resultobj = NULL;
25928 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25929 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25930 bool result;
25931 PyObject * obj0 = 0 ;
25932 PyObject * obj1 = 0 ;
25933 char *kwnames[] = {
25934 (char *) "self",(char *) "other", NULL
25935 };
25936
25937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
25938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25939 if (SWIG_arg_fail(1)) SWIG_fail;
25940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25941 if (SWIG_arg_fail(2)) SWIG_fail;
25942 {
25943 PyThreadState* __tstate = wxPyBeginAllowThreads();
25944 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
25945
25946 wxPyEndAllowThreads(__tstate);
25947 if (PyErr_Occurred()) SWIG_fail;
25948 }
25949 {
25950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25951 }
25952 return resultobj;
25953 fail:
25954 return NULL;
25955 }
25956
25957
25958 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
25959 PyObject *resultobj = NULL;
25960 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25961 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25962 bool result;
25963 PyObject * obj0 = 0 ;
25964 PyObject * obj1 = 0 ;
25965 char *kwnames[] = {
25966 (char *) "self",(char *) "other", NULL
25967 };
25968
25969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
25970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25971 if (SWIG_arg_fail(1)) SWIG_fail;
25972 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25973 if (SWIG_arg_fail(2)) SWIG_fail;
25974 {
25975 PyThreadState* __tstate = wxPyBeginAllowThreads();
25976 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
25977
25978 wxPyEndAllowThreads(__tstate);
25979 if (PyErr_Occurred()) SWIG_fail;
25980 }
25981 {
25982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25983 }
25984 return resultobj;
25985 fail:
25986 return NULL;
25987 }
25988
25989
25990 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
25991 PyObject *resultobj = NULL;
25992 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25993 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
25994 bool result;
25995 PyObject * obj0 = 0 ;
25996 PyObject * obj1 = 0 ;
25997 char *kwnames[] = {
25998 (char *) "self",(char *) "other", NULL
25999 };
26000
26001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
26002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26003 if (SWIG_arg_fail(1)) SWIG_fail;
26004 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26005 if (SWIG_arg_fail(2)) SWIG_fail;
26006 {
26007 PyThreadState* __tstate = wxPyBeginAllowThreads();
26008 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
26009
26010 wxPyEndAllowThreads(__tstate);
26011 if (PyErr_Occurred()) SWIG_fail;
26012 }
26013 {
26014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26015 }
26016 return resultobj;
26017 fail:
26018 return NULL;
26019 }
26020
26021
26022 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
26023 PyObject *resultobj = NULL;
26024 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26025 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
26026 bool result;
26027 PyObject * obj0 = 0 ;
26028 PyObject * obj1 = 0 ;
26029 char *kwnames[] = {
26030 (char *) "self",(char *) "other", NULL
26031 };
26032
26033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
26034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26035 if (SWIG_arg_fail(1)) SWIG_fail;
26036 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26037 if (SWIG_arg_fail(2)) SWIG_fail;
26038 {
26039 PyThreadState* __tstate = wxPyBeginAllowThreads();
26040 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
26041
26042 wxPyEndAllowThreads(__tstate);
26043 if (PyErr_Occurred()) SWIG_fail;
26044 }
26045 {
26046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26047 }
26048 return resultobj;
26049 fail:
26050 return NULL;
26051 }
26052
26053
26054 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26055 PyObject *resultobj = NULL;
26056 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26057 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
26058 bool result;
26059 PyObject * obj0 = 0 ;
26060 PyObject * obj1 = 0 ;
26061 char *kwnames[] = {
26062 (char *) "self",(char *) "other", NULL
26063 };
26064
26065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26067 if (SWIG_arg_fail(1)) SWIG_fail;
26068 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26069 if (SWIG_arg_fail(2)) SWIG_fail;
26070 {
26071 PyThreadState* __tstate = wxPyBeginAllowThreads();
26072 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
26073
26074 wxPyEndAllowThreads(__tstate);
26075 if (PyErr_Occurred()) SWIG_fail;
26076 }
26077 {
26078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26079 }
26080 return resultobj;
26081 fail:
26082 return NULL;
26083 }
26084
26085
26086 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26087 PyObject *resultobj = NULL;
26088 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26089 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
26090 bool result;
26091 PyObject * obj0 = 0 ;
26092 PyObject * obj1 = 0 ;
26093 char *kwnames[] = {
26094 (char *) "self",(char *) "other", NULL
26095 };
26096
26097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26099 if (SWIG_arg_fail(1)) SWIG_fail;
26100 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26101 if (SWIG_arg_fail(2)) SWIG_fail;
26102 {
26103 PyThreadState* __tstate = wxPyBeginAllowThreads();
26104 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
26105
26106 wxPyEndAllowThreads(__tstate);
26107 if (PyErr_Occurred()) SWIG_fail;
26108 }
26109 {
26110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26111 }
26112 return resultobj;
26113 fail:
26114 return NULL;
26115 }
26116
26117
26118 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
26119 PyObject *resultobj = NULL;
26120 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26121 bool result;
26122 PyObject * obj0 = 0 ;
26123 char *kwnames[] = {
26124 (char *) "self", NULL
26125 };
26126
26127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
26128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26129 if (SWIG_arg_fail(1)) SWIG_fail;
26130 {
26131 PyThreadState* __tstate = wxPyBeginAllowThreads();
26132 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
26133
26134 wxPyEndAllowThreads(__tstate);
26135 if (PyErr_Occurred()) SWIG_fail;
26136 }
26137 {
26138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26139 }
26140 return resultobj;
26141 fail:
26142 return NULL;
26143 }
26144
26145
26146 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
26147 PyObject *resultobj = NULL;
26148 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26149 bool result;
26150 PyObject * obj0 = 0 ;
26151 char *kwnames[] = {
26152 (char *) "self", NULL
26153 };
26154
26155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
26156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26157 if (SWIG_arg_fail(1)) SWIG_fail;
26158 {
26159 PyThreadState* __tstate = wxPyBeginAllowThreads();
26160 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
26161
26162 wxPyEndAllowThreads(__tstate);
26163 if (PyErr_Occurred()) SWIG_fail;
26164 }
26165 {
26166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26167 }
26168 return resultobj;
26169 fail:
26170 return NULL;
26171 }
26172
26173
26174 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
26175 PyObject *resultobj = NULL;
26176 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26177 bool result;
26178 PyObject * obj0 = 0 ;
26179 char *kwnames[] = {
26180 (char *) "self", NULL
26181 };
26182
26183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
26184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26185 if (SWIG_arg_fail(1)) SWIG_fail;
26186 {
26187 PyThreadState* __tstate = wxPyBeginAllowThreads();
26188 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
26189
26190 wxPyEndAllowThreads(__tstate);
26191 if (PyErr_Occurred()) SWIG_fail;
26192 }
26193 {
26194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26195 }
26196 return resultobj;
26197 fail:
26198 return NULL;
26199 }
26200
26201
26202 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
26203 PyObject *resultobj = NULL;
26204 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26205 wxTimeSpan *arg2 = 0 ;
26206 bool result;
26207 PyObject * obj0 = 0 ;
26208 PyObject * obj1 = 0 ;
26209 char *kwnames[] = {
26210 (char *) "self",(char *) "ts", NULL
26211 };
26212
26213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
26214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26215 if (SWIG_arg_fail(1)) SWIG_fail;
26216 {
26217 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26218 if (SWIG_arg_fail(2)) SWIG_fail;
26219 if (arg2 == NULL) {
26220 SWIG_null_ref("wxTimeSpan");
26221 }
26222 if (SWIG_arg_fail(2)) SWIG_fail;
26223 }
26224 {
26225 PyThreadState* __tstate = wxPyBeginAllowThreads();
26226 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
26227
26228 wxPyEndAllowThreads(__tstate);
26229 if (PyErr_Occurred()) SWIG_fail;
26230 }
26231 {
26232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26233 }
26234 return resultobj;
26235 fail:
26236 return NULL;
26237 }
26238
26239
26240 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
26241 PyObject *resultobj = NULL;
26242 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26243 wxTimeSpan *arg2 = 0 ;
26244 bool result;
26245 PyObject * obj0 = 0 ;
26246 PyObject * obj1 = 0 ;
26247 char *kwnames[] = {
26248 (char *) "self",(char *) "ts", NULL
26249 };
26250
26251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
26252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26253 if (SWIG_arg_fail(1)) SWIG_fail;
26254 {
26255 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26256 if (SWIG_arg_fail(2)) SWIG_fail;
26257 if (arg2 == NULL) {
26258 SWIG_null_ref("wxTimeSpan");
26259 }
26260 if (SWIG_arg_fail(2)) SWIG_fail;
26261 }
26262 {
26263 PyThreadState* __tstate = wxPyBeginAllowThreads();
26264 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
26265
26266 wxPyEndAllowThreads(__tstate);
26267 if (PyErr_Occurred()) SWIG_fail;
26268 }
26269 {
26270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26271 }
26272 return resultobj;
26273 fail:
26274 return NULL;
26275 }
26276
26277
26278 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
26279 PyObject *resultobj = NULL;
26280 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26281 wxTimeSpan *arg2 = 0 ;
26282 bool result;
26283 PyObject * obj0 = 0 ;
26284 PyObject * obj1 = 0 ;
26285 char *kwnames[] = {
26286 (char *) "self",(char *) "t", NULL
26287 };
26288
26289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
26290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26291 if (SWIG_arg_fail(1)) SWIG_fail;
26292 {
26293 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26294 if (SWIG_arg_fail(2)) SWIG_fail;
26295 if (arg2 == NULL) {
26296 SWIG_null_ref("wxTimeSpan");
26297 }
26298 if (SWIG_arg_fail(2)) SWIG_fail;
26299 }
26300 {
26301 PyThreadState* __tstate = wxPyBeginAllowThreads();
26302 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
26303
26304 wxPyEndAllowThreads(__tstate);
26305 if (PyErr_Occurred()) SWIG_fail;
26306 }
26307 {
26308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26309 }
26310 return resultobj;
26311 fail:
26312 return NULL;
26313 }
26314
26315
26316 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
26317 PyObject *resultobj = NULL;
26318 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26319 int result;
26320 PyObject * obj0 = 0 ;
26321 char *kwnames[] = {
26322 (char *) "self", NULL
26323 };
26324
26325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
26326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26327 if (SWIG_arg_fail(1)) SWIG_fail;
26328 {
26329 PyThreadState* __tstate = wxPyBeginAllowThreads();
26330 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
26331
26332 wxPyEndAllowThreads(__tstate);
26333 if (PyErr_Occurred()) SWIG_fail;
26334 }
26335 {
26336 resultobj = SWIG_From_int(static_cast<int >(result));
26337 }
26338 return resultobj;
26339 fail:
26340 return NULL;
26341 }
26342
26343
26344 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
26345 PyObject *resultobj = NULL;
26346 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26347 int result;
26348 PyObject * obj0 = 0 ;
26349 char *kwnames[] = {
26350 (char *) "self", NULL
26351 };
26352
26353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
26354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26355 if (SWIG_arg_fail(1)) SWIG_fail;
26356 {
26357 PyThreadState* __tstate = wxPyBeginAllowThreads();
26358 result = (int)((wxTimeSpan const *)arg1)->GetDays();
26359
26360 wxPyEndAllowThreads(__tstate);
26361 if (PyErr_Occurred()) SWIG_fail;
26362 }
26363 {
26364 resultobj = SWIG_From_int(static_cast<int >(result));
26365 }
26366 return resultobj;
26367 fail:
26368 return NULL;
26369 }
26370
26371
26372 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
26373 PyObject *resultobj = NULL;
26374 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26375 int result;
26376 PyObject * obj0 = 0 ;
26377 char *kwnames[] = {
26378 (char *) "self", NULL
26379 };
26380
26381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
26382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26383 if (SWIG_arg_fail(1)) SWIG_fail;
26384 {
26385 PyThreadState* __tstate = wxPyBeginAllowThreads();
26386 result = (int)((wxTimeSpan const *)arg1)->GetHours();
26387
26388 wxPyEndAllowThreads(__tstate);
26389 if (PyErr_Occurred()) SWIG_fail;
26390 }
26391 {
26392 resultobj = SWIG_From_int(static_cast<int >(result));
26393 }
26394 return resultobj;
26395 fail:
26396 return NULL;
26397 }
26398
26399
26400 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
26401 PyObject *resultobj = NULL;
26402 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26403 int result;
26404 PyObject * obj0 = 0 ;
26405 char *kwnames[] = {
26406 (char *) "self", NULL
26407 };
26408
26409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
26410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26411 if (SWIG_arg_fail(1)) SWIG_fail;
26412 {
26413 PyThreadState* __tstate = wxPyBeginAllowThreads();
26414 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
26415
26416 wxPyEndAllowThreads(__tstate);
26417 if (PyErr_Occurred()) SWIG_fail;
26418 }
26419 {
26420 resultobj = SWIG_From_int(static_cast<int >(result));
26421 }
26422 return resultobj;
26423 fail:
26424 return NULL;
26425 }
26426
26427
26428 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
26429 PyObject *resultobj = NULL;
26430 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26431 wxLongLong result;
26432 PyObject * obj0 = 0 ;
26433 char *kwnames[] = {
26434 (char *) "self", NULL
26435 };
26436
26437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
26438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26439 if (SWIG_arg_fail(1)) SWIG_fail;
26440 {
26441 PyThreadState* __tstate = wxPyBeginAllowThreads();
26442 result = ((wxTimeSpan const *)arg1)->GetSeconds();
26443
26444 wxPyEndAllowThreads(__tstate);
26445 if (PyErr_Occurred()) SWIG_fail;
26446 }
26447 {
26448 PyObject *hi, *lo, *shifter, *shifted;
26449 hi = PyLong_FromLong( (&result)->GetHi() );
26450 lo = PyLong_FromLong( (&result)->GetLo() );
26451 shifter = PyLong_FromLong(32);
26452 shifted = PyNumber_Lshift(hi, shifter);
26453 resultobj = PyNumber_Or(shifted, lo);
26454 Py_DECREF(hi);
26455 Py_DECREF(lo);
26456 Py_DECREF(shifter);
26457 Py_DECREF(shifted);
26458 }
26459 return resultobj;
26460 fail:
26461 return NULL;
26462 }
26463
26464
26465 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
26466 PyObject *resultobj = NULL;
26467 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26468 wxLongLong result;
26469 PyObject * obj0 = 0 ;
26470 char *kwnames[] = {
26471 (char *) "self", NULL
26472 };
26473
26474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
26475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26476 if (SWIG_arg_fail(1)) SWIG_fail;
26477 {
26478 PyThreadState* __tstate = wxPyBeginAllowThreads();
26479 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
26480
26481 wxPyEndAllowThreads(__tstate);
26482 if (PyErr_Occurred()) SWIG_fail;
26483 }
26484 {
26485 PyObject *hi, *lo, *shifter, *shifted;
26486 hi = PyLong_FromLong( (&result)->GetHi() );
26487 lo = PyLong_FromLong( (&result)->GetLo() );
26488 shifter = PyLong_FromLong(32);
26489 shifted = PyNumber_Lshift(hi, shifter);
26490 resultobj = PyNumber_Or(shifted, lo);
26491 Py_DECREF(hi);
26492 Py_DECREF(lo);
26493 Py_DECREF(shifter);
26494 Py_DECREF(shifted);
26495 }
26496 return resultobj;
26497 fail:
26498 return NULL;
26499 }
26500
26501
26502 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
26503 PyObject *resultobj = NULL;
26504 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
26505 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
26506 wxString *arg2 = (wxString *) &arg2_defvalue ;
26507 wxString result;
26508 bool temp2 = false ;
26509 PyObject * obj0 = 0 ;
26510 PyObject * obj1 = 0 ;
26511 char *kwnames[] = {
26512 (char *) "self",(char *) "format", NULL
26513 };
26514
26515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
26516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
26517 if (SWIG_arg_fail(1)) SWIG_fail;
26518 if (obj1) {
26519 {
26520 arg2 = wxString_in_helper(obj1);
26521 if (arg2 == NULL) SWIG_fail;
26522 temp2 = true;
26523 }
26524 }
26525 {
26526 PyThreadState* __tstate = wxPyBeginAllowThreads();
26527 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
26528
26529 wxPyEndAllowThreads(__tstate);
26530 if (PyErr_Occurred()) SWIG_fail;
26531 }
26532 {
26533 #if wxUSE_UNICODE
26534 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26535 #else
26536 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26537 #endif
26538 }
26539 {
26540 if (temp2)
26541 delete arg2;
26542 }
26543 return resultobj;
26544 fail:
26545 {
26546 if (temp2)
26547 delete arg2;
26548 }
26549 return NULL;
26550 }
26551
26552
26553 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
26554 PyObject *obj;
26555 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26556 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
26557 Py_INCREF(obj);
26558 return Py_BuildValue((char *)"");
26559 }
26560 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
26561 PyObject *resultobj = NULL;
26562 int arg1 = (int) 0 ;
26563 int arg2 = (int) 0 ;
26564 int arg3 = (int) 0 ;
26565 int arg4 = (int) 0 ;
26566 wxDateSpan *result;
26567 PyObject * obj0 = 0 ;
26568 PyObject * obj1 = 0 ;
26569 PyObject * obj2 = 0 ;
26570 PyObject * obj3 = 0 ;
26571 char *kwnames[] = {
26572 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
26573 };
26574
26575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26576 if (obj0) {
26577 {
26578 arg1 = static_cast<int >(SWIG_As_int(obj0));
26579 if (SWIG_arg_fail(1)) SWIG_fail;
26580 }
26581 }
26582 if (obj1) {
26583 {
26584 arg2 = static_cast<int >(SWIG_As_int(obj1));
26585 if (SWIG_arg_fail(2)) SWIG_fail;
26586 }
26587 }
26588 if (obj2) {
26589 {
26590 arg3 = static_cast<int >(SWIG_As_int(obj2));
26591 if (SWIG_arg_fail(3)) SWIG_fail;
26592 }
26593 }
26594 if (obj3) {
26595 {
26596 arg4 = static_cast<int >(SWIG_As_int(obj3));
26597 if (SWIG_arg_fail(4)) SWIG_fail;
26598 }
26599 }
26600 {
26601 PyThreadState* __tstate = wxPyBeginAllowThreads();
26602 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
26603
26604 wxPyEndAllowThreads(__tstate);
26605 if (PyErr_Occurred()) SWIG_fail;
26606 }
26607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26608 return resultobj;
26609 fail:
26610 return NULL;
26611 }
26612
26613
26614 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
26615 PyObject *resultobj = NULL;
26616 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26617 PyObject * obj0 = 0 ;
26618 char *kwnames[] = {
26619 (char *) "self", NULL
26620 };
26621
26622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
26623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26624 if (SWIG_arg_fail(1)) SWIG_fail;
26625 {
26626 PyThreadState* __tstate = wxPyBeginAllowThreads();
26627 delete arg1;
26628
26629 wxPyEndAllowThreads(__tstate);
26630 if (PyErr_Occurred()) SWIG_fail;
26631 }
26632 Py_INCREF(Py_None); resultobj = Py_None;
26633 return resultobj;
26634 fail:
26635 return NULL;
26636 }
26637
26638
26639 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
26640 PyObject *resultobj = NULL;
26641 int arg1 ;
26642 wxDateSpan result;
26643 PyObject * obj0 = 0 ;
26644 char *kwnames[] = {
26645 (char *) "days", NULL
26646 };
26647
26648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
26649 {
26650 arg1 = static_cast<int >(SWIG_As_int(obj0));
26651 if (SWIG_arg_fail(1)) SWIG_fail;
26652 }
26653 {
26654 PyThreadState* __tstate = wxPyBeginAllowThreads();
26655 result = wxDateSpan::Days(arg1);
26656
26657 wxPyEndAllowThreads(__tstate);
26658 if (PyErr_Occurred()) SWIG_fail;
26659 }
26660 {
26661 wxDateSpan * resultptr;
26662 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26663 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26664 }
26665 return resultobj;
26666 fail:
26667 return NULL;
26668 }
26669
26670
26671 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
26672 PyObject *resultobj = NULL;
26673 wxDateSpan result;
26674 char *kwnames[] = {
26675 NULL
26676 };
26677
26678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
26679 {
26680 PyThreadState* __tstate = wxPyBeginAllowThreads();
26681 result = wxDateSpan::Day();
26682
26683 wxPyEndAllowThreads(__tstate);
26684 if (PyErr_Occurred()) SWIG_fail;
26685 }
26686 {
26687 wxDateSpan * resultptr;
26688 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26689 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26690 }
26691 return resultobj;
26692 fail:
26693 return NULL;
26694 }
26695
26696
26697 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
26698 PyObject *resultobj = NULL;
26699 int arg1 ;
26700 wxDateSpan result;
26701 PyObject * obj0 = 0 ;
26702 char *kwnames[] = {
26703 (char *) "weeks", NULL
26704 };
26705
26706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
26707 {
26708 arg1 = static_cast<int >(SWIG_As_int(obj0));
26709 if (SWIG_arg_fail(1)) SWIG_fail;
26710 }
26711 {
26712 PyThreadState* __tstate = wxPyBeginAllowThreads();
26713 result = wxDateSpan::Weeks(arg1);
26714
26715 wxPyEndAllowThreads(__tstate);
26716 if (PyErr_Occurred()) SWIG_fail;
26717 }
26718 {
26719 wxDateSpan * resultptr;
26720 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26721 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26722 }
26723 return resultobj;
26724 fail:
26725 return NULL;
26726 }
26727
26728
26729 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
26730 PyObject *resultobj = NULL;
26731 wxDateSpan result;
26732 char *kwnames[] = {
26733 NULL
26734 };
26735
26736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
26737 {
26738 PyThreadState* __tstate = wxPyBeginAllowThreads();
26739 result = wxDateSpan::Week();
26740
26741 wxPyEndAllowThreads(__tstate);
26742 if (PyErr_Occurred()) SWIG_fail;
26743 }
26744 {
26745 wxDateSpan * resultptr;
26746 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26747 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26748 }
26749 return resultobj;
26750 fail:
26751 return NULL;
26752 }
26753
26754
26755 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
26756 PyObject *resultobj = NULL;
26757 int arg1 ;
26758 wxDateSpan result;
26759 PyObject * obj0 = 0 ;
26760 char *kwnames[] = {
26761 (char *) "mon", NULL
26762 };
26763
26764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
26765 {
26766 arg1 = static_cast<int >(SWIG_As_int(obj0));
26767 if (SWIG_arg_fail(1)) SWIG_fail;
26768 }
26769 {
26770 PyThreadState* __tstate = wxPyBeginAllowThreads();
26771 result = wxDateSpan::Months(arg1);
26772
26773 wxPyEndAllowThreads(__tstate);
26774 if (PyErr_Occurred()) SWIG_fail;
26775 }
26776 {
26777 wxDateSpan * resultptr;
26778 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26779 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26780 }
26781 return resultobj;
26782 fail:
26783 return NULL;
26784 }
26785
26786
26787 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
26788 PyObject *resultobj = NULL;
26789 wxDateSpan result;
26790 char *kwnames[] = {
26791 NULL
26792 };
26793
26794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
26795 {
26796 PyThreadState* __tstate = wxPyBeginAllowThreads();
26797 result = wxDateSpan::Month();
26798
26799 wxPyEndAllowThreads(__tstate);
26800 if (PyErr_Occurred()) SWIG_fail;
26801 }
26802 {
26803 wxDateSpan * resultptr;
26804 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26805 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26806 }
26807 return resultobj;
26808 fail:
26809 return NULL;
26810 }
26811
26812
26813 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
26814 PyObject *resultobj = NULL;
26815 int arg1 ;
26816 wxDateSpan result;
26817 PyObject * obj0 = 0 ;
26818 char *kwnames[] = {
26819 (char *) "years", NULL
26820 };
26821
26822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
26823 {
26824 arg1 = static_cast<int >(SWIG_As_int(obj0));
26825 if (SWIG_arg_fail(1)) SWIG_fail;
26826 }
26827 {
26828 PyThreadState* __tstate = wxPyBeginAllowThreads();
26829 result = wxDateSpan::Years(arg1);
26830
26831 wxPyEndAllowThreads(__tstate);
26832 if (PyErr_Occurred()) SWIG_fail;
26833 }
26834 {
26835 wxDateSpan * resultptr;
26836 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26837 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26838 }
26839 return resultobj;
26840 fail:
26841 return NULL;
26842 }
26843
26844
26845 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
26846 PyObject *resultobj = NULL;
26847 wxDateSpan result;
26848 char *kwnames[] = {
26849 NULL
26850 };
26851
26852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
26853 {
26854 PyThreadState* __tstate = wxPyBeginAllowThreads();
26855 result = wxDateSpan::Year();
26856
26857 wxPyEndAllowThreads(__tstate);
26858 if (PyErr_Occurred()) SWIG_fail;
26859 }
26860 {
26861 wxDateSpan * resultptr;
26862 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
26863 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26864 }
26865 return resultobj;
26866 fail:
26867 return NULL;
26868 }
26869
26870
26871 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
26872 PyObject *resultobj = NULL;
26873 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26874 int arg2 ;
26875 wxDateSpan *result;
26876 PyObject * obj0 = 0 ;
26877 PyObject * obj1 = 0 ;
26878 char *kwnames[] = {
26879 (char *) "self",(char *) "n", NULL
26880 };
26881
26882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
26883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26884 if (SWIG_arg_fail(1)) SWIG_fail;
26885 {
26886 arg2 = static_cast<int >(SWIG_As_int(obj1));
26887 if (SWIG_arg_fail(2)) SWIG_fail;
26888 }
26889 {
26890 PyThreadState* __tstate = wxPyBeginAllowThreads();
26891 {
26892 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
26893 result = (wxDateSpan *) &_result_ref;
26894 }
26895
26896 wxPyEndAllowThreads(__tstate);
26897 if (PyErr_Occurred()) SWIG_fail;
26898 }
26899 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26900 return resultobj;
26901 fail:
26902 return NULL;
26903 }
26904
26905
26906 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
26907 PyObject *resultobj = NULL;
26908 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26909 int arg2 ;
26910 wxDateSpan *result;
26911 PyObject * obj0 = 0 ;
26912 PyObject * obj1 = 0 ;
26913 char *kwnames[] = {
26914 (char *) "self",(char *) "n", NULL
26915 };
26916
26917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
26918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26919 if (SWIG_arg_fail(1)) SWIG_fail;
26920 {
26921 arg2 = static_cast<int >(SWIG_As_int(obj1));
26922 if (SWIG_arg_fail(2)) SWIG_fail;
26923 }
26924 {
26925 PyThreadState* __tstate = wxPyBeginAllowThreads();
26926 {
26927 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
26928 result = (wxDateSpan *) &_result_ref;
26929 }
26930
26931 wxPyEndAllowThreads(__tstate);
26932 if (PyErr_Occurred()) SWIG_fail;
26933 }
26934 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26935 return resultobj;
26936 fail:
26937 return NULL;
26938 }
26939
26940
26941 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
26942 PyObject *resultobj = NULL;
26943 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26944 int arg2 ;
26945 wxDateSpan *result;
26946 PyObject * obj0 = 0 ;
26947 PyObject * obj1 = 0 ;
26948 char *kwnames[] = {
26949 (char *) "self",(char *) "n", NULL
26950 };
26951
26952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
26953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26954 if (SWIG_arg_fail(1)) SWIG_fail;
26955 {
26956 arg2 = static_cast<int >(SWIG_As_int(obj1));
26957 if (SWIG_arg_fail(2)) SWIG_fail;
26958 }
26959 {
26960 PyThreadState* __tstate = wxPyBeginAllowThreads();
26961 {
26962 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
26963 result = (wxDateSpan *) &_result_ref;
26964 }
26965
26966 wxPyEndAllowThreads(__tstate);
26967 if (PyErr_Occurred()) SWIG_fail;
26968 }
26969 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26970 return resultobj;
26971 fail:
26972 return NULL;
26973 }
26974
26975
26976 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
26977 PyObject *resultobj = NULL;
26978 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26979 int arg2 ;
26980 wxDateSpan *result;
26981 PyObject * obj0 = 0 ;
26982 PyObject * obj1 = 0 ;
26983 char *kwnames[] = {
26984 (char *) "self",(char *) "n", NULL
26985 };
26986
26987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
26988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26989 if (SWIG_arg_fail(1)) SWIG_fail;
26990 {
26991 arg2 = static_cast<int >(SWIG_As_int(obj1));
26992 if (SWIG_arg_fail(2)) SWIG_fail;
26993 }
26994 {
26995 PyThreadState* __tstate = wxPyBeginAllowThreads();
26996 {
26997 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
26998 result = (wxDateSpan *) &_result_ref;
26999 }
27000
27001 wxPyEndAllowThreads(__tstate);
27002 if (PyErr_Occurred()) SWIG_fail;
27003 }
27004 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27005 return resultobj;
27006 fail:
27007 return NULL;
27008 }
27009
27010
27011 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
27012 PyObject *resultobj = NULL;
27013 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27014 int result;
27015 PyObject * obj0 = 0 ;
27016 char *kwnames[] = {
27017 (char *) "self", NULL
27018 };
27019
27020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
27021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27022 if (SWIG_arg_fail(1)) SWIG_fail;
27023 {
27024 PyThreadState* __tstate = wxPyBeginAllowThreads();
27025 result = (int)((wxDateSpan const *)arg1)->GetYears();
27026
27027 wxPyEndAllowThreads(__tstate);
27028 if (PyErr_Occurred()) SWIG_fail;
27029 }
27030 {
27031 resultobj = SWIG_From_int(static_cast<int >(result));
27032 }
27033 return resultobj;
27034 fail:
27035 return NULL;
27036 }
27037
27038
27039 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
27040 PyObject *resultobj = NULL;
27041 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27042 int result;
27043 PyObject * obj0 = 0 ;
27044 char *kwnames[] = {
27045 (char *) "self", NULL
27046 };
27047
27048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
27049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27050 if (SWIG_arg_fail(1)) SWIG_fail;
27051 {
27052 PyThreadState* __tstate = wxPyBeginAllowThreads();
27053 result = (int)((wxDateSpan const *)arg1)->GetMonths();
27054
27055 wxPyEndAllowThreads(__tstate);
27056 if (PyErr_Occurred()) SWIG_fail;
27057 }
27058 {
27059 resultobj = SWIG_From_int(static_cast<int >(result));
27060 }
27061 return resultobj;
27062 fail:
27063 return NULL;
27064 }
27065
27066
27067 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
27068 PyObject *resultobj = NULL;
27069 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27070 int result;
27071 PyObject * obj0 = 0 ;
27072 char *kwnames[] = {
27073 (char *) "self", NULL
27074 };
27075
27076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
27077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27078 if (SWIG_arg_fail(1)) SWIG_fail;
27079 {
27080 PyThreadState* __tstate = wxPyBeginAllowThreads();
27081 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
27082
27083 wxPyEndAllowThreads(__tstate);
27084 if (PyErr_Occurred()) SWIG_fail;
27085 }
27086 {
27087 resultobj = SWIG_From_int(static_cast<int >(result));
27088 }
27089 return resultobj;
27090 fail:
27091 return NULL;
27092 }
27093
27094
27095 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
27096 PyObject *resultobj = NULL;
27097 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27098 int result;
27099 PyObject * obj0 = 0 ;
27100 char *kwnames[] = {
27101 (char *) "self", NULL
27102 };
27103
27104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
27105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27106 if (SWIG_arg_fail(1)) SWIG_fail;
27107 {
27108 PyThreadState* __tstate = wxPyBeginAllowThreads();
27109 result = (int)((wxDateSpan const *)arg1)->GetDays();
27110
27111 wxPyEndAllowThreads(__tstate);
27112 if (PyErr_Occurred()) SWIG_fail;
27113 }
27114 {
27115 resultobj = SWIG_From_int(static_cast<int >(result));
27116 }
27117 return resultobj;
27118 fail:
27119 return NULL;
27120 }
27121
27122
27123 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
27124 PyObject *resultobj = NULL;
27125 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27126 int result;
27127 PyObject * obj0 = 0 ;
27128 char *kwnames[] = {
27129 (char *) "self", NULL
27130 };
27131
27132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
27133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27134 if (SWIG_arg_fail(1)) SWIG_fail;
27135 {
27136 PyThreadState* __tstate = wxPyBeginAllowThreads();
27137 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
27138
27139 wxPyEndAllowThreads(__tstate);
27140 if (PyErr_Occurred()) SWIG_fail;
27141 }
27142 {
27143 resultobj = SWIG_From_int(static_cast<int >(result));
27144 }
27145 return resultobj;
27146 fail:
27147 return NULL;
27148 }
27149
27150
27151 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27152 PyObject *resultobj = NULL;
27153 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27154 wxDateSpan *arg2 = 0 ;
27155 wxDateSpan *result;
27156 PyObject * obj0 = 0 ;
27157 PyObject * obj1 = 0 ;
27158 char *kwnames[] = {
27159 (char *) "self",(char *) "other", NULL
27160 };
27161
27162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
27163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27164 if (SWIG_arg_fail(1)) SWIG_fail;
27165 {
27166 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27167 if (SWIG_arg_fail(2)) SWIG_fail;
27168 if (arg2 == NULL) {
27169 SWIG_null_ref("wxDateSpan");
27170 }
27171 if (SWIG_arg_fail(2)) SWIG_fail;
27172 }
27173 {
27174 PyThreadState* __tstate = wxPyBeginAllowThreads();
27175 {
27176 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27177 result = (wxDateSpan *) &_result_ref;
27178 }
27179
27180 wxPyEndAllowThreads(__tstate);
27181 if (PyErr_Occurred()) SWIG_fail;
27182 }
27183 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27184 return resultobj;
27185 fail:
27186 return NULL;
27187 }
27188
27189
27190 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
27191 PyObject *resultobj = NULL;
27192 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27193 wxDateSpan *arg2 = 0 ;
27194 wxDateSpan *result;
27195 PyObject * obj0 = 0 ;
27196 PyObject * obj1 = 0 ;
27197 char *kwnames[] = {
27198 (char *) "self",(char *) "other", NULL
27199 };
27200
27201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
27202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27203 if (SWIG_arg_fail(1)) SWIG_fail;
27204 {
27205 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27206 if (SWIG_arg_fail(2)) SWIG_fail;
27207 if (arg2 == NULL) {
27208 SWIG_null_ref("wxDateSpan");
27209 }
27210 if (SWIG_arg_fail(2)) SWIG_fail;
27211 }
27212 {
27213 PyThreadState* __tstate = wxPyBeginAllowThreads();
27214 {
27215 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27216 result = (wxDateSpan *) &_result_ref;
27217 }
27218
27219 wxPyEndAllowThreads(__tstate);
27220 if (PyErr_Occurred()) SWIG_fail;
27221 }
27222 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27223 return resultobj;
27224 fail:
27225 return NULL;
27226 }
27227
27228
27229 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
27230 PyObject *resultobj = NULL;
27231 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27232 wxDateSpan *result;
27233 PyObject * obj0 = 0 ;
27234 char *kwnames[] = {
27235 (char *) "self", NULL
27236 };
27237
27238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
27239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27240 if (SWIG_arg_fail(1)) SWIG_fail;
27241 {
27242 PyThreadState* __tstate = wxPyBeginAllowThreads();
27243 {
27244 wxDateSpan &_result_ref = (arg1)->Neg();
27245 result = (wxDateSpan *) &_result_ref;
27246 }
27247
27248 wxPyEndAllowThreads(__tstate);
27249 if (PyErr_Occurred()) SWIG_fail;
27250 }
27251 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27252 return resultobj;
27253 fail:
27254 return NULL;
27255 }
27256
27257
27258 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
27259 PyObject *resultobj = NULL;
27260 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27261 int arg2 ;
27262 wxDateSpan *result;
27263 PyObject * obj0 = 0 ;
27264 PyObject * obj1 = 0 ;
27265 char *kwnames[] = {
27266 (char *) "self",(char *) "factor", NULL
27267 };
27268
27269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
27270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27271 if (SWIG_arg_fail(1)) SWIG_fail;
27272 {
27273 arg2 = static_cast<int >(SWIG_As_int(obj1));
27274 if (SWIG_arg_fail(2)) SWIG_fail;
27275 }
27276 {
27277 PyThreadState* __tstate = wxPyBeginAllowThreads();
27278 {
27279 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
27280 result = (wxDateSpan *) &_result_ref;
27281 }
27282
27283 wxPyEndAllowThreads(__tstate);
27284 if (PyErr_Occurred()) SWIG_fail;
27285 }
27286 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27287 return resultobj;
27288 fail:
27289 return NULL;
27290 }
27291
27292
27293 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
27294 PyObject *resultobj = NULL;
27295 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27296 wxDateSpan *arg2 = 0 ;
27297 wxDateSpan *result;
27298 PyObject * obj0 = 0 ;
27299 PyObject * obj1 = 0 ;
27300 char *kwnames[] = {
27301 (char *) "self",(char *) "other", NULL
27302 };
27303
27304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
27305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27306 if (SWIG_arg_fail(1)) SWIG_fail;
27307 {
27308 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27309 if (SWIG_arg_fail(2)) SWIG_fail;
27310 if (arg2 == NULL) {
27311 SWIG_null_ref("wxDateSpan");
27312 }
27313 if (SWIG_arg_fail(2)) SWIG_fail;
27314 }
27315 {
27316 PyThreadState* __tstate = wxPyBeginAllowThreads();
27317 {
27318 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27319 result = (wxDateSpan *) &_result_ref;
27320 }
27321
27322 wxPyEndAllowThreads(__tstate);
27323 if (PyErr_Occurred()) SWIG_fail;
27324 }
27325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
27326 return resultobj;
27327 fail:
27328 return NULL;
27329 }
27330
27331
27332 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
27333 PyObject *resultobj = NULL;
27334 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27335 wxDateSpan *arg2 = 0 ;
27336 wxDateSpan *result;
27337 PyObject * obj0 = 0 ;
27338 PyObject * obj1 = 0 ;
27339 char *kwnames[] = {
27340 (char *) "self",(char *) "other", NULL
27341 };
27342
27343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
27344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27345 if (SWIG_arg_fail(1)) SWIG_fail;
27346 {
27347 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27348 if (SWIG_arg_fail(2)) SWIG_fail;
27349 if (arg2 == NULL) {
27350 SWIG_null_ref("wxDateSpan");
27351 }
27352 if (SWIG_arg_fail(2)) SWIG_fail;
27353 }
27354 {
27355 PyThreadState* __tstate = wxPyBeginAllowThreads();
27356 {
27357 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27358 result = (wxDateSpan *) &_result_ref;
27359 }
27360
27361 wxPyEndAllowThreads(__tstate);
27362 if (PyErr_Occurred()) SWIG_fail;
27363 }
27364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
27365 return resultobj;
27366 fail:
27367 return NULL;
27368 }
27369
27370
27371 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
27372 PyObject *resultobj = NULL;
27373 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27374 wxDateSpan *result;
27375 PyObject * obj0 = 0 ;
27376 char *kwnames[] = {
27377 (char *) "self", NULL
27378 };
27379
27380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
27381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27382 if (SWIG_arg_fail(1)) SWIG_fail;
27383 {
27384 PyThreadState* __tstate = wxPyBeginAllowThreads();
27385 {
27386 wxDateSpan &_result_ref = (arg1)->operator -();
27387 result = (wxDateSpan *) &_result_ref;
27388 }
27389
27390 wxPyEndAllowThreads(__tstate);
27391 if (PyErr_Occurred()) SWIG_fail;
27392 }
27393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
27394 return resultobj;
27395 fail:
27396 return NULL;
27397 }
27398
27399
27400 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
27401 PyObject *resultobj = NULL;
27402 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27403 int arg2 ;
27404 wxDateSpan *result;
27405 PyObject * obj0 = 0 ;
27406 PyObject * obj1 = 0 ;
27407 char *kwnames[] = {
27408 (char *) "self",(char *) "factor", NULL
27409 };
27410
27411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
27412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27413 if (SWIG_arg_fail(1)) SWIG_fail;
27414 {
27415 arg2 = static_cast<int >(SWIG_As_int(obj1));
27416 if (SWIG_arg_fail(2)) SWIG_fail;
27417 }
27418 {
27419 PyThreadState* __tstate = wxPyBeginAllowThreads();
27420 {
27421 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
27422 result = (wxDateSpan *) &_result_ref;
27423 }
27424
27425 wxPyEndAllowThreads(__tstate);
27426 if (PyErr_Occurred()) SWIG_fail;
27427 }
27428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
27429 return resultobj;
27430 fail:
27431 return NULL;
27432 }
27433
27434
27435 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
27436 PyObject *resultobj = NULL;
27437 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27438 wxDateSpan *arg2 = 0 ;
27439 wxDateSpan result;
27440 PyObject * obj0 = 0 ;
27441 PyObject * obj1 = 0 ;
27442 char *kwnames[] = {
27443 (char *) "self",(char *) "other", NULL
27444 };
27445
27446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
27447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27448 if (SWIG_arg_fail(1)) SWIG_fail;
27449 {
27450 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27451 if (SWIG_arg_fail(2)) SWIG_fail;
27452 if (arg2 == NULL) {
27453 SWIG_null_ref("wxDateSpan");
27454 }
27455 if (SWIG_arg_fail(2)) SWIG_fail;
27456 }
27457 {
27458 PyThreadState* __tstate = wxPyBeginAllowThreads();
27459 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
27460
27461 wxPyEndAllowThreads(__tstate);
27462 if (PyErr_Occurred()) SWIG_fail;
27463 }
27464 {
27465 wxDateSpan * resultptr;
27466 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
27467 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
27468 }
27469 return resultobj;
27470 fail:
27471 return NULL;
27472 }
27473
27474
27475 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
27476 PyObject *resultobj = NULL;
27477 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27478 wxDateSpan *arg2 = 0 ;
27479 wxDateSpan result;
27480 PyObject * obj0 = 0 ;
27481 PyObject * obj1 = 0 ;
27482 char *kwnames[] = {
27483 (char *) "self",(char *) "other", NULL
27484 };
27485
27486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
27487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27488 if (SWIG_arg_fail(1)) SWIG_fail;
27489 {
27490 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27491 if (SWIG_arg_fail(2)) SWIG_fail;
27492 if (arg2 == NULL) {
27493 SWIG_null_ref("wxDateSpan");
27494 }
27495 if (SWIG_arg_fail(2)) SWIG_fail;
27496 }
27497 {
27498 PyThreadState* __tstate = wxPyBeginAllowThreads();
27499 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
27500
27501 wxPyEndAllowThreads(__tstate);
27502 if (PyErr_Occurred()) SWIG_fail;
27503 }
27504 {
27505 wxDateSpan * resultptr;
27506 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
27507 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
27508 }
27509 return resultobj;
27510 fail:
27511 return NULL;
27512 }
27513
27514
27515 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
27516 PyObject *resultobj = NULL;
27517 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27518 int arg2 ;
27519 wxDateSpan result;
27520 PyObject * obj0 = 0 ;
27521 PyObject * obj1 = 0 ;
27522 char *kwnames[] = {
27523 (char *) "self",(char *) "n", NULL
27524 };
27525
27526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
27527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27528 if (SWIG_arg_fail(1)) SWIG_fail;
27529 {
27530 arg2 = static_cast<int >(SWIG_As_int(obj1));
27531 if (SWIG_arg_fail(2)) SWIG_fail;
27532 }
27533 {
27534 PyThreadState* __tstate = wxPyBeginAllowThreads();
27535 result = wxDateSpan___mul__(arg1,arg2);
27536
27537 wxPyEndAllowThreads(__tstate);
27538 if (PyErr_Occurred()) SWIG_fail;
27539 }
27540 {
27541 wxDateSpan * resultptr;
27542 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
27543 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
27544 }
27545 return resultobj;
27546 fail:
27547 return NULL;
27548 }
27549
27550
27551 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
27552 PyObject *resultobj = NULL;
27553 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27554 int arg2 ;
27555 wxDateSpan result;
27556 PyObject * obj0 = 0 ;
27557 PyObject * obj1 = 0 ;
27558 char *kwnames[] = {
27559 (char *) "self",(char *) "n", NULL
27560 };
27561
27562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
27563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27564 if (SWIG_arg_fail(1)) SWIG_fail;
27565 {
27566 arg2 = static_cast<int >(SWIG_As_int(obj1));
27567 if (SWIG_arg_fail(2)) SWIG_fail;
27568 }
27569 {
27570 PyThreadState* __tstate = wxPyBeginAllowThreads();
27571 result = wxDateSpan___rmul__(arg1,arg2);
27572
27573 wxPyEndAllowThreads(__tstate);
27574 if (PyErr_Occurred()) SWIG_fail;
27575 }
27576 {
27577 wxDateSpan * resultptr;
27578 resultptr = new wxDateSpan(static_cast<wxDateSpan & >(result));
27579 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
27580 }
27581 return resultobj;
27582 fail:
27583 return NULL;
27584 }
27585
27586
27587 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
27588 PyObject *resultobj = NULL;
27589 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27590 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
27591 bool result;
27592 PyObject * obj0 = 0 ;
27593 PyObject * obj1 = 0 ;
27594 char *kwnames[] = {
27595 (char *) "self",(char *) "other", NULL
27596 };
27597
27598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
27599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27600 if (SWIG_arg_fail(1)) SWIG_fail;
27601 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27602 if (SWIG_arg_fail(2)) SWIG_fail;
27603 {
27604 PyThreadState* __tstate = wxPyBeginAllowThreads();
27605 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
27606
27607 wxPyEndAllowThreads(__tstate);
27608 if (PyErr_Occurred()) SWIG_fail;
27609 }
27610 {
27611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27612 }
27613 return resultobj;
27614 fail:
27615 return NULL;
27616 }
27617
27618
27619 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
27620 PyObject *resultobj = NULL;
27621 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
27622 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
27623 bool result;
27624 PyObject * obj0 = 0 ;
27625 PyObject * obj1 = 0 ;
27626 char *kwnames[] = {
27627 (char *) "self",(char *) "other", NULL
27628 };
27629
27630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
27631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27632 if (SWIG_arg_fail(1)) SWIG_fail;
27633 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
27634 if (SWIG_arg_fail(2)) SWIG_fail;
27635 {
27636 PyThreadState* __tstate = wxPyBeginAllowThreads();
27637 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
27638
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 {
27643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27644 }
27645 return resultobj;
27646 fail:
27647 return NULL;
27648 }
27649
27650
27651 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
27652 PyObject *obj;
27653 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27654 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
27655 Py_INCREF(obj);
27656 return Py_BuildValue((char *)"");
27657 }
27658 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
27659 PyObject *resultobj = NULL;
27660 long result;
27661 char *kwnames[] = {
27662 NULL
27663 };
27664
27665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
27666 {
27667 PyThreadState* __tstate = wxPyBeginAllowThreads();
27668 result = (long)wxGetLocalTime();
27669
27670 wxPyEndAllowThreads(__tstate);
27671 if (PyErr_Occurred()) SWIG_fail;
27672 }
27673 {
27674 resultobj = SWIG_From_long(static_cast<long >(result));
27675 }
27676 return resultobj;
27677 fail:
27678 return NULL;
27679 }
27680
27681
27682 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
27683 PyObject *resultobj = NULL;
27684 long result;
27685 char *kwnames[] = {
27686 NULL
27687 };
27688
27689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
27690 {
27691 PyThreadState* __tstate = wxPyBeginAllowThreads();
27692 result = (long)wxGetUTCTime();
27693
27694 wxPyEndAllowThreads(__tstate);
27695 if (PyErr_Occurred()) SWIG_fail;
27696 }
27697 {
27698 resultobj = SWIG_From_long(static_cast<long >(result));
27699 }
27700 return resultobj;
27701 fail:
27702 return NULL;
27703 }
27704
27705
27706 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
27707 PyObject *resultobj = NULL;
27708 long result;
27709 char *kwnames[] = {
27710 NULL
27711 };
27712
27713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
27714 {
27715 PyThreadState* __tstate = wxPyBeginAllowThreads();
27716 result = (long)wxGetCurrentTime();
27717
27718 wxPyEndAllowThreads(__tstate);
27719 if (PyErr_Occurred()) SWIG_fail;
27720 }
27721 {
27722 resultobj = SWIG_From_long(static_cast<long >(result));
27723 }
27724 return resultobj;
27725 fail:
27726 return NULL;
27727 }
27728
27729
27730 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
27731 PyObject *resultobj = NULL;
27732 wxLongLong result;
27733 char *kwnames[] = {
27734 NULL
27735 };
27736
27737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
27738 {
27739 PyThreadState* __tstate = wxPyBeginAllowThreads();
27740 result = wxGetLocalTimeMillis();
27741
27742 wxPyEndAllowThreads(__tstate);
27743 if (PyErr_Occurred()) SWIG_fail;
27744 }
27745 {
27746 PyObject *hi, *lo, *shifter, *shifted;
27747 hi = PyLong_FromLong( (&result)->GetHi() );
27748 lo = PyLong_FromLong( (&result)->GetLo() );
27749 shifter = PyLong_FromLong(32);
27750 shifted = PyNumber_Lshift(hi, shifter);
27751 resultobj = PyNumber_Or(shifted, lo);
27752 Py_DECREF(hi);
27753 Py_DECREF(lo);
27754 Py_DECREF(shifter);
27755 Py_DECREF(shifted);
27756 }
27757 return resultobj;
27758 fail:
27759 return NULL;
27760 }
27761
27762
27763 static int _wrap_DefaultDateTime_set(PyObject *) {
27764 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
27765 return 1;
27766 }
27767
27768
27769 static PyObject *_wrap_DefaultDateTime_get(void) {
27770 PyObject *pyobj = NULL;
27771
27772 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
27773 return pyobj;
27774 }
27775
27776
27777 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27778 PyObject *resultobj = NULL;
27779 wxDataFormatId arg1 ;
27780 wxDataFormat *result;
27781 PyObject * obj0 = 0 ;
27782 char *kwnames[] = {
27783 (char *) "type", NULL
27784 };
27785
27786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
27787 {
27788 arg1 = static_cast<wxDataFormatId >(SWIG_As_int(obj0));
27789 if (SWIG_arg_fail(1)) SWIG_fail;
27790 }
27791 {
27792 PyThreadState* __tstate = wxPyBeginAllowThreads();
27793 result = (wxDataFormat *)new wxDataFormat(arg1);
27794
27795 wxPyEndAllowThreads(__tstate);
27796 if (PyErr_Occurred()) SWIG_fail;
27797 }
27798 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
27799 return resultobj;
27800 fail:
27801 return NULL;
27802 }
27803
27804
27805 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27806 PyObject *resultobj = NULL;
27807 wxString *arg1 = 0 ;
27808 wxDataFormat *result;
27809 bool temp1 = false ;
27810 PyObject * obj0 = 0 ;
27811 char *kwnames[] = {
27812 (char *) "format", NULL
27813 };
27814
27815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
27816 {
27817 arg1 = wxString_in_helper(obj0);
27818 if (arg1 == NULL) SWIG_fail;
27819 temp1 = true;
27820 }
27821 {
27822 PyThreadState* __tstate = wxPyBeginAllowThreads();
27823 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
27824
27825 wxPyEndAllowThreads(__tstate);
27826 if (PyErr_Occurred()) SWIG_fail;
27827 }
27828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
27829 {
27830 if (temp1)
27831 delete arg1;
27832 }
27833 return resultobj;
27834 fail:
27835 {
27836 if (temp1)
27837 delete arg1;
27838 }
27839 return NULL;
27840 }
27841
27842
27843 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27844 PyObject *resultobj = NULL;
27845 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27846 PyObject * obj0 = 0 ;
27847 char *kwnames[] = {
27848 (char *) "self", NULL
27849 };
27850
27851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
27852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27853 if (SWIG_arg_fail(1)) SWIG_fail;
27854 {
27855 PyThreadState* __tstate = wxPyBeginAllowThreads();
27856 delete arg1;
27857
27858 wxPyEndAllowThreads(__tstate);
27859 if (PyErr_Occurred()) SWIG_fail;
27860 }
27861 Py_INCREF(Py_None); resultobj = Py_None;
27862 return resultobj;
27863 fail:
27864 return NULL;
27865 }
27866
27867
27868 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
27869 PyObject *resultobj = NULL;
27870 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27871 wxDataFormatId arg2 ;
27872 bool result;
27873 PyObject * obj0 = 0 ;
27874 PyObject * obj1 = 0 ;
27875
27876 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
27877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27878 if (SWIG_arg_fail(1)) SWIG_fail;
27879 {
27880 arg2 = static_cast<wxDataFormatId >(SWIG_As_int(obj1));
27881 if (SWIG_arg_fail(2)) SWIG_fail;
27882 }
27883 {
27884 PyThreadState* __tstate = wxPyBeginAllowThreads();
27885 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
27886
27887 wxPyEndAllowThreads(__tstate);
27888 if (PyErr_Occurred()) SWIG_fail;
27889 }
27890 {
27891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27892 }
27893 return resultobj;
27894 fail:
27895 return NULL;
27896 }
27897
27898
27899 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
27900 PyObject *resultobj = NULL;
27901 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27902 wxDataFormatId arg2 ;
27903 bool result;
27904 PyObject * obj0 = 0 ;
27905 PyObject * obj1 = 0 ;
27906
27907 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
27908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27909 if (SWIG_arg_fail(1)) SWIG_fail;
27910 {
27911 arg2 = static_cast<wxDataFormatId >(SWIG_As_int(obj1));
27912 if (SWIG_arg_fail(2)) SWIG_fail;
27913 }
27914 {
27915 PyThreadState* __tstate = wxPyBeginAllowThreads();
27916 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
27917
27918 wxPyEndAllowThreads(__tstate);
27919 if (PyErr_Occurred()) SWIG_fail;
27920 }
27921 {
27922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27923 }
27924 return resultobj;
27925 fail:
27926 return NULL;
27927 }
27928
27929
27930 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
27931 PyObject *resultobj = NULL;
27932 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
27933 wxDataFormat *arg2 = 0 ;
27934 bool result;
27935 PyObject * obj0 = 0 ;
27936 PyObject * obj1 = 0 ;
27937
27938 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
27939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27940 if (SWIG_arg_fail(1)) SWIG_fail;
27941 {
27942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27943 if (SWIG_arg_fail(2)) SWIG_fail;
27944 if (arg2 == NULL) {
27945 SWIG_null_ref("wxDataFormat");
27946 }
27947 if (SWIG_arg_fail(2)) SWIG_fail;
27948 }
27949 {
27950 PyThreadState* __tstate = wxPyBeginAllowThreads();
27951 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
27952
27953 wxPyEndAllowThreads(__tstate);
27954 if (PyErr_Occurred()) SWIG_fail;
27955 }
27956 {
27957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27958 }
27959 return resultobj;
27960 fail:
27961 return NULL;
27962 }
27963
27964
27965 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
27966 int argc;
27967 PyObject *argv[3];
27968 int ii;
27969
27970 argc = PyObject_Length(args);
27971 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
27972 argv[ii] = PyTuple_GetItem(args,ii);
27973 }
27974 if (argc == 2) {
27975 int _v;
27976 {
27977 void *ptr;
27978 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27979 _v = 0;
27980 PyErr_Clear();
27981 } else {
27982 _v = 1;
27983 }
27984 }
27985 if (_v) {
27986 {
27987 void *ptr = 0;
27988 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27989 _v = 0;
27990 PyErr_Clear();
27991 } else {
27992 _v = (ptr != 0);
27993 }
27994 }
27995 if (_v) {
27996 return _wrap_DataFormat___eq____SWIG_1(self,args);
27997 }
27998 }
27999 }
28000 if (argc == 2) {
28001 int _v;
28002 {
28003 void *ptr;
28004 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28005 _v = 0;
28006 PyErr_Clear();
28007 } else {
28008 _v = 1;
28009 }
28010 }
28011 if (_v) {
28012 _v = SWIG_Check_int(argv[1]);
28013 if (_v) {
28014 return _wrap_DataFormat___eq____SWIG_0(self,args);
28015 }
28016 }
28017 }
28018
28019 Py_INCREF(Py_NotImplemented);
28020 return Py_NotImplemented;
28021 }
28022
28023
28024 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
28025 PyObject *resultobj = NULL;
28026 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28027 wxDataFormat *arg2 = 0 ;
28028 bool result;
28029 PyObject * obj0 = 0 ;
28030 PyObject * obj1 = 0 ;
28031
28032 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
28033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28034 if (SWIG_arg_fail(1)) SWIG_fail;
28035 {
28036 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28037 if (SWIG_arg_fail(2)) SWIG_fail;
28038 if (arg2 == NULL) {
28039 SWIG_null_ref("wxDataFormat");
28040 }
28041 if (SWIG_arg_fail(2)) SWIG_fail;
28042 }
28043 {
28044 PyThreadState* __tstate = wxPyBeginAllowThreads();
28045 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
28046
28047 wxPyEndAllowThreads(__tstate);
28048 if (PyErr_Occurred()) SWIG_fail;
28049 }
28050 {
28051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28052 }
28053 return resultobj;
28054 fail:
28055 return NULL;
28056 }
28057
28058
28059 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
28060 int argc;
28061 PyObject *argv[3];
28062 int ii;
28063
28064 argc = PyObject_Length(args);
28065 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
28066 argv[ii] = PyTuple_GetItem(args,ii);
28067 }
28068 if (argc == 2) {
28069 int _v;
28070 {
28071 void *ptr;
28072 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28073 _v = 0;
28074 PyErr_Clear();
28075 } else {
28076 _v = 1;
28077 }
28078 }
28079 if (_v) {
28080 {
28081 void *ptr = 0;
28082 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28083 _v = 0;
28084 PyErr_Clear();
28085 } else {
28086 _v = (ptr != 0);
28087 }
28088 }
28089 if (_v) {
28090 return _wrap_DataFormat___ne____SWIG_1(self,args);
28091 }
28092 }
28093 }
28094 if (argc == 2) {
28095 int _v;
28096 {
28097 void *ptr;
28098 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28099 _v = 0;
28100 PyErr_Clear();
28101 } else {
28102 _v = 1;
28103 }
28104 }
28105 if (_v) {
28106 _v = SWIG_Check_int(argv[1]);
28107 if (_v) {
28108 return _wrap_DataFormat___ne____SWIG_0(self,args);
28109 }
28110 }
28111 }
28112
28113 Py_INCREF(Py_NotImplemented);
28114 return Py_NotImplemented;
28115 }
28116
28117
28118 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
28119 PyObject *resultobj = NULL;
28120 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28121 wxDataFormatId arg2 ;
28122 PyObject * obj0 = 0 ;
28123 PyObject * obj1 = 0 ;
28124 char *kwnames[] = {
28125 (char *) "self",(char *) "format", NULL
28126 };
28127
28128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
28129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28130 if (SWIG_arg_fail(1)) SWIG_fail;
28131 {
28132 arg2 = static_cast<wxDataFormatId >(SWIG_As_int(obj1));
28133 if (SWIG_arg_fail(2)) SWIG_fail;
28134 }
28135 {
28136 PyThreadState* __tstate = wxPyBeginAllowThreads();
28137 (arg1)->SetType(arg2);
28138
28139 wxPyEndAllowThreads(__tstate);
28140 if (PyErr_Occurred()) SWIG_fail;
28141 }
28142 Py_INCREF(Py_None); resultobj = Py_None;
28143 return resultobj;
28144 fail:
28145 return NULL;
28146 }
28147
28148
28149 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
28150 PyObject *resultobj = NULL;
28151 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28152 wxDataFormatId result;
28153 PyObject * obj0 = 0 ;
28154 char *kwnames[] = {
28155 (char *) "self", NULL
28156 };
28157
28158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
28159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28160 if (SWIG_arg_fail(1)) SWIG_fail;
28161 {
28162 PyThreadState* __tstate = wxPyBeginAllowThreads();
28163 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
28164
28165 wxPyEndAllowThreads(__tstate);
28166 if (PyErr_Occurred()) SWIG_fail;
28167 }
28168 resultobj = SWIG_From_int((result));
28169 return resultobj;
28170 fail:
28171 return NULL;
28172 }
28173
28174
28175 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
28176 PyObject *resultobj = NULL;
28177 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28178 wxString result;
28179 PyObject * obj0 = 0 ;
28180 char *kwnames[] = {
28181 (char *) "self", NULL
28182 };
28183
28184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
28185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28186 if (SWIG_arg_fail(1)) SWIG_fail;
28187 {
28188 PyThreadState* __tstate = wxPyBeginAllowThreads();
28189 result = ((wxDataFormat const *)arg1)->GetId();
28190
28191 wxPyEndAllowThreads(__tstate);
28192 if (PyErr_Occurred()) SWIG_fail;
28193 }
28194 {
28195 #if wxUSE_UNICODE
28196 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28197 #else
28198 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28199 #endif
28200 }
28201 return resultobj;
28202 fail:
28203 return NULL;
28204 }
28205
28206
28207 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
28208 PyObject *resultobj = NULL;
28209 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
28210 wxString *arg2 = 0 ;
28211 bool temp2 = false ;
28212 PyObject * obj0 = 0 ;
28213 PyObject * obj1 = 0 ;
28214 char *kwnames[] = {
28215 (char *) "self",(char *) "format", NULL
28216 };
28217
28218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
28219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28220 if (SWIG_arg_fail(1)) SWIG_fail;
28221 {
28222 arg2 = wxString_in_helper(obj1);
28223 if (arg2 == NULL) SWIG_fail;
28224 temp2 = true;
28225 }
28226 {
28227 PyThreadState* __tstate = wxPyBeginAllowThreads();
28228 (arg1)->SetId((wxString const &)*arg2);
28229
28230 wxPyEndAllowThreads(__tstate);
28231 if (PyErr_Occurred()) SWIG_fail;
28232 }
28233 Py_INCREF(Py_None); resultobj = Py_None;
28234 {
28235 if (temp2)
28236 delete arg2;
28237 }
28238 return resultobj;
28239 fail:
28240 {
28241 if (temp2)
28242 delete arg2;
28243 }
28244 return NULL;
28245 }
28246
28247
28248 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
28249 PyObject *obj;
28250 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28251 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
28252 Py_INCREF(obj);
28253 return Py_BuildValue((char *)"");
28254 }
28255 static int _wrap_FormatInvalid_set(PyObject *) {
28256 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
28257 return 1;
28258 }
28259
28260
28261 static PyObject *_wrap_FormatInvalid_get(void) {
28262 PyObject *pyobj = NULL;
28263
28264 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
28265 return pyobj;
28266 }
28267
28268
28269 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28270 PyObject *resultobj = NULL;
28271 wxDataObject *arg1 = (wxDataObject *) 0 ;
28272 PyObject * obj0 = 0 ;
28273 char *kwnames[] = {
28274 (char *) "self", NULL
28275 };
28276
28277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
28278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28279 if (SWIG_arg_fail(1)) SWIG_fail;
28280 {
28281 PyThreadState* __tstate = wxPyBeginAllowThreads();
28282 delete arg1;
28283
28284 wxPyEndAllowThreads(__tstate);
28285 if (PyErr_Occurred()) SWIG_fail;
28286 }
28287 Py_INCREF(Py_None); resultobj = Py_None;
28288 return resultobj;
28289 fail:
28290 return NULL;
28291 }
28292
28293
28294 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
28295 PyObject *resultobj = NULL;
28296 wxDataObject *arg1 = (wxDataObject *) 0 ;
28297 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
28298 SwigValueWrapper<wxDataFormat > result;
28299 PyObject * obj0 = 0 ;
28300 PyObject * obj1 = 0 ;
28301 char *kwnames[] = {
28302 (char *) "self",(char *) "dir", NULL
28303 };
28304
28305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
28306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28307 if (SWIG_arg_fail(1)) SWIG_fail;
28308 if (obj1) {
28309 {
28310 arg2 = static_cast<wxDataObject::Direction >(SWIG_As_int(obj1));
28311 if (SWIG_arg_fail(2)) SWIG_fail;
28312 }
28313 }
28314 {
28315 PyThreadState* __tstate = wxPyBeginAllowThreads();
28316 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
28317
28318 wxPyEndAllowThreads(__tstate);
28319 if (PyErr_Occurred()) SWIG_fail;
28320 }
28321 {
28322 wxDataFormat * resultptr;
28323 resultptr = new wxDataFormat(static_cast<wxDataFormat & >(result));
28324 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
28325 }
28326 return resultobj;
28327 fail:
28328 return NULL;
28329 }
28330
28331
28332 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
28333 PyObject *resultobj = NULL;
28334 wxDataObject *arg1 = (wxDataObject *) 0 ;
28335 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
28336 size_t result;
28337 PyObject * obj0 = 0 ;
28338 PyObject * obj1 = 0 ;
28339 char *kwnames[] = {
28340 (char *) "self",(char *) "dir", NULL
28341 };
28342
28343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
28344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28345 if (SWIG_arg_fail(1)) SWIG_fail;
28346 if (obj1) {
28347 {
28348 arg2 = static_cast<wxDataObject::Direction >(SWIG_As_int(obj1));
28349 if (SWIG_arg_fail(2)) SWIG_fail;
28350 }
28351 }
28352 {
28353 PyThreadState* __tstate = wxPyBeginAllowThreads();
28354 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
28355
28356 wxPyEndAllowThreads(__tstate);
28357 if (PyErr_Occurred()) SWIG_fail;
28358 }
28359 {
28360 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
28361 }
28362 return resultobj;
28363 fail:
28364 return NULL;
28365 }
28366
28367
28368 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
28369 PyObject *resultobj = NULL;
28370 wxDataObject *arg1 = (wxDataObject *) 0 ;
28371 wxDataFormat *arg2 = 0 ;
28372 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
28373 bool result;
28374 PyObject * obj0 = 0 ;
28375 PyObject * obj1 = 0 ;
28376 PyObject * obj2 = 0 ;
28377 char *kwnames[] = {
28378 (char *) "self",(char *) "format",(char *) "dir", NULL
28379 };
28380
28381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
28382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28383 if (SWIG_arg_fail(1)) SWIG_fail;
28384 {
28385 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28386 if (SWIG_arg_fail(2)) SWIG_fail;
28387 if (arg2 == NULL) {
28388 SWIG_null_ref("wxDataFormat");
28389 }
28390 if (SWIG_arg_fail(2)) SWIG_fail;
28391 }
28392 if (obj2) {
28393 {
28394 arg3 = static_cast<wxDataObject::Direction >(SWIG_As_int(obj2));
28395 if (SWIG_arg_fail(3)) SWIG_fail;
28396 }
28397 }
28398 {
28399 PyThreadState* __tstate = wxPyBeginAllowThreads();
28400 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
28401
28402 wxPyEndAllowThreads(__tstate);
28403 if (PyErr_Occurred()) SWIG_fail;
28404 }
28405 {
28406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28407 }
28408 return resultobj;
28409 fail:
28410 return NULL;
28411 }
28412
28413
28414 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
28415 PyObject *resultobj = NULL;
28416 wxDataObject *arg1 = (wxDataObject *) 0 ;
28417 wxDataFormat *arg2 = 0 ;
28418 size_t result;
28419 PyObject * obj0 = 0 ;
28420 PyObject * obj1 = 0 ;
28421 char *kwnames[] = {
28422 (char *) "self",(char *) "format", NULL
28423 };
28424
28425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
28426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28427 if (SWIG_arg_fail(1)) SWIG_fail;
28428 {
28429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28430 if (SWIG_arg_fail(2)) SWIG_fail;
28431 if (arg2 == NULL) {
28432 SWIG_null_ref("wxDataFormat");
28433 }
28434 if (SWIG_arg_fail(2)) SWIG_fail;
28435 }
28436 {
28437 PyThreadState* __tstate = wxPyBeginAllowThreads();
28438 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
28439
28440 wxPyEndAllowThreads(__tstate);
28441 if (PyErr_Occurred()) SWIG_fail;
28442 }
28443 {
28444 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
28445 }
28446 return resultobj;
28447 fail:
28448 return NULL;
28449 }
28450
28451
28452 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
28453 PyObject *resultobj = NULL;
28454 wxDataObject *arg1 = (wxDataObject *) 0 ;
28455 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
28456 PyObject *result;
28457 PyObject * obj0 = 0 ;
28458 PyObject * obj1 = 0 ;
28459 char *kwnames[] = {
28460 (char *) "self",(char *) "dir", NULL
28461 };
28462
28463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
28464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28465 if (SWIG_arg_fail(1)) SWIG_fail;
28466 if (obj1) {
28467 {
28468 arg2 = static_cast<wxDataObject::Direction >(SWIG_As_int(obj1));
28469 if (SWIG_arg_fail(2)) SWIG_fail;
28470 }
28471 }
28472 {
28473 PyThreadState* __tstate = wxPyBeginAllowThreads();
28474 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
28475
28476 wxPyEndAllowThreads(__tstate);
28477 if (PyErr_Occurred()) SWIG_fail;
28478 }
28479 resultobj = result;
28480 return resultobj;
28481 fail:
28482 return NULL;
28483 }
28484
28485
28486 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
28487 PyObject *resultobj = NULL;
28488 wxDataObject *arg1 = (wxDataObject *) 0 ;
28489 wxDataFormat *arg2 = 0 ;
28490 PyObject *result;
28491 PyObject * obj0 = 0 ;
28492 PyObject * obj1 = 0 ;
28493 char *kwnames[] = {
28494 (char *) "self",(char *) "format", NULL
28495 };
28496
28497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
28498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28499 if (SWIG_arg_fail(1)) SWIG_fail;
28500 {
28501 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28502 if (SWIG_arg_fail(2)) SWIG_fail;
28503 if (arg2 == NULL) {
28504 SWIG_null_ref("wxDataFormat");
28505 }
28506 if (SWIG_arg_fail(2)) SWIG_fail;
28507 }
28508 {
28509 PyThreadState* __tstate = wxPyBeginAllowThreads();
28510 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
28511
28512 wxPyEndAllowThreads(__tstate);
28513 if (PyErr_Occurred()) SWIG_fail;
28514 }
28515 resultobj = result;
28516 return resultobj;
28517 fail:
28518 return NULL;
28519 }
28520
28521
28522 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28523 PyObject *resultobj = NULL;
28524 wxDataObject *arg1 = (wxDataObject *) 0 ;
28525 wxDataFormat *arg2 = 0 ;
28526 PyObject *arg3 = (PyObject *) 0 ;
28527 bool result;
28528 PyObject * obj0 = 0 ;
28529 PyObject * obj1 = 0 ;
28530 PyObject * obj2 = 0 ;
28531 char *kwnames[] = {
28532 (char *) "self",(char *) "format",(char *) "data", NULL
28533 };
28534
28535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
28536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28537 if (SWIG_arg_fail(1)) SWIG_fail;
28538 {
28539 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28540 if (SWIG_arg_fail(2)) SWIG_fail;
28541 if (arg2 == NULL) {
28542 SWIG_null_ref("wxDataFormat");
28543 }
28544 if (SWIG_arg_fail(2)) SWIG_fail;
28545 }
28546 arg3 = obj2;
28547 {
28548 PyThreadState* __tstate = wxPyBeginAllowThreads();
28549 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
28550
28551 wxPyEndAllowThreads(__tstate);
28552 if (PyErr_Occurred()) SWIG_fail;
28553 }
28554 {
28555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28556 }
28557 return resultobj;
28558 fail:
28559 return NULL;
28560 }
28561
28562
28563 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
28564 PyObject *obj;
28565 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28566 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
28567 Py_INCREF(obj);
28568 return Py_BuildValue((char *)"");
28569 }
28570 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
28571 PyObject *resultobj = NULL;
28572 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
28573 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
28574 wxDataObjectSimple *result;
28575 PyObject * obj0 = 0 ;
28576 char *kwnames[] = {
28577 (char *) "format", NULL
28578 };
28579
28580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
28581 if (obj0) {
28582 {
28583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28584 if (SWIG_arg_fail(1)) SWIG_fail;
28585 if (arg1 == NULL) {
28586 SWIG_null_ref("wxDataFormat");
28587 }
28588 if (SWIG_arg_fail(1)) SWIG_fail;
28589 }
28590 }
28591 {
28592 PyThreadState* __tstate = wxPyBeginAllowThreads();
28593 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
28594
28595 wxPyEndAllowThreads(__tstate);
28596 if (PyErr_Occurred()) SWIG_fail;
28597 }
28598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
28599 return resultobj;
28600 fail:
28601 return NULL;
28602 }
28603
28604
28605 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
28606 PyObject *resultobj = NULL;
28607 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28608 wxDataFormat *result;
28609 PyObject * obj0 = 0 ;
28610 char *kwnames[] = {
28611 (char *) "self", NULL
28612 };
28613
28614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
28615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28616 if (SWIG_arg_fail(1)) SWIG_fail;
28617 {
28618 PyThreadState* __tstate = wxPyBeginAllowThreads();
28619 {
28620 wxDataFormat const &_result_ref = (arg1)->GetFormat();
28621 result = (wxDataFormat *) &_result_ref;
28622 }
28623
28624 wxPyEndAllowThreads(__tstate);
28625 if (PyErr_Occurred()) SWIG_fail;
28626 }
28627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
28628 return resultobj;
28629 fail:
28630 return NULL;
28631 }
28632
28633
28634 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
28635 PyObject *resultobj = NULL;
28636 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28637 wxDataFormat *arg2 = 0 ;
28638 PyObject * obj0 = 0 ;
28639 PyObject * obj1 = 0 ;
28640 char *kwnames[] = {
28641 (char *) "self",(char *) "format", NULL
28642 };
28643
28644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
28645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28646 if (SWIG_arg_fail(1)) SWIG_fail;
28647 {
28648 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28649 if (SWIG_arg_fail(2)) SWIG_fail;
28650 if (arg2 == NULL) {
28651 SWIG_null_ref("wxDataFormat");
28652 }
28653 if (SWIG_arg_fail(2)) SWIG_fail;
28654 }
28655 {
28656 PyThreadState* __tstate = wxPyBeginAllowThreads();
28657 (arg1)->SetFormat((wxDataFormat const &)*arg2);
28658
28659 wxPyEndAllowThreads(__tstate);
28660 if (PyErr_Occurred()) SWIG_fail;
28661 }
28662 Py_INCREF(Py_None); resultobj = Py_None;
28663 return resultobj;
28664 fail:
28665 return NULL;
28666 }
28667
28668
28669 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
28670 PyObject *resultobj = NULL;
28671 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28672 size_t result;
28673 PyObject * obj0 = 0 ;
28674 char *kwnames[] = {
28675 (char *) "self", NULL
28676 };
28677
28678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
28679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28680 if (SWIG_arg_fail(1)) SWIG_fail;
28681 {
28682 PyThreadState* __tstate = wxPyBeginAllowThreads();
28683 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
28684
28685 wxPyEndAllowThreads(__tstate);
28686 if (PyErr_Occurred()) SWIG_fail;
28687 }
28688 {
28689 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
28690 }
28691 return resultobj;
28692 fail:
28693 return NULL;
28694 }
28695
28696
28697 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
28698 PyObject *resultobj = NULL;
28699 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28700 PyObject *result;
28701 PyObject * obj0 = 0 ;
28702 char *kwnames[] = {
28703 (char *) "self", NULL
28704 };
28705
28706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
28707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28708 if (SWIG_arg_fail(1)) SWIG_fail;
28709 {
28710 PyThreadState* __tstate = wxPyBeginAllowThreads();
28711 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
28712
28713 wxPyEndAllowThreads(__tstate);
28714 if (PyErr_Occurred()) SWIG_fail;
28715 }
28716 resultobj = result;
28717 return resultobj;
28718 fail:
28719 return NULL;
28720 }
28721
28722
28723 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28724 PyObject *resultobj = NULL;
28725 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
28726 PyObject *arg2 = (PyObject *) 0 ;
28727 bool result;
28728 PyObject * obj0 = 0 ;
28729 PyObject * obj1 = 0 ;
28730 char *kwnames[] = {
28731 (char *) "self",(char *) "data", NULL
28732 };
28733
28734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
28735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28736 if (SWIG_arg_fail(1)) SWIG_fail;
28737 arg2 = obj1;
28738 {
28739 PyThreadState* __tstate = wxPyBeginAllowThreads();
28740 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
28741
28742 wxPyEndAllowThreads(__tstate);
28743 if (PyErr_Occurred()) SWIG_fail;
28744 }
28745 {
28746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28747 }
28748 return resultobj;
28749 fail:
28750 return NULL;
28751 }
28752
28753
28754 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
28755 PyObject *obj;
28756 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28757 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
28758 Py_INCREF(obj);
28759 return Py_BuildValue((char *)"");
28760 }
28761 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
28762 PyObject *resultobj = NULL;
28763 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
28764 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
28765 wxPyDataObjectSimple *result;
28766 PyObject * obj0 = 0 ;
28767 char *kwnames[] = {
28768 (char *) "format", NULL
28769 };
28770
28771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
28772 if (obj0) {
28773 {
28774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28775 if (SWIG_arg_fail(1)) SWIG_fail;
28776 if (arg1 == NULL) {
28777 SWIG_null_ref("wxDataFormat");
28778 }
28779 if (SWIG_arg_fail(1)) SWIG_fail;
28780 }
28781 }
28782 {
28783 PyThreadState* __tstate = wxPyBeginAllowThreads();
28784 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
28785
28786 wxPyEndAllowThreads(__tstate);
28787 if (PyErr_Occurred()) SWIG_fail;
28788 }
28789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
28790 return resultobj;
28791 fail:
28792 return NULL;
28793 }
28794
28795
28796 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28797 PyObject *resultobj = NULL;
28798 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
28799 PyObject *arg2 = (PyObject *) 0 ;
28800 PyObject *arg3 = (PyObject *) 0 ;
28801 PyObject * obj0 = 0 ;
28802 PyObject * obj1 = 0 ;
28803 PyObject * obj2 = 0 ;
28804 char *kwnames[] = {
28805 (char *) "self",(char *) "self",(char *) "_class", NULL
28806 };
28807
28808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
28810 if (SWIG_arg_fail(1)) SWIG_fail;
28811 arg2 = obj1;
28812 arg3 = obj2;
28813 {
28814 PyThreadState* __tstate = wxPyBeginAllowThreads();
28815 (arg1)->_setCallbackInfo(arg2,arg3);
28816
28817 wxPyEndAllowThreads(__tstate);
28818 if (PyErr_Occurred()) SWIG_fail;
28819 }
28820 Py_INCREF(Py_None); resultobj = Py_None;
28821 return resultobj;
28822 fail:
28823 return NULL;
28824 }
28825
28826
28827 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
28828 PyObject *obj;
28829 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28830 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
28831 Py_INCREF(obj);
28832 return Py_BuildValue((char *)"");
28833 }
28834 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
28835 PyObject *resultobj = NULL;
28836 wxDataObjectComposite *result;
28837 char *kwnames[] = {
28838 NULL
28839 };
28840
28841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
28842 {
28843 PyThreadState* __tstate = wxPyBeginAllowThreads();
28844 result = (wxDataObjectComposite *)new wxDataObjectComposite();
28845
28846 wxPyEndAllowThreads(__tstate);
28847 if (PyErr_Occurred()) SWIG_fail;
28848 }
28849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
28850 return resultobj;
28851 fail:
28852 return NULL;
28853 }
28854
28855
28856 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
28857 PyObject *resultobj = NULL;
28858 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
28859 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
28860 bool arg3 = (bool) false ;
28861 PyObject * obj0 = 0 ;
28862 PyObject * obj1 = 0 ;
28863 PyObject * obj2 = 0 ;
28864 char *kwnames[] = {
28865 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
28866 };
28867
28868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
28869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
28870 if (SWIG_arg_fail(1)) SWIG_fail;
28871 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28872 if (SWIG_arg_fail(2)) SWIG_fail;
28873 if (obj2) {
28874 {
28875 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
28876 if (SWIG_arg_fail(3)) SWIG_fail;
28877 }
28878 }
28879 {
28880 PyThreadState* __tstate = wxPyBeginAllowThreads();
28881 (arg1)->Add(arg2,arg3);
28882
28883 wxPyEndAllowThreads(__tstate);
28884 if (PyErr_Occurred()) SWIG_fail;
28885 }
28886 Py_INCREF(Py_None); resultobj = Py_None;
28887 return resultobj;
28888 fail:
28889 return NULL;
28890 }
28891
28892
28893 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
28894 PyObject *obj;
28895 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28896 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
28897 Py_INCREF(obj);
28898 return Py_BuildValue((char *)"");
28899 }
28900 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28901 PyObject *resultobj = NULL;
28902 wxString const &arg1_defvalue = wxPyEmptyString ;
28903 wxString *arg1 = (wxString *) &arg1_defvalue ;
28904 wxTextDataObject *result;
28905 bool temp1 = false ;
28906 PyObject * obj0 = 0 ;
28907 char *kwnames[] = {
28908 (char *) "text", NULL
28909 };
28910
28911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
28912 if (obj0) {
28913 {
28914 arg1 = wxString_in_helper(obj0);
28915 if (arg1 == NULL) SWIG_fail;
28916 temp1 = true;
28917 }
28918 }
28919 {
28920 PyThreadState* __tstate = wxPyBeginAllowThreads();
28921 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
28922
28923 wxPyEndAllowThreads(__tstate);
28924 if (PyErr_Occurred()) SWIG_fail;
28925 }
28926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
28927 {
28928 if (temp1)
28929 delete arg1;
28930 }
28931 return resultobj;
28932 fail:
28933 {
28934 if (temp1)
28935 delete arg1;
28936 }
28937 return NULL;
28938 }
28939
28940
28941 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
28942 PyObject *resultobj = NULL;
28943 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
28944 size_t result;
28945 PyObject * obj0 = 0 ;
28946 char *kwnames[] = {
28947 (char *) "self", NULL
28948 };
28949
28950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
28951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28952 if (SWIG_arg_fail(1)) SWIG_fail;
28953 {
28954 PyThreadState* __tstate = wxPyBeginAllowThreads();
28955 result = (size_t)(arg1)->GetTextLength();
28956
28957 wxPyEndAllowThreads(__tstate);
28958 if (PyErr_Occurred()) SWIG_fail;
28959 }
28960 {
28961 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
28962 }
28963 return resultobj;
28964 fail:
28965 return NULL;
28966 }
28967
28968
28969 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
28970 PyObject *resultobj = NULL;
28971 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
28972 wxString result;
28973 PyObject * obj0 = 0 ;
28974 char *kwnames[] = {
28975 (char *) "self", NULL
28976 };
28977
28978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
28979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
28980 if (SWIG_arg_fail(1)) SWIG_fail;
28981 {
28982 PyThreadState* __tstate = wxPyBeginAllowThreads();
28983 result = (arg1)->GetText();
28984
28985 wxPyEndAllowThreads(__tstate);
28986 if (PyErr_Occurred()) SWIG_fail;
28987 }
28988 {
28989 #if wxUSE_UNICODE
28990 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28991 #else
28992 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28993 #endif
28994 }
28995 return resultobj;
28996 fail:
28997 return NULL;
28998 }
28999
29000
29001 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
29002 PyObject *resultobj = NULL;
29003 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
29004 wxString *arg2 = 0 ;
29005 bool temp2 = false ;
29006 PyObject * obj0 = 0 ;
29007 PyObject * obj1 = 0 ;
29008 char *kwnames[] = {
29009 (char *) "self",(char *) "text", NULL
29010 };
29011
29012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
29013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
29014 if (SWIG_arg_fail(1)) SWIG_fail;
29015 {
29016 arg2 = wxString_in_helper(obj1);
29017 if (arg2 == NULL) SWIG_fail;
29018 temp2 = true;
29019 }
29020 {
29021 PyThreadState* __tstate = wxPyBeginAllowThreads();
29022 (arg1)->SetText((wxString const &)*arg2);
29023
29024 wxPyEndAllowThreads(__tstate);
29025 if (PyErr_Occurred()) SWIG_fail;
29026 }
29027 Py_INCREF(Py_None); resultobj = Py_None;
29028 {
29029 if (temp2)
29030 delete arg2;
29031 }
29032 return resultobj;
29033 fail:
29034 {
29035 if (temp2)
29036 delete arg2;
29037 }
29038 return NULL;
29039 }
29040
29041
29042 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
29043 PyObject *obj;
29044 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29045 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
29046 Py_INCREF(obj);
29047 return Py_BuildValue((char *)"");
29048 }
29049 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29050 PyObject *resultobj = NULL;
29051 wxString const &arg1_defvalue = wxPyEmptyString ;
29052 wxString *arg1 = (wxString *) &arg1_defvalue ;
29053 wxPyTextDataObject *result;
29054 bool temp1 = false ;
29055 PyObject * obj0 = 0 ;
29056 char *kwnames[] = {
29057 (char *) "text", NULL
29058 };
29059
29060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
29061 if (obj0) {
29062 {
29063 arg1 = wxString_in_helper(obj0);
29064 if (arg1 == NULL) SWIG_fail;
29065 temp1 = true;
29066 }
29067 }
29068 {
29069 PyThreadState* __tstate = wxPyBeginAllowThreads();
29070 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
29071
29072 wxPyEndAllowThreads(__tstate);
29073 if (PyErr_Occurred()) SWIG_fail;
29074 }
29075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
29076 {
29077 if (temp1)
29078 delete arg1;
29079 }
29080 return resultobj;
29081 fail:
29082 {
29083 if (temp1)
29084 delete arg1;
29085 }
29086 return NULL;
29087 }
29088
29089
29090 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29091 PyObject *resultobj = NULL;
29092 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
29093 PyObject *arg2 = (PyObject *) 0 ;
29094 PyObject *arg3 = (PyObject *) 0 ;
29095 PyObject * obj0 = 0 ;
29096 PyObject * obj1 = 0 ;
29097 PyObject * obj2 = 0 ;
29098 char *kwnames[] = {
29099 (char *) "self",(char *) "self",(char *) "_class", NULL
29100 };
29101
29102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
29104 if (SWIG_arg_fail(1)) SWIG_fail;
29105 arg2 = obj1;
29106 arg3 = obj2;
29107 {
29108 PyThreadState* __tstate = wxPyBeginAllowThreads();
29109 (arg1)->_setCallbackInfo(arg2,arg3);
29110
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 Py_INCREF(Py_None); resultobj = Py_None;
29115 return resultobj;
29116 fail:
29117 return NULL;
29118 }
29119
29120
29121 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
29122 PyObject *obj;
29123 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29124 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
29125 Py_INCREF(obj);
29126 return Py_BuildValue((char *)"");
29127 }
29128 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29129 PyObject *resultobj = NULL;
29130 wxBitmap const &arg1_defvalue = wxNullBitmap ;
29131 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
29132 wxBitmapDataObject *result;
29133 PyObject * obj0 = 0 ;
29134 char *kwnames[] = {
29135 (char *) "bitmap", NULL
29136 };
29137
29138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
29139 if (obj0) {
29140 {
29141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
29142 if (SWIG_arg_fail(1)) SWIG_fail;
29143 if (arg1 == NULL) {
29144 SWIG_null_ref("wxBitmap");
29145 }
29146 if (SWIG_arg_fail(1)) SWIG_fail;
29147 }
29148 }
29149 {
29150 PyThreadState* __tstate = wxPyBeginAllowThreads();
29151 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
29152
29153 wxPyEndAllowThreads(__tstate);
29154 if (PyErr_Occurred()) SWIG_fail;
29155 }
29156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
29157 return resultobj;
29158 fail:
29159 return NULL;
29160 }
29161
29162
29163 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
29164 PyObject *resultobj = NULL;
29165 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
29166 wxBitmap result;
29167 PyObject * obj0 = 0 ;
29168 char *kwnames[] = {
29169 (char *) "self", NULL
29170 };
29171
29172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
29173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
29174 if (SWIG_arg_fail(1)) SWIG_fail;
29175 {
29176 PyThreadState* __tstate = wxPyBeginAllowThreads();
29177 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
29178
29179 wxPyEndAllowThreads(__tstate);
29180 if (PyErr_Occurred()) SWIG_fail;
29181 }
29182 {
29183 wxBitmap * resultptr;
29184 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
29185 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
29186 }
29187 return resultobj;
29188 fail:
29189 return NULL;
29190 }
29191
29192
29193 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
29194 PyObject *resultobj = NULL;
29195 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
29196 wxBitmap *arg2 = 0 ;
29197 PyObject * obj0 = 0 ;
29198 PyObject * obj1 = 0 ;
29199 char *kwnames[] = {
29200 (char *) "self",(char *) "bitmap", NULL
29201 };
29202
29203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
29204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
29205 if (SWIG_arg_fail(1)) SWIG_fail;
29206 {
29207 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
29208 if (SWIG_arg_fail(2)) SWIG_fail;
29209 if (arg2 == NULL) {
29210 SWIG_null_ref("wxBitmap");
29211 }
29212 if (SWIG_arg_fail(2)) SWIG_fail;
29213 }
29214 {
29215 PyThreadState* __tstate = wxPyBeginAllowThreads();
29216 (arg1)->SetBitmap((wxBitmap const &)*arg2);
29217
29218 wxPyEndAllowThreads(__tstate);
29219 if (PyErr_Occurred()) SWIG_fail;
29220 }
29221 Py_INCREF(Py_None); resultobj = Py_None;
29222 return resultobj;
29223 fail:
29224 return NULL;
29225 }
29226
29227
29228 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
29229 PyObject *obj;
29230 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29231 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
29232 Py_INCREF(obj);
29233 return Py_BuildValue((char *)"");
29234 }
29235 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29236 PyObject *resultobj = NULL;
29237 wxBitmap const &arg1_defvalue = wxNullBitmap ;
29238 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
29239 wxPyBitmapDataObject *result;
29240 PyObject * obj0 = 0 ;
29241 char *kwnames[] = {
29242 (char *) "bitmap", NULL
29243 };
29244
29245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
29246 if (obj0) {
29247 {
29248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
29249 if (SWIG_arg_fail(1)) SWIG_fail;
29250 if (arg1 == NULL) {
29251 SWIG_null_ref("wxBitmap");
29252 }
29253 if (SWIG_arg_fail(1)) SWIG_fail;
29254 }
29255 }
29256 {
29257 PyThreadState* __tstate = wxPyBeginAllowThreads();
29258 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
29259
29260 wxPyEndAllowThreads(__tstate);
29261 if (PyErr_Occurred()) SWIG_fail;
29262 }
29263 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
29264 return resultobj;
29265 fail:
29266 return NULL;
29267 }
29268
29269
29270 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29271 PyObject *resultobj = NULL;
29272 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
29273 PyObject *arg2 = (PyObject *) 0 ;
29274 PyObject *arg3 = (PyObject *) 0 ;
29275 PyObject * obj0 = 0 ;
29276 PyObject * obj1 = 0 ;
29277 PyObject * obj2 = 0 ;
29278 char *kwnames[] = {
29279 (char *) "self",(char *) "self",(char *) "_class", NULL
29280 };
29281
29282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
29284 if (SWIG_arg_fail(1)) SWIG_fail;
29285 arg2 = obj1;
29286 arg3 = obj2;
29287 {
29288 PyThreadState* __tstate = wxPyBeginAllowThreads();
29289 (arg1)->_setCallbackInfo(arg2,arg3);
29290
29291 wxPyEndAllowThreads(__tstate);
29292 if (PyErr_Occurred()) SWIG_fail;
29293 }
29294 Py_INCREF(Py_None); resultobj = Py_None;
29295 return resultobj;
29296 fail:
29297 return NULL;
29298 }
29299
29300
29301 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
29302 PyObject *obj;
29303 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29304 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
29305 Py_INCREF(obj);
29306 return Py_BuildValue((char *)"");
29307 }
29308 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29309 PyObject *resultobj = NULL;
29310 wxFileDataObject *result;
29311 char *kwnames[] = {
29312 NULL
29313 };
29314
29315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
29316 {
29317 PyThreadState* __tstate = wxPyBeginAllowThreads();
29318 result = (wxFileDataObject *)new wxFileDataObject();
29319
29320 wxPyEndAllowThreads(__tstate);
29321 if (PyErr_Occurred()) SWIG_fail;
29322 }
29323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
29324 return resultobj;
29325 fail:
29326 return NULL;
29327 }
29328
29329
29330 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
29331 PyObject *resultobj = NULL;
29332 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
29333 wxArrayString *result;
29334 PyObject * obj0 = 0 ;
29335 char *kwnames[] = {
29336 (char *) "self", NULL
29337 };
29338
29339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
29340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
29341 if (SWIG_arg_fail(1)) SWIG_fail;
29342 {
29343 PyThreadState* __tstate = wxPyBeginAllowThreads();
29344 {
29345 wxArrayString const &_result_ref = (arg1)->GetFilenames();
29346 result = (wxArrayString *) &_result_ref;
29347 }
29348
29349 wxPyEndAllowThreads(__tstate);
29350 if (PyErr_Occurred()) SWIG_fail;
29351 }
29352 {
29353 resultobj = wxArrayString2PyList_helper(*result);
29354 }
29355 return resultobj;
29356 fail:
29357 return NULL;
29358 }
29359
29360
29361 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
29362 PyObject *resultobj = NULL;
29363 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
29364 wxString *arg2 = 0 ;
29365 bool temp2 = false ;
29366 PyObject * obj0 = 0 ;
29367 PyObject * obj1 = 0 ;
29368 char *kwnames[] = {
29369 (char *) "self",(char *) "filename", NULL
29370 };
29371
29372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
29373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
29374 if (SWIG_arg_fail(1)) SWIG_fail;
29375 {
29376 arg2 = wxString_in_helper(obj1);
29377 if (arg2 == NULL) SWIG_fail;
29378 temp2 = true;
29379 }
29380 {
29381 PyThreadState* __tstate = wxPyBeginAllowThreads();
29382 (arg1)->AddFile((wxString const &)*arg2);
29383
29384 wxPyEndAllowThreads(__tstate);
29385 if (PyErr_Occurred()) SWIG_fail;
29386 }
29387 Py_INCREF(Py_None); resultobj = Py_None;
29388 {
29389 if (temp2)
29390 delete arg2;
29391 }
29392 return resultobj;
29393 fail:
29394 {
29395 if (temp2)
29396 delete arg2;
29397 }
29398 return NULL;
29399 }
29400
29401
29402 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
29403 PyObject *obj;
29404 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29405 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
29406 Py_INCREF(obj);
29407 return Py_BuildValue((char *)"");
29408 }
29409 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
29410 PyObject *resultobj = NULL;
29411 wxDataFormat *arg1 = 0 ;
29412 wxCustomDataObject *result;
29413 PyObject * obj0 = 0 ;
29414
29415 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
29416 {
29417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29418 if (SWIG_arg_fail(1)) SWIG_fail;
29419 if (arg1 == NULL) {
29420 SWIG_null_ref("wxDataFormat");
29421 }
29422 if (SWIG_arg_fail(1)) SWIG_fail;
29423 }
29424 {
29425 PyThreadState* __tstate = wxPyBeginAllowThreads();
29426 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
29427
29428 wxPyEndAllowThreads(__tstate);
29429 if (PyErr_Occurred()) SWIG_fail;
29430 }
29431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
29432 return resultobj;
29433 fail:
29434 return NULL;
29435 }
29436
29437
29438 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
29439 PyObject *resultobj = NULL;
29440 wxString *arg1 = 0 ;
29441 wxCustomDataObject *result;
29442 bool temp1 = false ;
29443 PyObject * obj0 = 0 ;
29444
29445 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
29446 {
29447 arg1 = wxString_in_helper(obj0);
29448 if (arg1 == NULL) SWIG_fail;
29449 temp1 = true;
29450 }
29451 {
29452 PyThreadState* __tstate = wxPyBeginAllowThreads();
29453 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
29454
29455 wxPyEndAllowThreads(__tstate);
29456 if (PyErr_Occurred()) SWIG_fail;
29457 }
29458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
29459 {
29460 if (temp1)
29461 delete arg1;
29462 }
29463 return resultobj;
29464 fail:
29465 {
29466 if (temp1)
29467 delete arg1;
29468 }
29469 return NULL;
29470 }
29471
29472
29473 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
29474 PyObject *resultobj = NULL;
29475 wxCustomDataObject *result;
29476
29477 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
29478 {
29479 PyThreadState* __tstate = wxPyBeginAllowThreads();
29480 result = (wxCustomDataObject *)new wxCustomDataObject();
29481
29482 wxPyEndAllowThreads(__tstate);
29483 if (PyErr_Occurred()) SWIG_fail;
29484 }
29485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
29486 return resultobj;
29487 fail:
29488 return NULL;
29489 }
29490
29491
29492 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
29493 int argc;
29494 PyObject *argv[2];
29495 int ii;
29496
29497 argc = PyObject_Length(args);
29498 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
29499 argv[ii] = PyTuple_GetItem(args,ii);
29500 }
29501 if (argc == 0) {
29502 return _wrap_new_CustomDataObject__SWIG_2(self,args);
29503 }
29504 if (argc == 1) {
29505 int _v;
29506 {
29507 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
29508 }
29509 if (_v) {
29510 return _wrap_new_CustomDataObject__SWIG_1(self,args);
29511 }
29512 }
29513 if (argc == 1) {
29514 int _v;
29515 {
29516 void *ptr = 0;
29517 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
29518 _v = 0;
29519 PyErr_Clear();
29520 } else {
29521 _v = (ptr != 0);
29522 }
29523 }
29524 if (_v) {
29525 return _wrap_new_CustomDataObject__SWIG_0(self,args);
29526 }
29527 }
29528
29529 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
29530 return NULL;
29531 }
29532
29533
29534 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29535 PyObject *resultobj = NULL;
29536 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
29537 PyObject *arg2 = (PyObject *) 0 ;
29538 bool result;
29539 PyObject * obj0 = 0 ;
29540 PyObject * obj1 = 0 ;
29541 char *kwnames[] = {
29542 (char *) "self",(char *) "data", NULL
29543 };
29544
29545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
29546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
29547 if (SWIG_arg_fail(1)) SWIG_fail;
29548 arg2 = obj1;
29549 {
29550 PyThreadState* __tstate = wxPyBeginAllowThreads();
29551 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
29552
29553 wxPyEndAllowThreads(__tstate);
29554 if (PyErr_Occurred()) SWIG_fail;
29555 }
29556 {
29557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29558 }
29559 return resultobj;
29560 fail:
29561 return NULL;
29562 }
29563
29564
29565 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
29566 PyObject *resultobj = NULL;
29567 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
29568 size_t result;
29569 PyObject * obj0 = 0 ;
29570 char *kwnames[] = {
29571 (char *) "self", NULL
29572 };
29573
29574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
29575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
29576 if (SWIG_arg_fail(1)) SWIG_fail;
29577 {
29578 PyThreadState* __tstate = wxPyBeginAllowThreads();
29579 result = (size_t)(arg1)->GetSize();
29580
29581 wxPyEndAllowThreads(__tstate);
29582 if (PyErr_Occurred()) SWIG_fail;
29583 }
29584 {
29585 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
29586 }
29587 return resultobj;
29588 fail:
29589 return NULL;
29590 }
29591
29592
29593 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29594 PyObject *resultobj = NULL;
29595 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
29596 PyObject *result;
29597 PyObject * obj0 = 0 ;
29598 char *kwnames[] = {
29599 (char *) "self", NULL
29600 };
29601
29602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
29603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
29604 if (SWIG_arg_fail(1)) SWIG_fail;
29605 {
29606 PyThreadState* __tstate = wxPyBeginAllowThreads();
29607 result = (PyObject *)wxCustomDataObject_GetData(arg1);
29608
29609 wxPyEndAllowThreads(__tstate);
29610 if (PyErr_Occurred()) SWIG_fail;
29611 }
29612 resultobj = result;
29613 return resultobj;
29614 fail:
29615 return NULL;
29616 }
29617
29618
29619 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
29620 PyObject *obj;
29621 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29622 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
29623 Py_INCREF(obj);
29624 return Py_BuildValue((char *)"");
29625 }
29626 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29627 PyObject *resultobj = NULL;
29628 wxURLDataObject *result;
29629 char *kwnames[] = {
29630 NULL
29631 };
29632
29633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
29634 {
29635 PyThreadState* __tstate = wxPyBeginAllowThreads();
29636 result = (wxURLDataObject *)new wxURLDataObject();
29637
29638 wxPyEndAllowThreads(__tstate);
29639 if (PyErr_Occurred()) SWIG_fail;
29640 }
29641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
29642 return resultobj;
29643 fail:
29644 return NULL;
29645 }
29646
29647
29648 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
29649 PyObject *resultobj = NULL;
29650 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
29651 wxString result;
29652 PyObject * obj0 = 0 ;
29653 char *kwnames[] = {
29654 (char *) "self", NULL
29655 };
29656
29657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
29658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
29659 if (SWIG_arg_fail(1)) SWIG_fail;
29660 {
29661 PyThreadState* __tstate = wxPyBeginAllowThreads();
29662 result = (arg1)->GetURL();
29663
29664 wxPyEndAllowThreads(__tstate);
29665 if (PyErr_Occurred()) SWIG_fail;
29666 }
29667 {
29668 #if wxUSE_UNICODE
29669 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29670 #else
29671 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29672 #endif
29673 }
29674 return resultobj;
29675 fail:
29676 return NULL;
29677 }
29678
29679
29680 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
29681 PyObject *resultobj = NULL;
29682 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
29683 wxString *arg2 = 0 ;
29684 bool temp2 = false ;
29685 PyObject * obj0 = 0 ;
29686 PyObject * obj1 = 0 ;
29687 char *kwnames[] = {
29688 (char *) "self",(char *) "url", NULL
29689 };
29690
29691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
29692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
29693 if (SWIG_arg_fail(1)) SWIG_fail;
29694 {
29695 arg2 = wxString_in_helper(obj1);
29696 if (arg2 == NULL) SWIG_fail;
29697 temp2 = true;
29698 }
29699 {
29700 PyThreadState* __tstate = wxPyBeginAllowThreads();
29701 (arg1)->SetURL((wxString const &)*arg2);
29702
29703 wxPyEndAllowThreads(__tstate);
29704 if (PyErr_Occurred()) SWIG_fail;
29705 }
29706 Py_INCREF(Py_None); resultobj = Py_None;
29707 {
29708 if (temp2)
29709 delete arg2;
29710 }
29711 return resultobj;
29712 fail:
29713 {
29714 if (temp2)
29715 delete arg2;
29716 }
29717 return NULL;
29718 }
29719
29720
29721 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
29722 PyObject *obj;
29723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29724 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
29725 Py_INCREF(obj);
29726 return Py_BuildValue((char *)"");
29727 }
29728 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29729 PyObject *resultobj = NULL;
29730 wxMetafileDataObject *result;
29731 char *kwnames[] = {
29732 NULL
29733 };
29734
29735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
29736 {
29737 PyThreadState* __tstate = wxPyBeginAllowThreads();
29738 result = (wxMetafileDataObject *)new wxMetafileDataObject();
29739
29740 wxPyEndAllowThreads(__tstate);
29741 if (PyErr_Occurred()) SWIG_fail;
29742 }
29743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
29744 return resultobj;
29745 fail:
29746 return NULL;
29747 }
29748
29749
29750 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
29751 PyObject *obj;
29752 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29753 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
29754 Py_INCREF(obj);
29755 return Py_BuildValue((char *)"");
29756 }
29757 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
29758 PyObject *resultobj = NULL;
29759 wxDragResult arg1 ;
29760 bool result;
29761 PyObject * obj0 = 0 ;
29762 char *kwnames[] = {
29763 (char *) "res", NULL
29764 };
29765
29766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
29767 {
29768 arg1 = static_cast<wxDragResult >(SWIG_As_int(obj0));
29769 if (SWIG_arg_fail(1)) SWIG_fail;
29770 }
29771 {
29772 PyThreadState* __tstate = wxPyBeginAllowThreads();
29773 result = (bool)wxIsDragResultOk(arg1);
29774
29775 wxPyEndAllowThreads(__tstate);
29776 if (PyErr_Occurred()) SWIG_fail;
29777 }
29778 {
29779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29780 }
29781 return resultobj;
29782 fail:
29783 return NULL;
29784 }
29785
29786
29787 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
29788 PyObject *resultobj = NULL;
29789 wxWindow *arg1 = (wxWindow *) 0 ;
29790 wxIcon const &arg2_defvalue = wxNullIcon ;
29791 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
29792 wxIcon const &arg3_defvalue = wxNullIcon ;
29793 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
29794 wxIcon const &arg4_defvalue = wxNullIcon ;
29795 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
29796 wxPyDropSource *result;
29797 PyObject * obj0 = 0 ;
29798 PyObject * obj1 = 0 ;
29799 PyObject * obj2 = 0 ;
29800 PyObject * obj3 = 0 ;
29801 char *kwnames[] = {
29802 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
29803 };
29804
29805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29807 if (SWIG_arg_fail(1)) SWIG_fail;
29808 if (obj1) {
29809 {
29810 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
29811 if (SWIG_arg_fail(2)) SWIG_fail;
29812 if (arg2 == NULL) {
29813 SWIG_null_ref("wxIcon");
29814 }
29815 if (SWIG_arg_fail(2)) SWIG_fail;
29816 }
29817 }
29818 if (obj2) {
29819 {
29820 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
29821 if (SWIG_arg_fail(3)) SWIG_fail;
29822 if (arg3 == NULL) {
29823 SWIG_null_ref("wxIcon");
29824 }
29825 if (SWIG_arg_fail(3)) SWIG_fail;
29826 }
29827 }
29828 if (obj3) {
29829 {
29830 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
29831 if (SWIG_arg_fail(4)) SWIG_fail;
29832 if (arg4 == NULL) {
29833 SWIG_null_ref("wxIcon");
29834 }
29835 if (SWIG_arg_fail(4)) SWIG_fail;
29836 }
29837 }
29838 {
29839 PyThreadState* __tstate = wxPyBeginAllowThreads();
29840 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
29841
29842 wxPyEndAllowThreads(__tstate);
29843 if (PyErr_Occurred()) SWIG_fail;
29844 }
29845 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
29846 return resultobj;
29847 fail:
29848 return NULL;
29849 }
29850
29851
29852 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29853 PyObject *resultobj = NULL;
29854 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29855 PyObject *arg2 = (PyObject *) 0 ;
29856 PyObject *arg3 = (PyObject *) 0 ;
29857 int arg4 ;
29858 PyObject * obj0 = 0 ;
29859 PyObject * obj1 = 0 ;
29860 PyObject * obj2 = 0 ;
29861 PyObject * obj3 = 0 ;
29862 char *kwnames[] = {
29863 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
29864 };
29865
29866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29868 if (SWIG_arg_fail(1)) SWIG_fail;
29869 arg2 = obj1;
29870 arg3 = obj2;
29871 {
29872 arg4 = static_cast<int >(SWIG_As_int(obj3));
29873 if (SWIG_arg_fail(4)) SWIG_fail;
29874 }
29875 {
29876 PyThreadState* __tstate = wxPyBeginAllowThreads();
29877 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
29878
29879 wxPyEndAllowThreads(__tstate);
29880 if (PyErr_Occurred()) SWIG_fail;
29881 }
29882 Py_INCREF(Py_None); resultobj = Py_None;
29883 return resultobj;
29884 fail:
29885 return NULL;
29886 }
29887
29888
29889 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
29890 PyObject *resultobj = NULL;
29891 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29892 PyObject * obj0 = 0 ;
29893 char *kwnames[] = {
29894 (char *) "self", NULL
29895 };
29896
29897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
29898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29899 if (SWIG_arg_fail(1)) SWIG_fail;
29900 {
29901 PyThreadState* __tstate = wxPyBeginAllowThreads();
29902 delete arg1;
29903
29904 wxPyEndAllowThreads(__tstate);
29905 if (PyErr_Occurred()) SWIG_fail;
29906 }
29907 Py_INCREF(Py_None); resultobj = Py_None;
29908 return resultobj;
29909 fail:
29910 return NULL;
29911 }
29912
29913
29914 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29915 PyObject *resultobj = NULL;
29916 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29917 wxDataObject *arg2 = 0 ;
29918 PyObject * obj0 = 0 ;
29919 PyObject * obj1 = 0 ;
29920 char *kwnames[] = {
29921 (char *) "self",(char *) "data", NULL
29922 };
29923
29924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29929 if (SWIG_arg_fail(2)) SWIG_fail;
29930 if (arg2 == NULL) {
29931 SWIG_null_ref("wxDataObject");
29932 }
29933 if (SWIG_arg_fail(2)) SWIG_fail;
29934 }
29935 {
29936 PyThreadState* __tstate = wxPyBeginAllowThreads();
29937 (arg1)->SetData(*arg2);
29938
29939 wxPyEndAllowThreads(__tstate);
29940 if (PyErr_Occurred()) SWIG_fail;
29941 }
29942 Py_INCREF(Py_None); resultobj = Py_None;
29943 return resultobj;
29944 fail:
29945 return NULL;
29946 }
29947
29948
29949 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
29950 PyObject *resultobj = NULL;
29951 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29952 wxDataObject *result;
29953 PyObject * obj0 = 0 ;
29954 char *kwnames[] = {
29955 (char *) "self", NULL
29956 };
29957
29958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
29959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29960 if (SWIG_arg_fail(1)) SWIG_fail;
29961 {
29962 PyThreadState* __tstate = wxPyBeginAllowThreads();
29963 result = (wxDataObject *)(arg1)->GetDataObject();
29964
29965 wxPyEndAllowThreads(__tstate);
29966 if (PyErr_Occurred()) SWIG_fail;
29967 }
29968 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
29969 return resultobj;
29970 fail:
29971 return NULL;
29972 }
29973
29974
29975 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29976 PyObject *resultobj = NULL;
29977 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
29978 wxDragResult arg2 ;
29979 wxCursor *arg3 = 0 ;
29980 PyObject * obj0 = 0 ;
29981 PyObject * obj1 = 0 ;
29982 PyObject * obj2 = 0 ;
29983 char *kwnames[] = {
29984 (char *) "self",(char *) "res",(char *) "cursor", NULL
29985 };
29986
29987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
29988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
29989 if (SWIG_arg_fail(1)) SWIG_fail;
29990 {
29991 arg2 = static_cast<wxDragResult >(SWIG_As_int(obj1));
29992 if (SWIG_arg_fail(2)) SWIG_fail;
29993 }
29994 {
29995 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29996 if (SWIG_arg_fail(3)) SWIG_fail;
29997 if (arg3 == NULL) {
29998 SWIG_null_ref("wxCursor");
29999 }
30000 if (SWIG_arg_fail(3)) SWIG_fail;
30001 }
30002 {
30003 PyThreadState* __tstate = wxPyBeginAllowThreads();
30004 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
30005
30006 wxPyEndAllowThreads(__tstate);
30007 if (PyErr_Occurred()) SWIG_fail;
30008 }
30009 Py_INCREF(Py_None); resultobj = Py_None;
30010 return resultobj;
30011 fail:
30012 return NULL;
30013 }
30014
30015
30016 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
30017 PyObject *resultobj = NULL;
30018 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
30019 int arg2 = (int) wxDrag_CopyOnly ;
30020 wxDragResult result;
30021 PyObject * obj0 = 0 ;
30022 PyObject * obj1 = 0 ;
30023 char *kwnames[] = {
30024 (char *) "self",(char *) "flags", NULL
30025 };
30026
30027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
30028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
30029 if (SWIG_arg_fail(1)) SWIG_fail;
30030 if (obj1) {
30031 {
30032 arg2 = static_cast<int >(SWIG_As_int(obj1));
30033 if (SWIG_arg_fail(2)) SWIG_fail;
30034 }
30035 }
30036 {
30037 PyThreadState* __tstate = wxPyBeginAllowThreads();
30038 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
30039
30040 wxPyEndAllowThreads(__tstate);
30041 if (PyErr_Occurred()) SWIG_fail;
30042 }
30043 resultobj = SWIG_From_int((result));
30044 return resultobj;
30045 fail:
30046 return NULL;
30047 }
30048
30049
30050 static PyObject *_wrap_DropSource_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
30051 PyObject *resultobj = NULL;
30052 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
30053 wxDragResult arg2 ;
30054 bool result;
30055 PyObject * obj0 = 0 ;
30056 PyObject * obj1 = 0 ;
30057 char *kwnames[] = {
30058 (char *) "self",(char *) "effect", NULL
30059 };
30060
30061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
30062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
30063 if (SWIG_arg_fail(1)) SWIG_fail;
30064 {
30065 arg2 = static_cast<wxDragResult >(SWIG_As_int(obj1));
30066 if (SWIG_arg_fail(2)) SWIG_fail;
30067 }
30068 {
30069 PyThreadState* __tstate = wxPyBeginAllowThreads();
30070 result = (bool)(arg1)->GiveFeedback(arg2);
30071
30072 wxPyEndAllowThreads(__tstate);
30073 if (PyErr_Occurred()) SWIG_fail;
30074 }
30075 {
30076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30077 }
30078 return resultobj;
30079 fail:
30080 return NULL;
30081 }
30082
30083
30084 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
30085 PyObject *obj;
30086 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30087 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
30088 Py_INCREF(obj);
30089 return Py_BuildValue((char *)"");
30090 }
30091 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30092 PyObject *resultobj = NULL;
30093 wxDataObject *arg1 = (wxDataObject *) NULL ;
30094 wxPyDropTarget *result;
30095 PyObject * obj0 = 0 ;
30096 char *kwnames[] = {
30097 (char *) "dataObject", NULL
30098 };
30099
30100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
30101 if (obj0) {
30102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30103 if (SWIG_arg_fail(1)) SWIG_fail;
30104 }
30105 {
30106 PyThreadState* __tstate = wxPyBeginAllowThreads();
30107 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
30108
30109 wxPyEndAllowThreads(__tstate);
30110 if (PyErr_Occurred()) SWIG_fail;
30111 }
30112 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
30113 return resultobj;
30114 fail:
30115 return NULL;
30116 }
30117
30118
30119 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
30120 PyObject *resultobj = NULL;
30121 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30122 PyObject *arg2 = (PyObject *) 0 ;
30123 PyObject *arg3 = (PyObject *) 0 ;
30124 PyObject * obj0 = 0 ;
30125 PyObject * obj1 = 0 ;
30126 PyObject * obj2 = 0 ;
30127 char *kwnames[] = {
30128 (char *) "self",(char *) "self",(char *) "_class", NULL
30129 };
30130
30131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
30132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30133 if (SWIG_arg_fail(1)) SWIG_fail;
30134 arg2 = obj1;
30135 arg3 = obj2;
30136 {
30137 PyThreadState* __tstate = wxPyBeginAllowThreads();
30138 (arg1)->_setCallbackInfo(arg2,arg3);
30139
30140 wxPyEndAllowThreads(__tstate);
30141 if (PyErr_Occurred()) SWIG_fail;
30142 }
30143 Py_INCREF(Py_None); resultobj = Py_None;
30144 return resultobj;
30145 fail:
30146 return NULL;
30147 }
30148
30149
30150 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30151 PyObject *resultobj = NULL;
30152 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30153 PyObject * obj0 = 0 ;
30154 char *kwnames[] = {
30155 (char *) "self", NULL
30156 };
30157
30158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
30159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30160 if (SWIG_arg_fail(1)) SWIG_fail;
30161 {
30162 PyThreadState* __tstate = wxPyBeginAllowThreads();
30163 delete arg1;
30164
30165 wxPyEndAllowThreads(__tstate);
30166 if (PyErr_Occurred()) SWIG_fail;
30167 }
30168 Py_INCREF(Py_None); resultobj = Py_None;
30169 return resultobj;
30170 fail:
30171 return NULL;
30172 }
30173
30174
30175 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
30176 PyObject *resultobj = NULL;
30177 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30178 wxDataObject *result;
30179 PyObject * obj0 = 0 ;
30180 char *kwnames[] = {
30181 (char *) "self", NULL
30182 };
30183
30184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
30185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30186 if (SWIG_arg_fail(1)) SWIG_fail;
30187 {
30188 PyThreadState* __tstate = wxPyBeginAllowThreads();
30189 result = (wxDataObject *)(arg1)->GetDataObject();
30190
30191 wxPyEndAllowThreads(__tstate);
30192 if (PyErr_Occurred()) SWIG_fail;
30193 }
30194 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
30195 return resultobj;
30196 fail:
30197 return NULL;
30198 }
30199
30200
30201 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
30202 PyObject *resultobj = NULL;
30203 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30204 wxDataObject *arg2 = (wxDataObject *) 0 ;
30205 PyObject * obj0 = 0 ;
30206 PyObject * obj1 = 0 ;
30207 char *kwnames[] = {
30208 (char *) "self",(char *) "dataObject", NULL
30209 };
30210
30211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
30212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30213 if (SWIG_arg_fail(1)) SWIG_fail;
30214 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30215 if (SWIG_arg_fail(2)) SWIG_fail;
30216 {
30217 PyThreadState* __tstate = wxPyBeginAllowThreads();
30218 (arg1)->SetDataObject(arg2);
30219
30220 wxPyEndAllowThreads(__tstate);
30221 if (PyErr_Occurred()) SWIG_fail;
30222 }
30223 Py_INCREF(Py_None); resultobj = Py_None;
30224 return resultobj;
30225 fail:
30226 return NULL;
30227 }
30228
30229
30230 static PyObject *_wrap_DropTarget_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
30231 PyObject *resultobj = NULL;
30232 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30233 int arg2 ;
30234 int arg3 ;
30235 wxDragResult arg4 ;
30236 wxDragResult result;
30237 PyObject * obj0 = 0 ;
30238 PyObject * obj1 = 0 ;
30239 PyObject * obj2 = 0 ;
30240 PyObject * obj3 = 0 ;
30241 char *kwnames[] = {
30242 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30243 };
30244
30245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30247 if (SWIG_arg_fail(1)) SWIG_fail;
30248 {
30249 arg2 = static_cast<int >(SWIG_As_int(obj1));
30250 if (SWIG_arg_fail(2)) SWIG_fail;
30251 }
30252 {
30253 arg3 = static_cast<int >(SWIG_As_int(obj2));
30254 if (SWIG_arg_fail(3)) SWIG_fail;
30255 }
30256 {
30257 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30258 if (SWIG_arg_fail(4)) SWIG_fail;
30259 }
30260 {
30261 PyThreadState* __tstate = wxPyBeginAllowThreads();
30262 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
30263
30264 wxPyEndAllowThreads(__tstate);
30265 if (PyErr_Occurred()) SWIG_fail;
30266 }
30267 resultobj = SWIG_From_int((result));
30268 return resultobj;
30269 fail:
30270 return NULL;
30271 }
30272
30273
30274 static PyObject *_wrap_DropTarget_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
30275 PyObject *resultobj = NULL;
30276 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30277 int arg2 ;
30278 int arg3 ;
30279 wxDragResult arg4 ;
30280 wxDragResult result;
30281 PyObject * obj0 = 0 ;
30282 PyObject * obj1 = 0 ;
30283 PyObject * obj2 = 0 ;
30284 PyObject * obj3 = 0 ;
30285 char *kwnames[] = {
30286 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30287 };
30288
30289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30291 if (SWIG_arg_fail(1)) SWIG_fail;
30292 {
30293 arg2 = static_cast<int >(SWIG_As_int(obj1));
30294 if (SWIG_arg_fail(2)) SWIG_fail;
30295 }
30296 {
30297 arg3 = static_cast<int >(SWIG_As_int(obj2));
30298 if (SWIG_arg_fail(3)) SWIG_fail;
30299 }
30300 {
30301 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30302 if (SWIG_arg_fail(4)) SWIG_fail;
30303 }
30304 {
30305 PyThreadState* __tstate = wxPyBeginAllowThreads();
30306 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
30307
30308 wxPyEndAllowThreads(__tstate);
30309 if (PyErr_Occurred()) SWIG_fail;
30310 }
30311 resultobj = SWIG_From_int((result));
30312 return resultobj;
30313 fail:
30314 return NULL;
30315 }
30316
30317
30318 static PyObject *_wrap_DropTarget_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
30319 PyObject *resultobj = NULL;
30320 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30321 PyObject * obj0 = 0 ;
30322 char *kwnames[] = {
30323 (char *) "self", NULL
30324 };
30325
30326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_OnLeave",kwnames,&obj0)) goto fail;
30327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30328 if (SWIG_arg_fail(1)) SWIG_fail;
30329 {
30330 PyThreadState* __tstate = wxPyBeginAllowThreads();
30331 (arg1)->OnLeave();
30332
30333 wxPyEndAllowThreads(__tstate);
30334 if (PyErr_Occurred()) SWIG_fail;
30335 }
30336 Py_INCREF(Py_None); resultobj = Py_None;
30337 return resultobj;
30338 fail:
30339 return NULL;
30340 }
30341
30342
30343 static PyObject *_wrap_DropTarget_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
30344 PyObject *resultobj = NULL;
30345 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30346 int arg2 ;
30347 int arg3 ;
30348 bool result;
30349 PyObject * obj0 = 0 ;
30350 PyObject * obj1 = 0 ;
30351 PyObject * obj2 = 0 ;
30352 char *kwnames[] = {
30353 (char *) "self",(char *) "x",(char *) "y", NULL
30354 };
30355
30356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
30357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30358 if (SWIG_arg_fail(1)) SWIG_fail;
30359 {
30360 arg2 = static_cast<int >(SWIG_As_int(obj1));
30361 if (SWIG_arg_fail(2)) SWIG_fail;
30362 }
30363 {
30364 arg3 = static_cast<int >(SWIG_As_int(obj2));
30365 if (SWIG_arg_fail(3)) SWIG_fail;
30366 }
30367 {
30368 PyThreadState* __tstate = wxPyBeginAllowThreads();
30369 result = (bool)(arg1)->OnDrop(arg2,arg3);
30370
30371 wxPyEndAllowThreads(__tstate);
30372 if (PyErr_Occurred()) SWIG_fail;
30373 }
30374 {
30375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30376 }
30377 return resultobj;
30378 fail:
30379 return NULL;
30380 }
30381
30382
30383 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
30384 PyObject *resultobj = NULL;
30385 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30386 bool result;
30387 PyObject * obj0 = 0 ;
30388 char *kwnames[] = {
30389 (char *) "self", NULL
30390 };
30391
30392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
30393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30394 if (SWIG_arg_fail(1)) SWIG_fail;
30395 {
30396 PyThreadState* __tstate = wxPyBeginAllowThreads();
30397 result = (bool)(arg1)->GetData();
30398
30399 wxPyEndAllowThreads(__tstate);
30400 if (PyErr_Occurred()) SWIG_fail;
30401 }
30402 {
30403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30404 }
30405 return resultobj;
30406 fail:
30407 return NULL;
30408 }
30409
30410
30411 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
30412 PyObject *resultobj = NULL;
30413 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30414 wxDragResult arg2 ;
30415 PyObject * obj0 = 0 ;
30416 PyObject * obj1 = 0 ;
30417 char *kwnames[] = {
30418 (char *) "self",(char *) "action", NULL
30419 };
30420
30421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
30422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30423 if (SWIG_arg_fail(1)) SWIG_fail;
30424 {
30425 arg2 = static_cast<wxDragResult >(SWIG_As_int(obj1));
30426 if (SWIG_arg_fail(2)) SWIG_fail;
30427 }
30428 {
30429 PyThreadState* __tstate = wxPyBeginAllowThreads();
30430 (arg1)->SetDefaultAction(arg2);
30431
30432 wxPyEndAllowThreads(__tstate);
30433 if (PyErr_Occurred()) SWIG_fail;
30434 }
30435 Py_INCREF(Py_None); resultobj = Py_None;
30436 return resultobj;
30437 fail:
30438 return NULL;
30439 }
30440
30441
30442 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
30443 PyObject *resultobj = NULL;
30444 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
30445 wxDragResult result;
30446 PyObject * obj0 = 0 ;
30447 char *kwnames[] = {
30448 (char *) "self", NULL
30449 };
30450
30451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
30452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
30453 if (SWIG_arg_fail(1)) SWIG_fail;
30454 {
30455 PyThreadState* __tstate = wxPyBeginAllowThreads();
30456 result = (wxDragResult)(arg1)->GetDefaultAction();
30457
30458 wxPyEndAllowThreads(__tstate);
30459 if (PyErr_Occurred()) SWIG_fail;
30460 }
30461 resultobj = SWIG_From_int((result));
30462 return resultobj;
30463 fail:
30464 return NULL;
30465 }
30466
30467
30468 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
30469 PyObject *obj;
30470 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30471 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
30472 Py_INCREF(obj);
30473 return Py_BuildValue((char *)"");
30474 }
30475 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30476 PyObject *resultobj = NULL;
30477 wxPyTextDropTarget *result;
30478 char *kwnames[] = {
30479 NULL
30480 };
30481
30482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
30483 {
30484 PyThreadState* __tstate = wxPyBeginAllowThreads();
30485 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
30486
30487 wxPyEndAllowThreads(__tstate);
30488 if (PyErr_Occurred()) SWIG_fail;
30489 }
30490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
30491 return resultobj;
30492 fail:
30493 return NULL;
30494 }
30495
30496
30497 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
30498 PyObject *resultobj = NULL;
30499 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30500 PyObject *arg2 = (PyObject *) 0 ;
30501 PyObject *arg3 = (PyObject *) 0 ;
30502 PyObject * obj0 = 0 ;
30503 PyObject * obj1 = 0 ;
30504 PyObject * obj2 = 0 ;
30505 char *kwnames[] = {
30506 (char *) "self",(char *) "self",(char *) "_class", NULL
30507 };
30508
30509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
30510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30511 if (SWIG_arg_fail(1)) SWIG_fail;
30512 arg2 = obj1;
30513 arg3 = obj2;
30514 {
30515 PyThreadState* __tstate = wxPyBeginAllowThreads();
30516 (arg1)->_setCallbackInfo(arg2,arg3);
30517
30518 wxPyEndAllowThreads(__tstate);
30519 if (PyErr_Occurred()) SWIG_fail;
30520 }
30521 Py_INCREF(Py_None); resultobj = Py_None;
30522 return resultobj;
30523 fail:
30524 return NULL;
30525 }
30526
30527
30528 static PyObject *_wrap_TextDropTarget_OnDropText(PyObject *, PyObject *args, PyObject *kwargs) {
30529 PyObject *resultobj = NULL;
30530 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30531 int arg2 ;
30532 int arg3 ;
30533 wxString *arg4 = 0 ;
30534 bool result;
30535 bool temp4 = false ;
30536 PyObject * obj0 = 0 ;
30537 PyObject * obj1 = 0 ;
30538 PyObject * obj2 = 0 ;
30539 PyObject * obj3 = 0 ;
30540 char *kwnames[] = {
30541 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
30542 };
30543
30544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30546 if (SWIG_arg_fail(1)) SWIG_fail;
30547 {
30548 arg2 = static_cast<int >(SWIG_As_int(obj1));
30549 if (SWIG_arg_fail(2)) SWIG_fail;
30550 }
30551 {
30552 arg3 = static_cast<int >(SWIG_As_int(obj2));
30553 if (SWIG_arg_fail(3)) SWIG_fail;
30554 }
30555 {
30556 arg4 = wxString_in_helper(obj3);
30557 if (arg4 == NULL) SWIG_fail;
30558 temp4 = true;
30559 }
30560 {
30561 PyThreadState* __tstate = wxPyBeginAllowThreads();
30562 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
30563
30564 wxPyEndAllowThreads(__tstate);
30565 if (PyErr_Occurred()) SWIG_fail;
30566 }
30567 {
30568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30569 }
30570 {
30571 if (temp4)
30572 delete arg4;
30573 }
30574 return resultobj;
30575 fail:
30576 {
30577 if (temp4)
30578 delete arg4;
30579 }
30580 return NULL;
30581 }
30582
30583
30584 static PyObject *_wrap_TextDropTarget_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
30585 PyObject *resultobj = NULL;
30586 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30587 int arg2 ;
30588 int arg3 ;
30589 wxDragResult arg4 ;
30590 wxDragResult result;
30591 PyObject * obj0 = 0 ;
30592 PyObject * obj1 = 0 ;
30593 PyObject * obj2 = 0 ;
30594 PyObject * obj3 = 0 ;
30595 char *kwnames[] = {
30596 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30597 };
30598
30599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30601 if (SWIG_arg_fail(1)) SWIG_fail;
30602 {
30603 arg2 = static_cast<int >(SWIG_As_int(obj1));
30604 if (SWIG_arg_fail(2)) SWIG_fail;
30605 }
30606 {
30607 arg3 = static_cast<int >(SWIG_As_int(obj2));
30608 if (SWIG_arg_fail(3)) SWIG_fail;
30609 }
30610 {
30611 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30612 if (SWIG_arg_fail(4)) SWIG_fail;
30613 }
30614 {
30615 PyThreadState* __tstate = wxPyBeginAllowThreads();
30616 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
30617
30618 wxPyEndAllowThreads(__tstate);
30619 if (PyErr_Occurred()) SWIG_fail;
30620 }
30621 resultobj = SWIG_From_int((result));
30622 return resultobj;
30623 fail:
30624 return NULL;
30625 }
30626
30627
30628 static PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
30629 PyObject *resultobj = NULL;
30630 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30631 int arg2 ;
30632 int arg3 ;
30633 wxDragResult arg4 ;
30634 wxDragResult result;
30635 PyObject * obj0 = 0 ;
30636 PyObject * obj1 = 0 ;
30637 PyObject * obj2 = 0 ;
30638 PyObject * obj3 = 0 ;
30639 char *kwnames[] = {
30640 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30641 };
30642
30643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30645 if (SWIG_arg_fail(1)) SWIG_fail;
30646 {
30647 arg2 = static_cast<int >(SWIG_As_int(obj1));
30648 if (SWIG_arg_fail(2)) SWIG_fail;
30649 }
30650 {
30651 arg3 = static_cast<int >(SWIG_As_int(obj2));
30652 if (SWIG_arg_fail(3)) SWIG_fail;
30653 }
30654 {
30655 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30656 if (SWIG_arg_fail(4)) SWIG_fail;
30657 }
30658 {
30659 PyThreadState* __tstate = wxPyBeginAllowThreads();
30660 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
30661
30662 wxPyEndAllowThreads(__tstate);
30663 if (PyErr_Occurred()) SWIG_fail;
30664 }
30665 resultobj = SWIG_From_int((result));
30666 return resultobj;
30667 fail:
30668 return NULL;
30669 }
30670
30671
30672 static PyObject *_wrap_TextDropTarget_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
30673 PyObject *resultobj = NULL;
30674 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30675 PyObject * obj0 = 0 ;
30676 char *kwnames[] = {
30677 (char *) "self", NULL
30678 };
30679
30680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_OnLeave",kwnames,&obj0)) goto fail;
30681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30682 if (SWIG_arg_fail(1)) SWIG_fail;
30683 {
30684 PyThreadState* __tstate = wxPyBeginAllowThreads();
30685 (arg1)->OnLeave();
30686
30687 wxPyEndAllowThreads(__tstate);
30688 if (PyErr_Occurred()) SWIG_fail;
30689 }
30690 Py_INCREF(Py_None); resultobj = Py_None;
30691 return resultobj;
30692 fail:
30693 return NULL;
30694 }
30695
30696
30697 static PyObject *_wrap_TextDropTarget_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
30698 PyObject *resultobj = NULL;
30699 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30700 int arg2 ;
30701 int arg3 ;
30702 bool result;
30703 PyObject * obj0 = 0 ;
30704 PyObject * obj1 = 0 ;
30705 PyObject * obj2 = 0 ;
30706 char *kwnames[] = {
30707 (char *) "self",(char *) "x",(char *) "y", NULL
30708 };
30709
30710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
30711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30712 if (SWIG_arg_fail(1)) SWIG_fail;
30713 {
30714 arg2 = static_cast<int >(SWIG_As_int(obj1));
30715 if (SWIG_arg_fail(2)) SWIG_fail;
30716 }
30717 {
30718 arg3 = static_cast<int >(SWIG_As_int(obj2));
30719 if (SWIG_arg_fail(3)) SWIG_fail;
30720 }
30721 {
30722 PyThreadState* __tstate = wxPyBeginAllowThreads();
30723 result = (bool)(arg1)->OnDrop(arg2,arg3);
30724
30725 wxPyEndAllowThreads(__tstate);
30726 if (PyErr_Occurred()) SWIG_fail;
30727 }
30728 {
30729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30730 }
30731 return resultobj;
30732 fail:
30733 return NULL;
30734 }
30735
30736
30737 static PyObject *_wrap_TextDropTarget_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
30738 PyObject *resultobj = NULL;
30739 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
30740 int arg2 ;
30741 int arg3 ;
30742 wxDragResult arg4 ;
30743 wxDragResult result;
30744 PyObject * obj0 = 0 ;
30745 PyObject * obj1 = 0 ;
30746 PyObject * obj2 = 0 ;
30747 PyObject * obj3 = 0 ;
30748 char *kwnames[] = {
30749 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30750 };
30751
30752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
30754 if (SWIG_arg_fail(1)) SWIG_fail;
30755 {
30756 arg2 = static_cast<int >(SWIG_As_int(obj1));
30757 if (SWIG_arg_fail(2)) SWIG_fail;
30758 }
30759 {
30760 arg3 = static_cast<int >(SWIG_As_int(obj2));
30761 if (SWIG_arg_fail(3)) SWIG_fail;
30762 }
30763 {
30764 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30765 if (SWIG_arg_fail(4)) SWIG_fail;
30766 }
30767 {
30768 PyThreadState* __tstate = wxPyBeginAllowThreads();
30769 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
30770
30771 wxPyEndAllowThreads(__tstate);
30772 if (PyErr_Occurred()) SWIG_fail;
30773 }
30774 resultobj = SWIG_From_int((result));
30775 return resultobj;
30776 fail:
30777 return NULL;
30778 }
30779
30780
30781 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
30782 PyObject *obj;
30783 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30784 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
30785 Py_INCREF(obj);
30786 return Py_BuildValue((char *)"");
30787 }
30788 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30789 PyObject *resultobj = NULL;
30790 wxPyFileDropTarget *result;
30791 char *kwnames[] = {
30792 NULL
30793 };
30794
30795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
30796 {
30797 PyThreadState* __tstate = wxPyBeginAllowThreads();
30798 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
30799
30800 wxPyEndAllowThreads(__tstate);
30801 if (PyErr_Occurred()) SWIG_fail;
30802 }
30803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
30804 return resultobj;
30805 fail:
30806 return NULL;
30807 }
30808
30809
30810 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
30811 PyObject *resultobj = NULL;
30812 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30813 PyObject *arg2 = (PyObject *) 0 ;
30814 PyObject *arg3 = (PyObject *) 0 ;
30815 PyObject * obj0 = 0 ;
30816 PyObject * obj1 = 0 ;
30817 PyObject * obj2 = 0 ;
30818 char *kwnames[] = {
30819 (char *) "self",(char *) "self",(char *) "_class", NULL
30820 };
30821
30822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
30823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30824 if (SWIG_arg_fail(1)) SWIG_fail;
30825 arg2 = obj1;
30826 arg3 = obj2;
30827 {
30828 PyThreadState* __tstate = wxPyBeginAllowThreads();
30829 (arg1)->_setCallbackInfo(arg2,arg3);
30830
30831 wxPyEndAllowThreads(__tstate);
30832 if (PyErr_Occurred()) SWIG_fail;
30833 }
30834 Py_INCREF(Py_None); resultobj = Py_None;
30835 return resultobj;
30836 fail:
30837 return NULL;
30838 }
30839
30840
30841 static PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *, PyObject *args, PyObject *kwargs) {
30842 PyObject *resultobj = NULL;
30843 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30844 int arg2 ;
30845 int arg3 ;
30846 wxArrayString *arg4 = 0 ;
30847 bool result;
30848 bool temp4 = false ;
30849 PyObject * obj0 = 0 ;
30850 PyObject * obj1 = 0 ;
30851 PyObject * obj2 = 0 ;
30852 PyObject * obj3 = 0 ;
30853 char *kwnames[] = {
30854 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
30855 };
30856
30857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30859 if (SWIG_arg_fail(1)) SWIG_fail;
30860 {
30861 arg2 = static_cast<int >(SWIG_As_int(obj1));
30862 if (SWIG_arg_fail(2)) SWIG_fail;
30863 }
30864 {
30865 arg3 = static_cast<int >(SWIG_As_int(obj2));
30866 if (SWIG_arg_fail(3)) SWIG_fail;
30867 }
30868 {
30869 if (! PySequence_Check(obj3)) {
30870 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
30871 SWIG_fail;
30872 }
30873 arg4 = new wxArrayString;
30874 temp4 = true;
30875 int i, len=PySequence_Length(obj3);
30876 for (i=0; i<len; i++) {
30877 PyObject* item = PySequence_GetItem(obj3, i);
30878 wxString* s = wxString_in_helper(item);
30879 if (PyErr_Occurred()) SWIG_fail;
30880 arg4->Add(*s);
30881 delete s;
30882 Py_DECREF(item);
30883 }
30884 }
30885 {
30886 PyThreadState* __tstate = wxPyBeginAllowThreads();
30887 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
30888
30889 wxPyEndAllowThreads(__tstate);
30890 if (PyErr_Occurred()) SWIG_fail;
30891 }
30892 {
30893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30894 }
30895 {
30896 if (temp4) delete arg4;
30897 }
30898 return resultobj;
30899 fail:
30900 {
30901 if (temp4) delete arg4;
30902 }
30903 return NULL;
30904 }
30905
30906
30907 static PyObject *_wrap_FileDropTarget_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
30908 PyObject *resultobj = NULL;
30909 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30910 int arg2 ;
30911 int arg3 ;
30912 wxDragResult arg4 ;
30913 wxDragResult result;
30914 PyObject * obj0 = 0 ;
30915 PyObject * obj1 = 0 ;
30916 PyObject * obj2 = 0 ;
30917 PyObject * obj3 = 0 ;
30918 char *kwnames[] = {
30919 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30920 };
30921
30922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30924 if (SWIG_arg_fail(1)) SWIG_fail;
30925 {
30926 arg2 = static_cast<int >(SWIG_As_int(obj1));
30927 if (SWIG_arg_fail(2)) SWIG_fail;
30928 }
30929 {
30930 arg3 = static_cast<int >(SWIG_As_int(obj2));
30931 if (SWIG_arg_fail(3)) SWIG_fail;
30932 }
30933 {
30934 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30935 if (SWIG_arg_fail(4)) SWIG_fail;
30936 }
30937 {
30938 PyThreadState* __tstate = wxPyBeginAllowThreads();
30939 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
30940
30941 wxPyEndAllowThreads(__tstate);
30942 if (PyErr_Occurred()) SWIG_fail;
30943 }
30944 resultobj = SWIG_From_int((result));
30945 return resultobj;
30946 fail:
30947 return NULL;
30948 }
30949
30950
30951 static PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
30952 PyObject *resultobj = NULL;
30953 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30954 int arg2 ;
30955 int arg3 ;
30956 wxDragResult arg4 ;
30957 wxDragResult result;
30958 PyObject * obj0 = 0 ;
30959 PyObject * obj1 = 0 ;
30960 PyObject * obj2 = 0 ;
30961 PyObject * obj3 = 0 ;
30962 char *kwnames[] = {
30963 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
30964 };
30965
30966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
30968 if (SWIG_arg_fail(1)) SWIG_fail;
30969 {
30970 arg2 = static_cast<int >(SWIG_As_int(obj1));
30971 if (SWIG_arg_fail(2)) SWIG_fail;
30972 }
30973 {
30974 arg3 = static_cast<int >(SWIG_As_int(obj2));
30975 if (SWIG_arg_fail(3)) SWIG_fail;
30976 }
30977 {
30978 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
30979 if (SWIG_arg_fail(4)) SWIG_fail;
30980 }
30981 {
30982 PyThreadState* __tstate = wxPyBeginAllowThreads();
30983 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
30984
30985 wxPyEndAllowThreads(__tstate);
30986 if (PyErr_Occurred()) SWIG_fail;
30987 }
30988 resultobj = SWIG_From_int((result));
30989 return resultobj;
30990 fail:
30991 return NULL;
30992 }
30993
30994
30995 static PyObject *_wrap_FileDropTarget_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
30996 PyObject *resultobj = NULL;
30997 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
30998 PyObject * obj0 = 0 ;
30999 char *kwnames[] = {
31000 (char *) "self", NULL
31001 };
31002
31003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_OnLeave",kwnames,&obj0)) goto fail;
31004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
31005 if (SWIG_arg_fail(1)) SWIG_fail;
31006 {
31007 PyThreadState* __tstate = wxPyBeginAllowThreads();
31008 (arg1)->OnLeave();
31009
31010 wxPyEndAllowThreads(__tstate);
31011 if (PyErr_Occurred()) SWIG_fail;
31012 }
31013 Py_INCREF(Py_None); resultobj = Py_None;
31014 return resultobj;
31015 fail:
31016 return NULL;
31017 }
31018
31019
31020 static PyObject *_wrap_FileDropTarget_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
31021 PyObject *resultobj = NULL;
31022 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
31023 int arg2 ;
31024 int arg3 ;
31025 bool result;
31026 PyObject * obj0 = 0 ;
31027 PyObject * obj1 = 0 ;
31028 PyObject * obj2 = 0 ;
31029 char *kwnames[] = {
31030 (char *) "self",(char *) "x",(char *) "y", NULL
31031 };
31032
31033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
31034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
31035 if (SWIG_arg_fail(1)) SWIG_fail;
31036 {
31037 arg2 = static_cast<int >(SWIG_As_int(obj1));
31038 if (SWIG_arg_fail(2)) SWIG_fail;
31039 }
31040 {
31041 arg3 = static_cast<int >(SWIG_As_int(obj2));
31042 if (SWIG_arg_fail(3)) SWIG_fail;
31043 }
31044 {
31045 PyThreadState* __tstate = wxPyBeginAllowThreads();
31046 result = (bool)(arg1)->OnDrop(arg2,arg3);
31047
31048 wxPyEndAllowThreads(__tstate);
31049 if (PyErr_Occurred()) SWIG_fail;
31050 }
31051 {
31052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31053 }
31054 return resultobj;
31055 fail:
31056 return NULL;
31057 }
31058
31059
31060 static PyObject *_wrap_FileDropTarget_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
31061 PyObject *resultobj = NULL;
31062 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
31063 int arg2 ;
31064 int arg3 ;
31065 wxDragResult arg4 ;
31066 wxDragResult result;
31067 PyObject * obj0 = 0 ;
31068 PyObject * obj1 = 0 ;
31069 PyObject * obj2 = 0 ;
31070 PyObject * obj3 = 0 ;
31071 char *kwnames[] = {
31072 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
31073 };
31074
31075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
31077 if (SWIG_arg_fail(1)) SWIG_fail;
31078 {
31079 arg2 = static_cast<int >(SWIG_As_int(obj1));
31080 if (SWIG_arg_fail(2)) SWIG_fail;
31081 }
31082 {
31083 arg3 = static_cast<int >(SWIG_As_int(obj2));
31084 if (SWIG_arg_fail(3)) SWIG_fail;
31085 }
31086 {
31087 arg4 = static_cast<wxDragResult >(SWIG_As_int(obj3));
31088 if (SWIG_arg_fail(4)) SWIG_fail;
31089 }
31090 {
31091 PyThreadState* __tstate = wxPyBeginAllowThreads();
31092 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
31093
31094 wxPyEndAllowThreads(__tstate);
31095 if (PyErr_Occurred()) SWIG_fail;
31096 }
31097 resultobj = SWIG_From_int((result));
31098 return resultobj;
31099 fail:
31100 return NULL;
31101 }
31102
31103
31104 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
31105 PyObject *obj;
31106 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31107 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
31108 Py_INCREF(obj);
31109 return Py_BuildValue((char *)"");
31110 }
31111 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
31112 PyObject *resultobj = NULL;
31113 wxClipboard *result;
31114 char *kwnames[] = {
31115 NULL
31116 };
31117
31118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
31119 {
31120 PyThreadState* __tstate = wxPyBeginAllowThreads();
31121 result = (wxClipboard *)new wxClipboard();
31122
31123 wxPyEndAllowThreads(__tstate);
31124 if (PyErr_Occurred()) SWIG_fail;
31125 }
31126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
31127 return resultobj;
31128 fail:
31129 return NULL;
31130 }
31131
31132
31133 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
31134 PyObject *resultobj = NULL;
31135 wxClipboard *arg1 = (wxClipboard *) 0 ;
31136 PyObject * obj0 = 0 ;
31137 char *kwnames[] = {
31138 (char *) "self", NULL
31139 };
31140
31141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
31142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31143 if (SWIG_arg_fail(1)) SWIG_fail;
31144 {
31145 PyThreadState* __tstate = wxPyBeginAllowThreads();
31146 delete arg1;
31147
31148 wxPyEndAllowThreads(__tstate);
31149 if (PyErr_Occurred()) SWIG_fail;
31150 }
31151 Py_INCREF(Py_None); resultobj = Py_None;
31152 return resultobj;
31153 fail:
31154 return NULL;
31155 }
31156
31157
31158 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
31159 PyObject *resultobj = NULL;
31160 wxClipboard *arg1 = (wxClipboard *) 0 ;
31161 bool result;
31162 PyObject * obj0 = 0 ;
31163 char *kwnames[] = {
31164 (char *) "self", NULL
31165 };
31166
31167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
31172 result = (bool)(arg1)->Open();
31173
31174 wxPyEndAllowThreads(__tstate);
31175 if (PyErr_Occurred()) SWIG_fail;
31176 }
31177 {
31178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31179 }
31180 return resultobj;
31181 fail:
31182 return NULL;
31183 }
31184
31185
31186 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
31187 PyObject *resultobj = NULL;
31188 wxClipboard *arg1 = (wxClipboard *) 0 ;
31189 PyObject * obj0 = 0 ;
31190 char *kwnames[] = {
31191 (char *) "self", NULL
31192 };
31193
31194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
31195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31196 if (SWIG_arg_fail(1)) SWIG_fail;
31197 {
31198 PyThreadState* __tstate = wxPyBeginAllowThreads();
31199 (arg1)->Close();
31200
31201 wxPyEndAllowThreads(__tstate);
31202 if (PyErr_Occurred()) SWIG_fail;
31203 }
31204 Py_INCREF(Py_None); resultobj = Py_None;
31205 return resultobj;
31206 fail:
31207 return NULL;
31208 }
31209
31210
31211 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
31212 PyObject *resultobj = NULL;
31213 wxClipboard *arg1 = (wxClipboard *) 0 ;
31214 bool result;
31215 PyObject * obj0 = 0 ;
31216 char *kwnames[] = {
31217 (char *) "self", NULL
31218 };
31219
31220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
31221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31222 if (SWIG_arg_fail(1)) SWIG_fail;
31223 {
31224 PyThreadState* __tstate = wxPyBeginAllowThreads();
31225 result = (bool)((wxClipboard const *)arg1)->IsOpened();
31226
31227 wxPyEndAllowThreads(__tstate);
31228 if (PyErr_Occurred()) SWIG_fail;
31229 }
31230 {
31231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31232 }
31233 return resultobj;
31234 fail:
31235 return NULL;
31236 }
31237
31238
31239 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
31240 PyObject *resultobj = NULL;
31241 wxClipboard *arg1 = (wxClipboard *) 0 ;
31242 wxDataObject *arg2 = (wxDataObject *) 0 ;
31243 bool result;
31244 PyObject * obj0 = 0 ;
31245 PyObject * obj1 = 0 ;
31246 char *kwnames[] = {
31247 (char *) "self",(char *) "data", NULL
31248 };
31249
31250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
31251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31252 if (SWIG_arg_fail(1)) SWIG_fail;
31253 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31254 if (SWIG_arg_fail(2)) SWIG_fail;
31255 {
31256 PyThreadState* __tstate = wxPyBeginAllowThreads();
31257 result = (bool)(arg1)->AddData(arg2);
31258
31259 wxPyEndAllowThreads(__tstate);
31260 if (PyErr_Occurred()) SWIG_fail;
31261 }
31262 {
31263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31264 }
31265 return resultobj;
31266 fail:
31267 return NULL;
31268 }
31269
31270
31271 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
31272 PyObject *resultobj = NULL;
31273 wxClipboard *arg1 = (wxClipboard *) 0 ;
31274 wxDataObject *arg2 = (wxDataObject *) 0 ;
31275 bool result;
31276 PyObject * obj0 = 0 ;
31277 PyObject * obj1 = 0 ;
31278 char *kwnames[] = {
31279 (char *) "self",(char *) "data", NULL
31280 };
31281
31282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
31283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31284 if (SWIG_arg_fail(1)) SWIG_fail;
31285 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31286 if (SWIG_arg_fail(2)) SWIG_fail;
31287 {
31288 PyThreadState* __tstate = wxPyBeginAllowThreads();
31289 result = (bool)(arg1)->SetData(arg2);
31290
31291 wxPyEndAllowThreads(__tstate);
31292 if (PyErr_Occurred()) SWIG_fail;
31293 }
31294 {
31295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31296 }
31297 return resultobj;
31298 fail:
31299 return NULL;
31300 }
31301
31302
31303 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
31304 PyObject *resultobj = NULL;
31305 wxClipboard *arg1 = (wxClipboard *) 0 ;
31306 wxDataFormat *arg2 = 0 ;
31307 bool result;
31308 PyObject * obj0 = 0 ;
31309 PyObject * obj1 = 0 ;
31310 char *kwnames[] = {
31311 (char *) "self",(char *) "format", NULL
31312 };
31313
31314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
31315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31316 if (SWIG_arg_fail(1)) SWIG_fail;
31317 {
31318 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
31319 if (SWIG_arg_fail(2)) SWIG_fail;
31320 if (arg2 == NULL) {
31321 SWIG_null_ref("wxDataFormat");
31322 }
31323 if (SWIG_arg_fail(2)) SWIG_fail;
31324 }
31325 {
31326 PyThreadState* __tstate = wxPyBeginAllowThreads();
31327 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
31328
31329 wxPyEndAllowThreads(__tstate);
31330 if (PyErr_Occurred()) SWIG_fail;
31331 }
31332 {
31333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31334 }
31335 return resultobj;
31336 fail:
31337 return NULL;
31338 }
31339
31340
31341 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
31342 PyObject *resultobj = NULL;
31343 wxClipboard *arg1 = (wxClipboard *) 0 ;
31344 wxDataObject *arg2 = 0 ;
31345 bool result;
31346 PyObject * obj0 = 0 ;
31347 PyObject * obj1 = 0 ;
31348 char *kwnames[] = {
31349 (char *) "self",(char *) "data", NULL
31350 };
31351
31352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
31353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31354 if (SWIG_arg_fail(1)) SWIG_fail;
31355 {
31356 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
31357 if (SWIG_arg_fail(2)) SWIG_fail;
31358 if (arg2 == NULL) {
31359 SWIG_null_ref("wxDataObject");
31360 }
31361 if (SWIG_arg_fail(2)) SWIG_fail;
31362 }
31363 {
31364 PyThreadState* __tstate = wxPyBeginAllowThreads();
31365 result = (bool)(arg1)->GetData(*arg2);
31366
31367 wxPyEndAllowThreads(__tstate);
31368 if (PyErr_Occurred()) SWIG_fail;
31369 }
31370 {
31371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31372 }
31373 return resultobj;
31374 fail:
31375 return NULL;
31376 }
31377
31378
31379 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
31380 PyObject *resultobj = NULL;
31381 wxClipboard *arg1 = (wxClipboard *) 0 ;
31382 PyObject * obj0 = 0 ;
31383 char *kwnames[] = {
31384 (char *) "self", NULL
31385 };
31386
31387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
31388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31389 if (SWIG_arg_fail(1)) SWIG_fail;
31390 {
31391 PyThreadState* __tstate = wxPyBeginAllowThreads();
31392 (arg1)->Clear();
31393
31394 wxPyEndAllowThreads(__tstate);
31395 if (PyErr_Occurred()) SWIG_fail;
31396 }
31397 Py_INCREF(Py_None); resultobj = Py_None;
31398 return resultobj;
31399 fail:
31400 return NULL;
31401 }
31402
31403
31404 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
31405 PyObject *resultobj = NULL;
31406 wxClipboard *arg1 = (wxClipboard *) 0 ;
31407 bool result;
31408 PyObject * obj0 = 0 ;
31409 char *kwnames[] = {
31410 (char *) "self", NULL
31411 };
31412
31413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
31414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31415 if (SWIG_arg_fail(1)) SWIG_fail;
31416 {
31417 PyThreadState* __tstate = wxPyBeginAllowThreads();
31418 result = (bool)(arg1)->Flush();
31419
31420 wxPyEndAllowThreads(__tstate);
31421 if (PyErr_Occurred()) SWIG_fail;
31422 }
31423 {
31424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31425 }
31426 return resultobj;
31427 fail:
31428 return NULL;
31429 }
31430
31431
31432 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
31433 PyObject *resultobj = NULL;
31434 wxClipboard *arg1 = (wxClipboard *) 0 ;
31435 bool arg2 = (bool) true ;
31436 PyObject * obj0 = 0 ;
31437 PyObject * obj1 = 0 ;
31438 char *kwnames[] = {
31439 (char *) "self",(char *) "primary", NULL
31440 };
31441
31442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
31443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31444 if (SWIG_arg_fail(1)) SWIG_fail;
31445 if (obj1) {
31446 {
31447 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
31448 if (SWIG_arg_fail(2)) SWIG_fail;
31449 }
31450 }
31451 {
31452 PyThreadState* __tstate = wxPyBeginAllowThreads();
31453 (arg1)->UsePrimarySelection(arg2);
31454
31455 wxPyEndAllowThreads(__tstate);
31456 if (PyErr_Occurred()) SWIG_fail;
31457 }
31458 Py_INCREF(Py_None); resultobj = Py_None;
31459 return resultobj;
31460 fail:
31461 return NULL;
31462 }
31463
31464
31465 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31466 PyObject *resultobj = NULL;
31467 wxClipboard *result;
31468 char *kwnames[] = {
31469 NULL
31470 };
31471
31472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
31473 {
31474 PyThreadState* __tstate = wxPyBeginAllowThreads();
31475 result = (wxClipboard *)wxClipboard::Get();
31476
31477 wxPyEndAllowThreads(__tstate);
31478 if (PyErr_Occurred()) SWIG_fail;
31479 }
31480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
31481 return resultobj;
31482 fail:
31483 return NULL;
31484 }
31485
31486
31487 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
31488 PyObject *obj;
31489 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31490 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
31491 Py_INCREF(obj);
31492 return Py_BuildValue((char *)"");
31493 }
31494 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
31495 PyObject *resultobj = NULL;
31496 wxClipboard *arg1 = (wxClipboard *) NULL ;
31497 wxClipboardLocker *result;
31498 PyObject * obj0 = 0 ;
31499 char *kwnames[] = {
31500 (char *) "clipboard", NULL
31501 };
31502
31503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
31504 if (obj0) {
31505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
31506 if (SWIG_arg_fail(1)) SWIG_fail;
31507 }
31508 {
31509 PyThreadState* __tstate = wxPyBeginAllowThreads();
31510 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
31511
31512 wxPyEndAllowThreads(__tstate);
31513 if (PyErr_Occurred()) SWIG_fail;
31514 }
31515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
31516 return resultobj;
31517 fail:
31518 return NULL;
31519 }
31520
31521
31522 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
31523 PyObject *resultobj = NULL;
31524 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
31525 PyObject * obj0 = 0 ;
31526 char *kwnames[] = {
31527 (char *) "self", NULL
31528 };
31529
31530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
31531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
31532 if (SWIG_arg_fail(1)) SWIG_fail;
31533 {
31534 PyThreadState* __tstate = wxPyBeginAllowThreads();
31535 delete arg1;
31536
31537 wxPyEndAllowThreads(__tstate);
31538 if (PyErr_Occurred()) SWIG_fail;
31539 }
31540 Py_INCREF(Py_None); resultobj = Py_None;
31541 return resultobj;
31542 fail:
31543 return NULL;
31544 }
31545
31546
31547 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
31548 PyObject *resultobj = NULL;
31549 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
31550 bool result;
31551 PyObject * obj0 = 0 ;
31552 char *kwnames[] = {
31553 (char *) "self", NULL
31554 };
31555
31556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
31557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
31558 if (SWIG_arg_fail(1)) SWIG_fail;
31559 {
31560 PyThreadState* __tstate = wxPyBeginAllowThreads();
31561 result = (bool)wxClipboardLocker___nonzero__(arg1);
31562
31563 wxPyEndAllowThreads(__tstate);
31564 if (PyErr_Occurred()) SWIG_fail;
31565 }
31566 {
31567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31568 }
31569 return resultobj;
31570 fail:
31571 return NULL;
31572 }
31573
31574
31575 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
31576 PyObject *obj;
31577 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31578 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
31579 Py_INCREF(obj);
31580 return Py_BuildValue((char *)"");
31581 }
31582 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
31583 PyObject *resultobj = NULL;
31584 int arg1 = (int) 0 ;
31585 int arg2 = (int) 0 ;
31586 int arg3 = (int) 0 ;
31587 int arg4 = (int) 0 ;
31588 wxVideoMode *result;
31589 PyObject * obj0 = 0 ;
31590 PyObject * obj1 = 0 ;
31591 PyObject * obj2 = 0 ;
31592 PyObject * obj3 = 0 ;
31593 char *kwnames[] = {
31594 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
31595 };
31596
31597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31598 if (obj0) {
31599 {
31600 arg1 = static_cast<int >(SWIG_As_int(obj0));
31601 if (SWIG_arg_fail(1)) SWIG_fail;
31602 }
31603 }
31604 if (obj1) {
31605 {
31606 arg2 = static_cast<int >(SWIG_As_int(obj1));
31607 if (SWIG_arg_fail(2)) SWIG_fail;
31608 }
31609 }
31610 if (obj2) {
31611 {
31612 arg3 = static_cast<int >(SWIG_As_int(obj2));
31613 if (SWIG_arg_fail(3)) SWIG_fail;
31614 }
31615 }
31616 if (obj3) {
31617 {
31618 arg4 = static_cast<int >(SWIG_As_int(obj3));
31619 if (SWIG_arg_fail(4)) SWIG_fail;
31620 }
31621 }
31622 {
31623 PyThreadState* __tstate = wxPyBeginAllowThreads();
31624 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
31625
31626 wxPyEndAllowThreads(__tstate);
31627 if (PyErr_Occurred()) SWIG_fail;
31628 }
31629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
31630 return resultobj;
31631 fail:
31632 return NULL;
31633 }
31634
31635
31636 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
31637 PyObject *resultobj = NULL;
31638 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31639 PyObject * obj0 = 0 ;
31640 char *kwnames[] = {
31641 (char *) "self", NULL
31642 };
31643
31644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
31645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31646 if (SWIG_arg_fail(1)) SWIG_fail;
31647 {
31648 PyThreadState* __tstate = wxPyBeginAllowThreads();
31649 delete arg1;
31650
31651 wxPyEndAllowThreads(__tstate);
31652 if (PyErr_Occurred()) SWIG_fail;
31653 }
31654 Py_INCREF(Py_None); resultobj = Py_None;
31655 return resultobj;
31656 fail:
31657 return NULL;
31658 }
31659
31660
31661 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
31662 PyObject *resultobj = NULL;
31663 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31664 wxVideoMode *arg2 = 0 ;
31665 bool result;
31666 PyObject * obj0 = 0 ;
31667 PyObject * obj1 = 0 ;
31668 char *kwnames[] = {
31669 (char *) "self",(char *) "other", NULL
31670 };
31671
31672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
31673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31674 if (SWIG_arg_fail(1)) SWIG_fail;
31675 {
31676 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31677 if (SWIG_arg_fail(2)) SWIG_fail;
31678 if (arg2 == NULL) {
31679 SWIG_null_ref("wxVideoMode");
31680 }
31681 if (SWIG_arg_fail(2)) SWIG_fail;
31682 }
31683 {
31684 PyThreadState* __tstate = wxPyBeginAllowThreads();
31685 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
31686
31687 wxPyEndAllowThreads(__tstate);
31688 if (PyErr_Occurred()) SWIG_fail;
31689 }
31690 {
31691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31692 }
31693 return resultobj;
31694 fail:
31695 return NULL;
31696 }
31697
31698
31699 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
31700 PyObject *resultobj = NULL;
31701 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31702 int result;
31703 PyObject * obj0 = 0 ;
31704 char *kwnames[] = {
31705 (char *) "self", NULL
31706 };
31707
31708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
31709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31710 if (SWIG_arg_fail(1)) SWIG_fail;
31711 {
31712 PyThreadState* __tstate = wxPyBeginAllowThreads();
31713 result = (int)((wxVideoMode const *)arg1)->GetWidth();
31714
31715 wxPyEndAllowThreads(__tstate);
31716 if (PyErr_Occurred()) SWIG_fail;
31717 }
31718 {
31719 resultobj = SWIG_From_int(static_cast<int >(result));
31720 }
31721 return resultobj;
31722 fail:
31723 return NULL;
31724 }
31725
31726
31727 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
31728 PyObject *resultobj = NULL;
31729 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31730 int result;
31731 PyObject * obj0 = 0 ;
31732 char *kwnames[] = {
31733 (char *) "self", NULL
31734 };
31735
31736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
31737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31738 if (SWIG_arg_fail(1)) SWIG_fail;
31739 {
31740 PyThreadState* __tstate = wxPyBeginAllowThreads();
31741 result = (int)((wxVideoMode const *)arg1)->GetHeight();
31742
31743 wxPyEndAllowThreads(__tstate);
31744 if (PyErr_Occurred()) SWIG_fail;
31745 }
31746 {
31747 resultobj = SWIG_From_int(static_cast<int >(result));
31748 }
31749 return resultobj;
31750 fail:
31751 return NULL;
31752 }
31753
31754
31755 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
31756 PyObject *resultobj = NULL;
31757 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31758 int result;
31759 PyObject * obj0 = 0 ;
31760 char *kwnames[] = {
31761 (char *) "self", NULL
31762 };
31763
31764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
31765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31766 if (SWIG_arg_fail(1)) SWIG_fail;
31767 {
31768 PyThreadState* __tstate = wxPyBeginAllowThreads();
31769 result = (int)((wxVideoMode const *)arg1)->GetDepth();
31770
31771 wxPyEndAllowThreads(__tstate);
31772 if (PyErr_Occurred()) SWIG_fail;
31773 }
31774 {
31775 resultobj = SWIG_From_int(static_cast<int >(result));
31776 }
31777 return resultobj;
31778 fail:
31779 return NULL;
31780 }
31781
31782
31783 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
31784 PyObject *resultobj = NULL;
31785 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31786 bool result;
31787 PyObject * obj0 = 0 ;
31788 char *kwnames[] = {
31789 (char *) "self", NULL
31790 };
31791
31792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
31793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31794 if (SWIG_arg_fail(1)) SWIG_fail;
31795 {
31796 PyThreadState* __tstate = wxPyBeginAllowThreads();
31797 result = (bool)((wxVideoMode const *)arg1)->IsOk();
31798
31799 wxPyEndAllowThreads(__tstate);
31800 if (PyErr_Occurred()) SWIG_fail;
31801 }
31802 {
31803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31804 }
31805 return resultobj;
31806 fail:
31807 return NULL;
31808 }
31809
31810
31811 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
31812 PyObject *resultobj = NULL;
31813 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31814 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
31815 bool result;
31816 PyObject * obj0 = 0 ;
31817 PyObject * obj1 = 0 ;
31818 char *kwnames[] = {
31819 (char *) "self",(char *) "other", NULL
31820 };
31821
31822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
31823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31824 if (SWIG_arg_fail(1)) SWIG_fail;
31825 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31826 if (SWIG_arg_fail(2)) SWIG_fail;
31827 {
31828 PyThreadState* __tstate = wxPyBeginAllowThreads();
31829 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
31830
31831 wxPyEndAllowThreads(__tstate);
31832 if (PyErr_Occurred()) SWIG_fail;
31833 }
31834 {
31835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31836 }
31837 return resultobj;
31838 fail:
31839 return NULL;
31840 }
31841
31842
31843 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
31844 PyObject *resultobj = NULL;
31845 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31846 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
31847 bool result;
31848 PyObject * obj0 = 0 ;
31849 PyObject * obj1 = 0 ;
31850 char *kwnames[] = {
31851 (char *) "self",(char *) "other", NULL
31852 };
31853
31854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
31855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31856 if (SWIG_arg_fail(1)) SWIG_fail;
31857 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31858 if (SWIG_arg_fail(2)) SWIG_fail;
31859 {
31860 PyThreadState* __tstate = wxPyBeginAllowThreads();
31861 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
31862
31863 wxPyEndAllowThreads(__tstate);
31864 if (PyErr_Occurred()) SWIG_fail;
31865 }
31866 {
31867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31868 }
31869 return resultobj;
31870 fail:
31871 return NULL;
31872 }
31873
31874
31875 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
31876 PyObject *resultobj = NULL;
31877 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31878 int arg2 ;
31879 PyObject * obj0 = 0 ;
31880 PyObject * obj1 = 0 ;
31881 char *kwnames[] = {
31882 (char *) "self",(char *) "w", NULL
31883 };
31884
31885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
31886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31887 if (SWIG_arg_fail(1)) SWIG_fail;
31888 {
31889 arg2 = static_cast<int >(SWIG_As_int(obj1));
31890 if (SWIG_arg_fail(2)) SWIG_fail;
31891 }
31892 if (arg1) (arg1)->w = arg2;
31893
31894 Py_INCREF(Py_None); resultobj = Py_None;
31895 return resultobj;
31896 fail:
31897 return NULL;
31898 }
31899
31900
31901 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
31902 PyObject *resultobj = NULL;
31903 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31904 int result;
31905 PyObject * obj0 = 0 ;
31906 char *kwnames[] = {
31907 (char *) "self", NULL
31908 };
31909
31910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
31911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31912 if (SWIG_arg_fail(1)) SWIG_fail;
31913 result = (int) ((arg1)->w);
31914
31915 {
31916 resultobj = SWIG_From_int(static_cast<int >(result));
31917 }
31918 return resultobj;
31919 fail:
31920 return NULL;
31921 }
31922
31923
31924 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
31925 PyObject *resultobj = NULL;
31926 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31927 int arg2 ;
31928 PyObject * obj0 = 0 ;
31929 PyObject * obj1 = 0 ;
31930 char *kwnames[] = {
31931 (char *) "self",(char *) "h", NULL
31932 };
31933
31934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
31935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31936 if (SWIG_arg_fail(1)) SWIG_fail;
31937 {
31938 arg2 = static_cast<int >(SWIG_As_int(obj1));
31939 if (SWIG_arg_fail(2)) SWIG_fail;
31940 }
31941 if (arg1) (arg1)->h = arg2;
31942
31943 Py_INCREF(Py_None); resultobj = Py_None;
31944 return resultobj;
31945 fail:
31946 return NULL;
31947 }
31948
31949
31950 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
31951 PyObject *resultobj = NULL;
31952 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31953 int result;
31954 PyObject * obj0 = 0 ;
31955 char *kwnames[] = {
31956 (char *) "self", NULL
31957 };
31958
31959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
31960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31961 if (SWIG_arg_fail(1)) SWIG_fail;
31962 result = (int) ((arg1)->h);
31963
31964 {
31965 resultobj = SWIG_From_int(static_cast<int >(result));
31966 }
31967 return resultobj;
31968 fail:
31969 return NULL;
31970 }
31971
31972
31973 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
31974 PyObject *resultobj = NULL;
31975 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
31976 int arg2 ;
31977 PyObject * obj0 = 0 ;
31978 PyObject * obj1 = 0 ;
31979 char *kwnames[] = {
31980 (char *) "self",(char *) "bpp", NULL
31981 };
31982
31983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
31984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31985 if (SWIG_arg_fail(1)) SWIG_fail;
31986 {
31987 arg2 = static_cast<int >(SWIG_As_int(obj1));
31988 if (SWIG_arg_fail(2)) SWIG_fail;
31989 }
31990 if (arg1) (arg1)->bpp = arg2;
31991
31992 Py_INCREF(Py_None); resultobj = Py_None;
31993 return resultobj;
31994 fail:
31995 return NULL;
31996 }
31997
31998
31999 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
32000 PyObject *resultobj = NULL;
32001 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
32002 int result;
32003 PyObject * obj0 = 0 ;
32004 char *kwnames[] = {
32005 (char *) "self", NULL
32006 };
32007
32008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
32009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
32010 if (SWIG_arg_fail(1)) SWIG_fail;
32011 result = (int) ((arg1)->bpp);
32012
32013 {
32014 resultobj = SWIG_From_int(static_cast<int >(result));
32015 }
32016 return resultobj;
32017 fail:
32018 return NULL;
32019 }
32020
32021
32022 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
32023 PyObject *resultobj = NULL;
32024 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
32025 int arg2 ;
32026 PyObject * obj0 = 0 ;
32027 PyObject * obj1 = 0 ;
32028 char *kwnames[] = {
32029 (char *) "self",(char *) "refresh", NULL
32030 };
32031
32032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
32033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
32034 if (SWIG_arg_fail(1)) SWIG_fail;
32035 {
32036 arg2 = static_cast<int >(SWIG_As_int(obj1));
32037 if (SWIG_arg_fail(2)) SWIG_fail;
32038 }
32039 if (arg1) (arg1)->refresh = arg2;
32040
32041 Py_INCREF(Py_None); resultobj = Py_None;
32042 return resultobj;
32043 fail:
32044 return NULL;
32045 }
32046
32047
32048 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
32049 PyObject *resultobj = NULL;
32050 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
32051 int result;
32052 PyObject * obj0 = 0 ;
32053 char *kwnames[] = {
32054 (char *) "self", NULL
32055 };
32056
32057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
32058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
32059 if (SWIG_arg_fail(1)) SWIG_fail;
32060 result = (int) ((arg1)->refresh);
32061
32062 {
32063 resultobj = SWIG_From_int(static_cast<int >(result));
32064 }
32065 return resultobj;
32066 fail:
32067 return NULL;
32068 }
32069
32070
32071 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
32072 PyObject *obj;
32073 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32074 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
32075 Py_INCREF(obj);
32076 return Py_BuildValue((char *)"");
32077 }
32078 static int _wrap_DefaultVideoMode_set(PyObject *) {
32079 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
32080 return 1;
32081 }
32082
32083
32084 static PyObject *_wrap_DefaultVideoMode_get(void) {
32085 PyObject *pyobj = NULL;
32086
32087 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
32088 return pyobj;
32089 }
32090
32091
32092 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
32093 PyObject *resultobj = NULL;
32094 size_t arg1 = (size_t) 0 ;
32095 wxDisplay *result;
32096 PyObject * obj0 = 0 ;
32097 char *kwnames[] = {
32098 (char *) "index", NULL
32099 };
32100
32101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
32102 if (obj0) {
32103 {
32104 arg1 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj0));
32105 if (SWIG_arg_fail(1)) SWIG_fail;
32106 }
32107 }
32108 {
32109 PyThreadState* __tstate = wxPyBeginAllowThreads();
32110 result = (wxDisplay *)new wxDisplay(arg1);
32111
32112 wxPyEndAllowThreads(__tstate);
32113 if (PyErr_Occurred()) SWIG_fail;
32114 }
32115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
32116 return resultobj;
32117 fail:
32118 return NULL;
32119 }
32120
32121
32122 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
32123 PyObject *resultobj = NULL;
32124 wxDisplay *arg1 = (wxDisplay *) 0 ;
32125 PyObject * obj0 = 0 ;
32126 char *kwnames[] = {
32127 (char *) "self", NULL
32128 };
32129
32130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
32131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32132 if (SWIG_arg_fail(1)) SWIG_fail;
32133 {
32134 PyThreadState* __tstate = wxPyBeginAllowThreads();
32135 delete arg1;
32136
32137 wxPyEndAllowThreads(__tstate);
32138 if (PyErr_Occurred()) SWIG_fail;
32139 }
32140 Py_INCREF(Py_None); resultobj = Py_None;
32141 return resultobj;
32142 fail:
32143 return NULL;
32144 }
32145
32146
32147 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
32148 PyObject *resultobj = NULL;
32149 size_t result;
32150 char *kwnames[] = {
32151 NULL
32152 };
32153
32154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
32155 {
32156 PyThreadState* __tstate = wxPyBeginAllowThreads();
32157 result = (size_t)wxDisplay::GetCount();
32158
32159 wxPyEndAllowThreads(__tstate);
32160 if (PyErr_Occurred()) SWIG_fail;
32161 }
32162 {
32163 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
32164 }
32165 return resultobj;
32166 fail:
32167 return NULL;
32168 }
32169
32170
32171 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
32172 PyObject *resultobj = NULL;
32173 wxPoint *arg1 = 0 ;
32174 int result;
32175 wxPoint temp1 ;
32176 PyObject * obj0 = 0 ;
32177 char *kwnames[] = {
32178 (char *) "pt", NULL
32179 };
32180
32181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
32182 {
32183 arg1 = &temp1;
32184 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
32185 }
32186 {
32187 PyThreadState* __tstate = wxPyBeginAllowThreads();
32188 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
32189
32190 wxPyEndAllowThreads(__tstate);
32191 if (PyErr_Occurred()) SWIG_fail;
32192 }
32193 {
32194 resultobj = SWIG_From_int(static_cast<int >(result));
32195 }
32196 return resultobj;
32197 fail:
32198 return NULL;
32199 }
32200
32201
32202 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32203 PyObject *resultobj = NULL;
32204 wxWindow *arg1 = (wxWindow *) 0 ;
32205 int result;
32206 PyObject * obj0 = 0 ;
32207 char *kwnames[] = {
32208 (char *) "window", NULL
32209 };
32210
32211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
32212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32213 if (SWIG_arg_fail(1)) SWIG_fail;
32214 {
32215 PyThreadState* __tstate = wxPyBeginAllowThreads();
32216 result = (int)wxDisplay::GetFromWindow(arg1);
32217
32218 wxPyEndAllowThreads(__tstate);
32219 if (PyErr_Occurred()) SWIG_fail;
32220 }
32221 {
32222 resultobj = SWIG_From_int(static_cast<int >(result));
32223 }
32224 return resultobj;
32225 fail:
32226 return NULL;
32227 }
32228
32229
32230 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
32231 PyObject *resultobj = NULL;
32232 wxDisplay *arg1 = (wxDisplay *) 0 ;
32233 bool result;
32234 PyObject * obj0 = 0 ;
32235 char *kwnames[] = {
32236 (char *) "self", NULL
32237 };
32238
32239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
32240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32241 if (SWIG_arg_fail(1)) SWIG_fail;
32242 {
32243 PyThreadState* __tstate = wxPyBeginAllowThreads();
32244 result = (bool)((wxDisplay const *)arg1)->IsOk();
32245
32246 wxPyEndAllowThreads(__tstate);
32247 if (PyErr_Occurred()) SWIG_fail;
32248 }
32249 {
32250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32251 }
32252 return resultobj;
32253 fail:
32254 return NULL;
32255 }
32256
32257
32258 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
32259 PyObject *resultobj = NULL;
32260 wxDisplay *arg1 = (wxDisplay *) 0 ;
32261 wxRect result;
32262 PyObject * obj0 = 0 ;
32263 char *kwnames[] = {
32264 (char *) "self", NULL
32265 };
32266
32267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
32268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32269 if (SWIG_arg_fail(1)) SWIG_fail;
32270 {
32271 PyThreadState* __tstate = wxPyBeginAllowThreads();
32272 result = ((wxDisplay const *)arg1)->GetGeometry();
32273
32274 wxPyEndAllowThreads(__tstate);
32275 if (PyErr_Occurred()) SWIG_fail;
32276 }
32277 {
32278 wxRect * resultptr;
32279 resultptr = new wxRect(static_cast<wxRect & >(result));
32280 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
32281 }
32282 return resultobj;
32283 fail:
32284 return NULL;
32285 }
32286
32287
32288 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
32289 PyObject *resultobj = NULL;
32290 wxDisplay *arg1 = (wxDisplay *) 0 ;
32291 wxString result;
32292 PyObject * obj0 = 0 ;
32293 char *kwnames[] = {
32294 (char *) "self", NULL
32295 };
32296
32297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
32298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32299 if (SWIG_arg_fail(1)) SWIG_fail;
32300 {
32301 PyThreadState* __tstate = wxPyBeginAllowThreads();
32302 result = ((wxDisplay const *)arg1)->GetName();
32303
32304 wxPyEndAllowThreads(__tstate);
32305 if (PyErr_Occurred()) SWIG_fail;
32306 }
32307 {
32308 #if wxUSE_UNICODE
32309 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32310 #else
32311 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32312 #endif
32313 }
32314 return resultobj;
32315 fail:
32316 return NULL;
32317 }
32318
32319
32320 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
32321 PyObject *resultobj = NULL;
32322 wxDisplay *arg1 = (wxDisplay *) 0 ;
32323 bool result;
32324 PyObject * obj0 = 0 ;
32325 char *kwnames[] = {
32326 (char *) "self", NULL
32327 };
32328
32329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
32330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32331 if (SWIG_arg_fail(1)) SWIG_fail;
32332 {
32333 PyThreadState* __tstate = wxPyBeginAllowThreads();
32334 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
32335
32336 wxPyEndAllowThreads(__tstate);
32337 if (PyErr_Occurred()) SWIG_fail;
32338 }
32339 {
32340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32341 }
32342 return resultobj;
32343 fail:
32344 return NULL;
32345 }
32346
32347
32348 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
32349 PyObject *resultobj = NULL;
32350 wxDisplay *arg1 = (wxDisplay *) 0 ;
32351 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
32352 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
32353 PyObject *result;
32354 PyObject * obj0 = 0 ;
32355 PyObject * obj1 = 0 ;
32356 char *kwnames[] = {
32357 (char *) "self",(char *) "mode", NULL
32358 };
32359
32360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
32361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32362 if (SWIG_arg_fail(1)) SWIG_fail;
32363 if (obj1) {
32364 {
32365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
32366 if (SWIG_arg_fail(2)) SWIG_fail;
32367 if (arg2 == NULL) {
32368 SWIG_null_ref("wxVideoMode");
32369 }
32370 if (SWIG_arg_fail(2)) SWIG_fail;
32371 }
32372 }
32373 {
32374 PyThreadState* __tstate = wxPyBeginAllowThreads();
32375 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
32376
32377 wxPyEndAllowThreads(__tstate);
32378 if (PyErr_Occurred()) SWIG_fail;
32379 }
32380 resultobj = result;
32381 return resultobj;
32382 fail:
32383 return NULL;
32384 }
32385
32386
32387 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
32388 PyObject *resultobj = NULL;
32389 wxDisplay *arg1 = (wxDisplay *) 0 ;
32390 wxVideoMode result;
32391 PyObject * obj0 = 0 ;
32392 char *kwnames[] = {
32393 (char *) "self", NULL
32394 };
32395
32396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
32397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32398 if (SWIG_arg_fail(1)) SWIG_fail;
32399 {
32400 PyThreadState* __tstate = wxPyBeginAllowThreads();
32401 result = ((wxDisplay const *)arg1)->GetCurrentMode();
32402
32403 wxPyEndAllowThreads(__tstate);
32404 if (PyErr_Occurred()) SWIG_fail;
32405 }
32406 {
32407 wxVideoMode * resultptr;
32408 resultptr = new wxVideoMode(static_cast<wxVideoMode & >(result));
32409 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
32410 }
32411 return resultobj;
32412 fail:
32413 return NULL;
32414 }
32415
32416
32417 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
32418 PyObject *resultobj = NULL;
32419 wxDisplay *arg1 = (wxDisplay *) 0 ;
32420 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
32421 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
32422 bool result;
32423 PyObject * obj0 = 0 ;
32424 PyObject * obj1 = 0 ;
32425 char *kwnames[] = {
32426 (char *) "self",(char *) "mode", NULL
32427 };
32428
32429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
32430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32431 if (SWIG_arg_fail(1)) SWIG_fail;
32432 if (obj1) {
32433 {
32434 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
32435 if (SWIG_arg_fail(2)) SWIG_fail;
32436 if (arg2 == NULL) {
32437 SWIG_null_ref("wxVideoMode");
32438 }
32439 if (SWIG_arg_fail(2)) SWIG_fail;
32440 }
32441 }
32442 {
32443 PyThreadState* __tstate = wxPyBeginAllowThreads();
32444 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
32445
32446 wxPyEndAllowThreads(__tstate);
32447 if (PyErr_Occurred()) SWIG_fail;
32448 }
32449 {
32450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32451 }
32452 return resultobj;
32453 fail:
32454 return NULL;
32455 }
32456
32457
32458 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
32459 PyObject *resultobj = NULL;
32460 wxDisplay *arg1 = (wxDisplay *) 0 ;
32461 PyObject * obj0 = 0 ;
32462 char *kwnames[] = {
32463 (char *) "self", NULL
32464 };
32465
32466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
32467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
32468 if (SWIG_arg_fail(1)) SWIG_fail;
32469 {
32470 PyThreadState* __tstate = wxPyBeginAllowThreads();
32471 (arg1)->ResetMode();
32472
32473 wxPyEndAllowThreads(__tstate);
32474 if (PyErr_Occurred()) SWIG_fail;
32475 }
32476 Py_INCREF(Py_None); resultobj = Py_None;
32477 return resultobj;
32478 fail:
32479 return NULL;
32480 }
32481
32482
32483 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
32484 PyObject *obj;
32485 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32486 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
32487 Py_INCREF(obj);
32488 return Py_BuildValue((char *)"");
32489 }
32490 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
32491 PyObject *resultobj = NULL;
32492 wxStandardPaths *result;
32493 char *kwnames[] = {
32494 NULL
32495 };
32496
32497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
32498 {
32499 PyThreadState* __tstate = wxPyBeginAllowThreads();
32500 result = (wxStandardPaths *)wxStandardPaths_Get();
32501
32502 wxPyEndAllowThreads(__tstate);
32503 if (PyErr_Occurred()) SWIG_fail;
32504 }
32505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
32506 return resultobj;
32507 fail:
32508 return NULL;
32509 }
32510
32511
32512 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
32513 PyObject *resultobj = NULL;
32514 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32515 wxString result;
32516 PyObject * obj0 = 0 ;
32517 char *kwnames[] = {
32518 (char *) "self", NULL
32519 };
32520
32521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
32522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32523 if (SWIG_arg_fail(1)) SWIG_fail;
32524 {
32525 PyThreadState* __tstate = wxPyBeginAllowThreads();
32526 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
32527
32528 wxPyEndAllowThreads(__tstate);
32529 if (PyErr_Occurred()) SWIG_fail;
32530 }
32531 {
32532 #if wxUSE_UNICODE
32533 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32534 #else
32535 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32536 #endif
32537 }
32538 return resultobj;
32539 fail:
32540 return NULL;
32541 }
32542
32543
32544 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
32545 PyObject *resultobj = NULL;
32546 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32547 wxString result;
32548 PyObject * obj0 = 0 ;
32549 char *kwnames[] = {
32550 (char *) "self", NULL
32551 };
32552
32553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
32554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32555 if (SWIG_arg_fail(1)) SWIG_fail;
32556 {
32557 PyThreadState* __tstate = wxPyBeginAllowThreads();
32558 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
32559
32560 wxPyEndAllowThreads(__tstate);
32561 if (PyErr_Occurred()) SWIG_fail;
32562 }
32563 {
32564 #if wxUSE_UNICODE
32565 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32566 #else
32567 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32568 #endif
32569 }
32570 return resultobj;
32571 fail:
32572 return NULL;
32573 }
32574
32575
32576 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
32577 PyObject *resultobj = NULL;
32578 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32579 wxString result;
32580 PyObject * obj0 = 0 ;
32581 char *kwnames[] = {
32582 (char *) "self", NULL
32583 };
32584
32585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
32586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32587 if (SWIG_arg_fail(1)) SWIG_fail;
32588 {
32589 PyThreadState* __tstate = wxPyBeginAllowThreads();
32590 result = ((wxStandardPaths const *)arg1)->GetDataDir();
32591
32592 wxPyEndAllowThreads(__tstate);
32593 if (PyErr_Occurred()) SWIG_fail;
32594 }
32595 {
32596 #if wxUSE_UNICODE
32597 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32598 #else
32599 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32600 #endif
32601 }
32602 return resultobj;
32603 fail:
32604 return NULL;
32605 }
32606
32607
32608 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
32609 PyObject *resultobj = NULL;
32610 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32611 wxString result;
32612 PyObject * obj0 = 0 ;
32613 char *kwnames[] = {
32614 (char *) "self", NULL
32615 };
32616
32617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
32618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32619 if (SWIG_arg_fail(1)) SWIG_fail;
32620 {
32621 PyThreadState* __tstate = wxPyBeginAllowThreads();
32622 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
32623
32624 wxPyEndAllowThreads(__tstate);
32625 if (PyErr_Occurred()) SWIG_fail;
32626 }
32627 {
32628 #if wxUSE_UNICODE
32629 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32630 #else
32631 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32632 #endif
32633 }
32634 return resultobj;
32635 fail:
32636 return NULL;
32637 }
32638
32639
32640 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
32641 PyObject *resultobj = NULL;
32642 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32643 wxString result;
32644 PyObject * obj0 = 0 ;
32645 char *kwnames[] = {
32646 (char *) "self", NULL
32647 };
32648
32649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
32650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32651 if (SWIG_arg_fail(1)) SWIG_fail;
32652 {
32653 PyThreadState* __tstate = wxPyBeginAllowThreads();
32654 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
32655
32656 wxPyEndAllowThreads(__tstate);
32657 if (PyErr_Occurred()) SWIG_fail;
32658 }
32659 {
32660 #if wxUSE_UNICODE
32661 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32662 #else
32663 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32664 #endif
32665 }
32666 return resultobj;
32667 fail:
32668 return NULL;
32669 }
32670
32671
32672 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
32673 PyObject *resultobj = NULL;
32674 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32675 wxString result;
32676 PyObject * obj0 = 0 ;
32677 char *kwnames[] = {
32678 (char *) "self", NULL
32679 };
32680
32681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
32682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32683 if (SWIG_arg_fail(1)) SWIG_fail;
32684 {
32685 PyThreadState* __tstate = wxPyBeginAllowThreads();
32686 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
32687
32688 wxPyEndAllowThreads(__tstate);
32689 if (PyErr_Occurred()) SWIG_fail;
32690 }
32691 {
32692 #if wxUSE_UNICODE
32693 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32694 #else
32695 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32696 #endif
32697 }
32698 return resultobj;
32699 fail:
32700 return NULL;
32701 }
32702
32703
32704 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
32705 PyObject *resultobj = NULL;
32706 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32707 wxString result;
32708 PyObject * obj0 = 0 ;
32709 char *kwnames[] = {
32710 (char *) "self", NULL
32711 };
32712
32713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
32714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32715 if (SWIG_arg_fail(1)) SWIG_fail;
32716 {
32717 PyThreadState* __tstate = wxPyBeginAllowThreads();
32718 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
32719
32720 wxPyEndAllowThreads(__tstate);
32721 if (PyErr_Occurred()) SWIG_fail;
32722 }
32723 {
32724 #if wxUSE_UNICODE
32725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32726 #else
32727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32728 #endif
32729 }
32730 return resultobj;
32731 fail:
32732 return NULL;
32733 }
32734
32735
32736 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
32737 PyObject *resultobj = NULL;
32738 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32739 wxString *arg2 = 0 ;
32740 bool temp2 = false ;
32741 PyObject * obj0 = 0 ;
32742 PyObject * obj1 = 0 ;
32743 char *kwnames[] = {
32744 (char *) "self",(char *) "prefix", NULL
32745 };
32746
32747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
32748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32749 if (SWIG_arg_fail(1)) SWIG_fail;
32750 {
32751 arg2 = wxString_in_helper(obj1);
32752 if (arg2 == NULL) SWIG_fail;
32753 temp2 = true;
32754 }
32755 {
32756 PyThreadState* __tstate = wxPyBeginAllowThreads();
32757 (arg1)->SetInstallPrefix((wxString const &)*arg2);
32758
32759 wxPyEndAllowThreads(__tstate);
32760 if (PyErr_Occurred()) SWIG_fail;
32761 }
32762 Py_INCREF(Py_None); resultobj = Py_None;
32763 {
32764 if (temp2)
32765 delete arg2;
32766 }
32767 return resultobj;
32768 fail:
32769 {
32770 if (temp2)
32771 delete arg2;
32772 }
32773 return NULL;
32774 }
32775
32776
32777 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
32778 PyObject *resultobj = NULL;
32779 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
32780 wxString result;
32781 PyObject * obj0 = 0 ;
32782 char *kwnames[] = {
32783 (char *) "self", NULL
32784 };
32785
32786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
32787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
32788 if (SWIG_arg_fail(1)) SWIG_fail;
32789 {
32790 PyThreadState* __tstate = wxPyBeginAllowThreads();
32791 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
32792
32793 wxPyEndAllowThreads(__tstate);
32794 if (PyErr_Occurred()) SWIG_fail;
32795 }
32796 {
32797 #if wxUSE_UNICODE
32798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32799 #else
32800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32801 #endif
32802 }
32803 return resultobj;
32804 fail:
32805 return NULL;
32806 }
32807
32808
32809 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
32810 PyObject *obj;
32811 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32812 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
32813 Py_INCREF(obj);
32814 return Py_BuildValue((char *)"");
32815 }
32816 static PyMethodDef SwigMethods[] = {
32817 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
32818 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
32819 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
32820 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
32821 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
32822 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
32823 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
32824 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
32825 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
32826 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
32827 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
32828 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
32829 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
32830 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
32831 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
32832 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
32833 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
32834 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
32835 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
32836 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
32837 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
32838 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
32839 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32840 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
32841 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
32842 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
32843 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
32844 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
32845 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
32846 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
32847 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
32848 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
32849 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
32850 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
32851 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
32852 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
32853 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
32854 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
32855 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
32856 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
32857 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
32858 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
32859 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
32860 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
32861 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
32862 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
32863 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
32864 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
32865 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
32866 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
32867 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
32868 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
32869 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
32870 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
32871 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
32872 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
32873 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32874 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32875 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
32876 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
32877 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
32878 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
32879 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
32880 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
32881 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32882 { (char *)"GetXDisplay", (PyCFunction) _wrap_GetXDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
32883 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32884 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
32885 { (char *)"FindWindowAtPointer", (PyCFunction) _wrap_FindWindowAtPointer, METH_VARARGS | METH_KEYWORDS, NULL},
32886 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32887 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32888 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32889 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
32890 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
32891 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
32892 { (char *)"new_MouseState", (PyCFunction) _wrap_new_MouseState, METH_VARARGS | METH_KEYWORDS, NULL},
32893 { (char *)"delete_MouseState", (PyCFunction) _wrap_delete_MouseState, METH_VARARGS | METH_KEYWORDS, NULL},
32894 { (char *)"MouseState_GetX", (PyCFunction) _wrap_MouseState_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
32895 { (char *)"MouseState_GetY", (PyCFunction) _wrap_MouseState_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
32896 { (char *)"MouseState_LeftDown", (PyCFunction) _wrap_MouseState_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
32897 { (char *)"MouseState_MiddleDown", (PyCFunction) _wrap_MouseState_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
32898 { (char *)"MouseState_RightDown", (PyCFunction) _wrap_MouseState_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
32899 { (char *)"MouseState_ControlDown", (PyCFunction) _wrap_MouseState_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
32900 { (char *)"MouseState_ShiftDown", (PyCFunction) _wrap_MouseState_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
32901 { (char *)"MouseState_AltDown", (PyCFunction) _wrap_MouseState_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
32902 { (char *)"MouseState_MetaDown", (PyCFunction) _wrap_MouseState_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
32903 { (char *)"MouseState_CmdDown", (PyCFunction) _wrap_MouseState_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
32904 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
32905 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
32906 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
32907 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
32908 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
32909 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
32910 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
32911 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
32912 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
32913 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
32914 { (char *)"GetMouseState", (PyCFunction) _wrap_GetMouseState, METH_VARARGS | METH_KEYWORDS, NULL},
32915 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
32916 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32917 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32918 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32919 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32920 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
32921 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
32922 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
32923 { (char *)"delete_ToolTip", (PyCFunction) _wrap_delete_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
32924 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
32925 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
32926 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32927 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
32928 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
32929 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
32930 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
32931 { (char *)"delete_Caret", (PyCFunction) _wrap_delete_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
32932 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
32933 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32934 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
32935 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
32936 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
32937 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32938 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
32939 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32940 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
32941 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
32942 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
32943 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32944 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
32945 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
32946 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
32947 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
32948 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
32949 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32950 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32951 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
32952 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
32953 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
32954 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
32955 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32956 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32957 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
32958 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
32959 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
32960 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
32961 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
32962 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
32963 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
32964 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
32965 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
32966 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
32967 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
32968 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
32969 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
32970 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
32971 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
32972 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
32973 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
32974 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
32975 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
32976 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32977 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
32978 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
32979 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
32980 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
32981 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
32982 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
32983 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
32984 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
32985 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32986 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
32987 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
32988 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
32989 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
32990 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32991 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32992 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
32993 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
32994 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
32995 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
32996 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
32997 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32998 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
32999 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
33000 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
33001 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
33002 { (char *)"Timer_Notify", (PyCFunction) _wrap_Timer_Notify, METH_VARARGS | METH_KEYWORDS, NULL},
33003 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
33004 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
33005 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
33006 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
33007 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
33008 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
33009 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
33010 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
33011 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
33012 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
33013 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
33014 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
33015 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
33016 { (char *)"delete_Log", (PyCFunction) _wrap_delete_Log, METH_VARARGS | METH_KEYWORDS, NULL},
33017 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
33018 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
33019 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
33020 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
33021 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
33022 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33023 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33024 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
33025 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
33026 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
33027 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
33028 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
33029 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
33030 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
33031 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
33032 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
33033 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
33034 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
33035 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
33036 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
33037 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
33038 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
33039 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
33040 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
33041 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
33042 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
33043 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
33044 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
33045 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
33046 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
33047 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
33048 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
33049 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
33050 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
33051 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
33052 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
33053 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
33054 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
33055 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
33056 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
33057 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
33058 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
33059 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
33060 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
33061 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
33062 { (char *)"new_LogBuffer", (PyCFunction) _wrap_new_LogBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
33063 { (char *)"LogBuffer_GetBuffer", (PyCFunction) _wrap_LogBuffer_GetBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
33064 { (char *)"LogBuffer_Flush", (PyCFunction) _wrap_LogBuffer_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
33065 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
33066 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
33067 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
33068 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
33069 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
33070 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
33071 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
33072 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33073 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
33074 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
33075 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
33076 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
33077 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
33078 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
33079 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
33080 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
33081 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
33082 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
33083 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
33084 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
33085 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33086 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
33087 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
33088 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
33089 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
33090 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
33091 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33092 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
33093 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
33094 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
33095 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
33096 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
33097 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
33098 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
33099 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
33100 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
33101 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
33102 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
33103 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
33104 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
33105 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
33106 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
33107 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
33108 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
33109 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
33110 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
33111 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
33112 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
33113 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
33114 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
33115 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
33116 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33117 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33118 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
33119 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33120 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33121 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33122 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33123 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33124 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
33125 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
33126 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
33127 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
33128 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
33129 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
33130 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
33131 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
33132 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
33133 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
33134 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
33135 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
33136 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
33137 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
33138 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
33139 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
33140 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
33141 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
33142 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
33143 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
33144 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
33145 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
33146 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
33147 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
33148 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
33149 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
33150 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
33151 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
33152 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
33153 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
33154 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
33155 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
33156 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
33157 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
33158 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
33159 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
33160 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33161 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33162 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
33163 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
33164 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
33165 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
33166 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
33167 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
33168 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33169 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
33170 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
33171 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
33172 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
33173 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
33174 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
33175 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
33176 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
33177 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
33178 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
33179 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
33180 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
33181 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
33182 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
33183 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
33184 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
33185 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
33186 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
33187 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33188 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
33189 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33190 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
33191 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
33192 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
33193 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
33194 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33195 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33196 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
33197 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
33198 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
33199 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
33200 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
33201 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
33202 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
33203 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
33204 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
33205 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
33206 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
33207 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
33208 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
33209 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33210 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
33211 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33212 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33213 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
33214 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33215 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
33216 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
33217 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
33218 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
33219 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
33220 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
33221 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
33222 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
33223 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
33224 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
33225 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
33226 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
33227 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
33228 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
33229 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
33230 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
33231 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
33232 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
33233 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33234 { (char *)"delete_ArtProvider", (PyCFunction) _wrap_delete_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33235 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33236 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33237 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33238 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
33239 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
33240 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
33241 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
33242 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
33243 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
33244 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
33245 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
33246 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
33247 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
33248 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
33249 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
33250 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
33251 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33252 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33253 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33254 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33255 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
33256 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
33257 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33258 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33259 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
33260 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
33261 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
33262 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
33263 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
33264 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
33265 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
33266 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
33267 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
33268 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
33269 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
33270 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33271 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33272 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
33273 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
33274 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
33275 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
33276 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
33277 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
33278 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
33279 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
33280 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
33281 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
33282 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
33283 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
33284 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
33285 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
33286 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
33287 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
33288 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
33289 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
33290 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
33291 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
33292 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
33293 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
33294 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
33295 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
33296 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
33297 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
33298 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
33299 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
33300 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
33301 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
33302 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
33303 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33304 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
33305 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
33306 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
33307 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33308 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
33309 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
33310 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
33311 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
33312 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
33313 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
33314 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
33315 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
33316 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
33317 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
33318 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
33319 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
33320 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
33321 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
33322 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
33323 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
33324 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
33325 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
33326 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
33327 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
33328 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
33329 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
33330 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33331 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
33332 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
33333 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
33334 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
33335 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
33336 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
33337 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
33338 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33339 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33340 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33341 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33342 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33343 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33344 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33345 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
33346 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
33347 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
33348 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
33349 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
33350 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
33351 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
33352 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
33353 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
33354 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
33355 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
33356 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
33357 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
33358 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
33359 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
33360 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
33361 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
33362 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
33363 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
33364 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
33365 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
33366 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
33367 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
33368 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
33369 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
33370 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
33371 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33372 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
33373 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
33374 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
33375 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
33376 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
33377 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
33378 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
33379 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
33380 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
33381 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
33382 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
33383 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
33384 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
33385 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
33386 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
33387 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
33388 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
33389 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
33390 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
33391 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
33392 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
33393 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
33394 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
33395 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
33396 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
33397 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
33398 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
33399 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
33400 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
33401 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
33402 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
33403 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
33404 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33405 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
33406 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33407 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
33408 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
33409 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
33410 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
33411 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
33412 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
33413 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
33414 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
33415 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
33416 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
33417 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
33418 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
33419 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
33420 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
33421 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
33422 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
33423 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
33424 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
33425 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
33426 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
33427 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
33428 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
33429 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
33430 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
33431 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
33432 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
33433 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
33434 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
33435 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
33436 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
33437 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
33438 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
33439 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
33440 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
33441 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
33442 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
33443 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
33444 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
33445 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
33446 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33447 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
33448 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
33449 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
33450 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
33451 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
33452 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
33453 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
33454 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
33455 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
33456 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
33457 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
33458 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
33459 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
33460 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
33461 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
33462 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
33463 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
33464 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
33465 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
33466 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
33467 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
33468 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
33469 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
33470 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
33471 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
33472 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
33473 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
33474 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
33475 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
33476 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
33477 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
33478 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
33479 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
33480 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
33481 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
33482 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
33483 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
33484 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
33485 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
33486 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
33487 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
33488 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
33489 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
33490 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
33491 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
33492 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
33493 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33494 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
33495 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
33496 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
33497 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
33498 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
33499 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33500 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33501 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33502 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
33503 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
33504 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
33505 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
33506 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
33507 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
33508 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
33509 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33510 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33511 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
33512 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
33513 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
33514 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
33515 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
33516 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33517 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
33518 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
33519 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33520 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
33521 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
33522 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
33523 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33524 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
33525 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
33526 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33527 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
33528 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
33529 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
33530 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
33531 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33532 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
33533 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
33534 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
33535 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
33536 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33537 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33538 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
33539 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33540 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
33541 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
33542 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
33543 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33544 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33545 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
33546 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33547 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
33548 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
33549 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
33550 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
33551 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33552 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
33553 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
33554 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
33555 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33556 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
33557 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
33558 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
33559 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33560 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
33561 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
33562 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
33563 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33564 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
33565 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33566 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33567 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
33568 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
33569 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
33570 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
33571 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33572 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33573 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33574 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33575 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
33576 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
33577 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
33578 { (char *)"DropTarget_OnLeave", (PyCFunction) _wrap_DropTarget_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
33579 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
33580 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
33581 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
33582 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
33583 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
33584 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33585 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33586 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
33587 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
33588 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
33589 { (char *)"TextDropTarget_OnLeave", (PyCFunction) _wrap_TextDropTarget_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
33590 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
33591 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
33592 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
33593 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
33594 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
33595 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
33596 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
33597 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
33598 { (char *)"FileDropTarget_OnLeave", (PyCFunction) _wrap_FileDropTarget_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
33599 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
33600 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
33601 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
33602 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
33603 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
33604 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
33605 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
33606 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
33607 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
33608 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
33609 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
33610 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
33611 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
33612 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
33613 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
33614 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
33615 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
33616 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
33617 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
33618 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
33619 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
33620 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
33621 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
33622 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
33623 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
33624 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
33625 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
33626 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
33627 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
33628 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
33629 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
33630 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
33631 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
33632 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
33633 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
33634 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
33635 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
33636 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
33637 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
33638 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
33639 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
33640 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
33641 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
33642 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
33643 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
33644 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
33645 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
33646 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
33647 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
33648 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
33649 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
33650 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
33651 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
33652 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
33653 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
33654 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
33655 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
33656 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
33657 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
33658 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
33659 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
33660 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
33661 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
33662 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
33663 { NULL, NULL, 0, NULL }
33664 };
33665
33666
33667 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
33668
33669 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
33670 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
33671 }
33672 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
33673 return (void *)((wxEvent *) ((wxMenuEvent *) x));
33674 }
33675 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
33676 return (void *)((wxEvent *) ((wxCloseEvent *) x));
33677 }
33678 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
33679 return (void *)((wxEvent *) ((wxMouseEvent *) x));
33680 }
33681 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
33682 return (void *)((wxEvent *) ((wxEraseEvent *) x));
33683 }
33684 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
33685 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
33686 }
33687 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
33688 return (void *)((wxEvent *) ((wxTimerEvent *) x));
33689 }
33690 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
33691 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
33692 }
33693 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
33694 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
33695 }
33696 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
33697 return (void *)((wxEvent *) ((wxPyEvent *) x));
33698 }
33699 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
33700 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
33701 }
33702 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
33703 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
33704 }
33705 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
33706 return (void *)((wxEvent *) ((wxIdleEvent *) x));
33707 }
33708 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
33709 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
33710 }
33711 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
33712 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
33713 }
33714 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
33715 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
33716 }
33717 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
33718 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
33719 }
33720 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
33721 return (void *)((wxEvent *) ((wxActivateEvent *) x));
33722 }
33723 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
33724 return (void *)((wxEvent *) ((wxSizeEvent *) x));
33725 }
33726 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
33727 return (void *)((wxEvent *) ((wxMoveEvent *) x));
33728 }
33729 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
33730 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
33731 }
33732 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
33733 return (void *)((wxEvent *) ((wxPaintEvent *) x));
33734 }
33735 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
33736 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
33737 }
33738 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
33739 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
33740 }
33741 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
33742 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
33743 }
33744 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
33745 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
33746 }
33747 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
33748 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
33749 }
33750 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
33751 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
33752 }
33753 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
33754 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
33755 }
33756 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
33757 return (void *)((wxEvent *) ((wxFocusEvent *) x));
33758 }
33759 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
33760 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
33761 }
33762 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
33763 return (void *)((wxEvent *) ((wxProcessEvent *) x));
33764 }
33765 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
33766 return (void *)((wxEvent *) ((wxShowEvent *) x));
33767 }
33768 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
33769 return (void *)((wxEvent *) ((wxCommandEvent *) x));
33770 }
33771 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
33772 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
33773 }
33774 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
33775 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
33776 }
33777 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
33778 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
33779 }
33780 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
33781 return (void *)((wxEvent *) ((wxKeyEvent *) x));
33782 }
33783 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
33784 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
33785 }
33786 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
33787 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
33788 }
33789 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
33790 return (void *)((wxConfigBase *) ((wxConfig *) x));
33791 }
33792 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
33793 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
33794 }
33795 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
33796 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
33797 }
33798 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
33799 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
33800 }
33801 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
33802 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
33803 }
33804 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
33805 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
33806 }
33807 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
33808 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
33809 }
33810 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
33811 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
33812 }
33813 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
33814 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
33815 }
33816 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
33817 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
33818 }
33819 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
33820 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
33821 }
33822 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
33823 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
33824 }
33825 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
33826 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
33827 }
33828 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
33829 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
33830 }
33831 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
33832 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
33833 }
33834 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
33835 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
33836 }
33837 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
33838 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
33839 }
33840 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
33841 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
33842 }
33843 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
33844 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
33845 }
33846 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
33847 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
33848 }
33849 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
33850 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
33851 }
33852 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
33853 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
33854 }
33855 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
33856 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
33857 }
33858 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
33859 return (void *)((wxEvtHandler *) ((wxWindow *) x));
33860 }
33861 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
33862 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
33863 }
33864 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
33865 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
33866 }
33867 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
33868 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
33869 }
33870 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
33871 return (void *)((wxEvtHandler *) ((wxValidator *) x));
33872 }
33873 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
33874 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
33875 }
33876 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
33877 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
33878 }
33879 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
33880 return (void *)((wxEvtHandler *) ((wxMenu *) x));
33881 }
33882 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
33883 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
33884 }
33885 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
33886 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
33887 }
33888 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
33889 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
33890 }
33891 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
33892 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
33893 }
33894 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
33895 return (void *)((wxObject *) ((wxSizerItem *) x));
33896 }
33897 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
33898 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
33899 }
33900 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
33901 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
33902 }
33903 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
33904 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
33905 }
33906 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
33907 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
33908 }
33909 static void *_p_wxSizerTo_p_wxObject(void *x) {
33910 return (void *)((wxObject *) ((wxSizer *) x));
33911 }
33912 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
33913 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
33914 }
33915 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
33916 return (void *)((wxObject *) ((wxFileHistory *) x));
33917 }
33918 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
33919 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
33920 }
33921 static void *_p_wxEventTo_p_wxObject(void *x) {
33922 return (void *)((wxObject *) ((wxEvent *) x));
33923 }
33924 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
33925 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
33926 }
33927 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
33928 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
33929 }
33930 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
33931 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
33932 }
33933 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
33934 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
33935 }
33936 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
33937 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
33938 }
33939 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
33940 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
33941 }
33942 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
33943 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
33944 }
33945 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
33946 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
33947 }
33948 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
33949 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
33950 }
33951 static void *_p_wxControlTo_p_wxObject(void *x) {
33952 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
33953 }
33954 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
33955 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
33956 }
33957 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
33958 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
33959 }
33960 static void *_p_wxFSFileTo_p_wxObject(void *x) {
33961 return (void *)((wxObject *) ((wxFSFile *) x));
33962 }
33963 static void *_p_wxClipboardTo_p_wxObject(void *x) {
33964 return (void *)((wxObject *) ((wxClipboard *) x));
33965 }
33966 static void *_p_wxPySizerTo_p_wxObject(void *x) {
33967 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
33968 }
33969 static void *_p_wxPyEventTo_p_wxObject(void *x) {
33970 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
33971 }
33972 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
33973 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
33974 }
33975 static void *_p_wxShowEventTo_p_wxObject(void *x) {
33976 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
33977 }
33978 static void *_p_wxToolTipTo_p_wxObject(void *x) {
33979 return (void *)((wxObject *) ((wxToolTip *) x));
33980 }
33981 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
33982 return (void *)((wxObject *) ((wxMenuItem *) x));
33983 }
33984 static void *_p_wxDateEventTo_p_wxObject(void *x) {
33985 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
33986 }
33987 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
33988 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
33989 }
33990 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
33991 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
33992 }
33993 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
33994 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
33995 }
33996 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
33997 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
33998 }
33999 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
34000 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
34001 }
34002 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
34003 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
34004 }
34005 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
34006 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
34007 }
34008 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
34009 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
34010 }
34011 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
34012 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
34013 }
34014 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
34015 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
34016 }
34017 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
34018 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
34019 }
34020 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
34021 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
34022 }
34023 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
34024 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
34025 }
34026 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
34027 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
34028 }
34029 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
34030 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
34031 }
34032 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
34033 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
34034 }
34035 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
34036 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
34037 }
34038 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
34039 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
34040 }
34041 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
34042 return (void *)((wxObject *) ((wxImageHandler *) x));
34043 }
34044 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
34045 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
34046 }
34047 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
34048 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
34049 }
34050 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
34051 return (void *)((wxObject *) ((wxEvtHandler *) x));
34052 }
34053 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
34054 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
34055 }
34056 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
34057 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
34058 }
34059 static void *_p_wxImageTo_p_wxObject(void *x) {
34060 return (void *)((wxObject *) ((wxImage *) x));
34061 }
34062 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
34063 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
34064 }
34065 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
34066 return (void *)((wxObject *) ((wxSystemOptions *) x));
34067 }
34068 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
34069 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
34070 }
34071 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
34072 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
34073 }
34074 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
34075 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
34076 }
34077 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
34078 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
34079 }
34080 static void *_p_wxWindowTo_p_wxObject(void *x) {
34081 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
34082 }
34083 static void *_p_wxMenuTo_p_wxObject(void *x) {
34084 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
34085 }
34086 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
34087 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
34088 }
34089 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
34090 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
34091 }
34092 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
34093 return (void *)((wxObject *) ((wxFileSystem *) x));
34094 }
34095 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
34096 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
34097 }
34098 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
34099 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
34100 }
34101 static void *_p_wxPyAppTo_p_wxObject(void *x) {
34102 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
34103 }
34104 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
34105 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
34106 }
34107 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
34108 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
34109 }
34110 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
34111 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
34112 }
34113 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
34114 return (void *)((wxObject *) ((wxBusyInfo *) x));
34115 }
34116 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
34117 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
34118 }
34119 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
34120 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
34121 }
34122 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
34123 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
34124 }
34125 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
34126 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
34127 }
34128 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
34129 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
34130 }
34131 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
34132 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
34133 }
34134 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
34135 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
34136 }
34137 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
34138 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
34139 }
34140 static void *_p_wxValidatorTo_p_wxObject(void *x) {
34141 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
34142 }
34143 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
34144 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
34145 }
34146 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
34147 return (void *)((wxLog *) ((wxLogBuffer *) x));
34148 }
34149 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
34150 return (void *)((wxLog *) ((wxLogStderr *) x));
34151 }
34152 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
34153 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
34154 }
34155 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
34156 return (void *)((wxLog *) ((wxLogWindow *) x));
34157 }
34158 static void *_p_wxLogChainTo_p_wxLog(void *x) {
34159 return (void *)((wxLog *) ((wxLogChain *) x));
34160 }
34161 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
34162 return (void *)((wxLog *) ((wxLogGui *) x));
34163 }
34164 static void *_p_wxPyLogTo_p_wxLog(void *x) {
34165 return (void *)((wxLog *) ((wxPyLog *) x));
34166 }
34167 static void *_p_wxControlTo_p_wxWindow(void *x) {
34168 return (void *)((wxWindow *) ((wxControl *) x));
34169 }
34170 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
34171 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
34172 }
34173 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
34174 return (void *)((wxWindow *) ((wxMenuBar *) x));
34175 }
34176 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
34177 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
34178 }
34179 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
34180 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
34181 }
34182 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
34183 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, 0};
34184 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
34185 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, 0};
34186 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, 0};
34187 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, 0};
34188 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, 0};
34189 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, 0};
34190 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, 0};
34191 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, 0};
34192 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, 0};
34193 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, 0};
34194 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, 0};
34195 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, 0};
34196 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, 0};
34197 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, 0};
34198 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, 0};
34199 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, 0};
34200 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, 0};
34201 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, 0};
34202 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, 0};
34203 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, 0};
34204 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, 0};
34205 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, 0};
34206 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, 0};
34207 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, 0};
34208 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, 0};
34209 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, 0};
34210 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, 0};
34211 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, 0};
34212 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, 0};
34213 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0};
34214 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, 0};
34215 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0};
34216 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0};
34217 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0};
34218 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0};
34219 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0};
34220 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0};
34221 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0};
34222 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0};
34223 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0};
34224 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0};
34225 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0};
34226 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0};
34227 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0};
34228 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0};
34229 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0};
34230 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0};
34231 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0};
34232 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0};
34233 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0};
34234 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0};
34235 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0};
34236 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0};
34237 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0};
34238 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0};
34239 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0};
34240 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0};
34241 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0};
34242 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0};
34243 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0};
34244 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0};
34245 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0};
34246 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0};
34247 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0};
34248 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0};
34249 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0};
34250 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0};
34251 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, 0};
34252 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0};
34253 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0};
34254 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0};
34255 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0};
34256 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0};
34257 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0};
34258 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, 0};
34259 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, 0};
34260 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, 0};
34261 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, 0};
34262 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, 0};
34263 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, 0};
34264 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, 0};
34265 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, 0};
34266 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, 0};
34267 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, 0};
34268 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, 0};
34269 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, 0};
34270 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, 0};
34271 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, 0};
34272 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, 0};
34273 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, 0};
34274 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, 0};
34275 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, 0};
34276 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, 0};
34277 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, 0};
34278 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, 0};
34279 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, 0};
34280 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, 0};
34281 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, 0};
34282 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, 0};
34283 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, 0};
34284 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0};
34285 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0};
34286 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0};
34287 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0};
34288 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0};
34289 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0};
34290 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0};
34291 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0};
34292 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0};
34293 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0};
34294 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0};
34295 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0};
34296 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0};
34297 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0};
34298 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0};
34299 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0};
34300 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0};
34301 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0};
34302 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0};
34303 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0};
34304 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0};
34305 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0};
34306 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0};
34307 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0};
34308 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0};
34309 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0};
34310 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0};
34311 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0};
34312 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0};
34313 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0};
34314 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, 0};
34315 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, 0};
34316 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, 0};
34317 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, 0};
34318 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, 0};
34319 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, 0};
34320 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, 0};
34321 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, 0};
34322 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, 0};
34323 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, 0};
34324 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, 0};
34325 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, 0};
34326 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, 0};
34327 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, 0};
34328 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, 0};
34329 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, 0};
34330 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, 0};
34331 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, 0};
34332 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, 0};
34333 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, 0};
34334 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, 0};
34335 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, 0};
34336 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, 0};
34337 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, 0};
34338 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, 0};
34339 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, 0};
34340 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, 0};
34341 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, 0};
34342 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, 0};
34343 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, 0};
34344 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, 0};
34345 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, 0};
34346 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, 0};
34347 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, 0};
34348 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, 0};
34349 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, 0};
34350 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, 0};
34351 static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
34352 static swig_type_info _swigt__std__ptrdiff_t = {"_std__ptrdiff_t", "std::ptrdiff_t", 0, 0, 0};
34353 static swig_type_info _swigt__unsigned_int = {"_unsigned_int", "unsigned int|std::size_t", 0, 0, 0};
34354
34355 static swig_type_info *swig_type_initial[] = {
34356 &_swigt__p_char,
34357 &_swigt__p_form_ops_t,
34358 &_swigt__p_int,
34359 &_swigt__p_unsigned_char,
34360 &_swigt__p_unsigned_int,
34361 &_swigt__p_unsigned_long,
34362 &_swigt__p_void,
34363 &_swigt__p_wxANIHandler,
34364 &_swigt__p_wxAcceleratorTable,
34365 &_swigt__p_wxActivateEvent,
34366 &_swigt__p_wxArrayString,
34367 &_swigt__p_wxBMPHandler,
34368 &_swigt__p_wxBitmap,
34369 &_swigt__p_wxBitmapDataObject,
34370 &_swigt__p_wxBoxSizer,
34371 &_swigt__p_wxBusyCursor,
34372 &_swigt__p_wxBusyInfo,
34373 &_swigt__p_wxCURHandler,
34374 &_swigt__p_wxCaret,
34375 &_swigt__p_wxChar,
34376 &_swigt__p_wxChildFocusEvent,
34377 &_swigt__p_wxClipboard,
34378 &_swigt__p_wxClipboardLocker,
34379 &_swigt__p_wxCloseEvent,
34380 &_swigt__p_wxColour,
34381 &_swigt__p_wxCommandEvent,
34382 &_swigt__p_wxConfig,
34383 &_swigt__p_wxConfigBase,
34384 &_swigt__p_wxConfigPathChanger,
34385 &_swigt__p_wxContextMenuEvent,
34386 &_swigt__p_wxControl,
34387 &_swigt__p_wxControlWithItems,
34388 &_swigt__p_wxCursor,
34389 &_swigt__p_wxCustomDataObject,
34390 &_swigt__p_wxDC,
34391 &_swigt__p_wxDataFormat,
34392 &_swigt__p_wxDataObject,
34393 &_swigt__p_wxDataObjectComposite,
34394 &_swigt__p_wxDataObjectSimple,
34395 &_swigt__p_wxDateEvent,
34396 &_swigt__p_wxDateSpan,
34397 &_swigt__p_wxDateTime,
34398 &_swigt__p_wxDateTime__TimeZone,
34399 &_swigt__p_wxDisplay,
34400 &_swigt__p_wxDisplayChangedEvent,
34401 &_swigt__p_wxDropFilesEvent,
34402 &_swigt__p_wxDuplexMode,
34403 &_swigt__p_wxEraseEvent,
34404 &_swigt__p_wxEvent,
34405 &_swigt__p_wxEvtHandler,
34406 &_swigt__p_wxFSFile,
34407 &_swigt__p_wxFileConfig,
34408 &_swigt__p_wxFileDataObject,
34409 &_swigt__p_wxFileHistory,
34410 &_swigt__p_wxFileSystem,
34411 &_swigt__p_wxFileType,
34412 &_swigt__p_wxFileTypeInfo,
34413 &_swigt__p_wxFlexGridSizer,
34414 &_swigt__p_wxFocusEvent,
34415 &_swigt__p_wxFont,
34416 &_swigt__p_wxFrame,
34417 &_swigt__p_wxGBSizerItem,
34418 &_swigt__p_wxGIFHandler,
34419 &_swigt__p_wxGridBagSizer,
34420 &_swigt__p_wxGridSizer,
34421 &_swigt__p_wxICOHandler,
34422 &_swigt__p_wxIcon,
34423 &_swigt__p_wxIconizeEvent,
34424 &_swigt__p_wxIdleEvent,
34425 &_swigt__p_wxImage,
34426 &_swigt__p_wxImageHandler,
34427 &_swigt__p_wxIndividualLayoutConstraint,
34428 &_swigt__p_wxInitDialogEvent,
34429 &_swigt__p_wxJPEGHandler,
34430 &_swigt__p_wxJoystick,
34431 &_swigt__p_wxJoystickEvent,
34432 &_swigt__p_wxKeyEvent,
34433 &_swigt__p_wxKillError,
34434 &_swigt__p_wxLayoutConstraints,
34435 &_swigt__p_wxLog,
34436 &_swigt__p_wxLogBuffer,
34437 &_swigt__p_wxLogChain,
34438 &_swigt__p_wxLogGui,
34439 &_swigt__p_wxLogNull,
34440 &_swigt__p_wxLogStderr,
34441 &_swigt__p_wxLogTextCtrl,
34442 &_swigt__p_wxLogWindow,
34443 &_swigt__p_wxMaximizeEvent,
34444 &_swigt__p_wxMemorySize,
34445 &_swigt__p_wxMenu,
34446 &_swigt__p_wxMenuBar,
34447 &_swigt__p_wxMenuEvent,
34448 &_swigt__p_wxMenuItem,
34449 &_swigt__p_wxMetafileDataObject,
34450 &_swigt__p_wxMimeTypesManager,
34451 &_swigt__p_wxMouseCaptureChangedEvent,
34452 &_swigt__p_wxMouseEvent,
34453 &_swigt__p_wxMouseState,
34454 &_swigt__p_wxMoveEvent,
34455 &_swigt__p_wxMutexGuiLocker,
34456 &_swigt__p_wxNavigationKeyEvent,
34457 &_swigt__p_wxNcPaintEvent,
34458 &_swigt__p_wxNotifyEvent,
34459 &_swigt__p_wxObject,
34460 &_swigt__p_wxOutputStream,
34461 &_swigt__p_wxPCXHandler,
34462 &_swigt__p_wxPNGHandler,
34463 &_swigt__p_wxPNMHandler,
34464 &_swigt__p_wxPaintEvent,
34465 &_swigt__p_wxPaletteChangedEvent,
34466 &_swigt__p_wxPaperSize,
34467 &_swigt__p_wxPoint,
34468 &_swigt__p_wxProcessEvent,
34469 &_swigt__p_wxPyApp,
34470 &_swigt__p_wxPyArtProvider,
34471 &_swigt__p_wxPyBitmapDataObject,
34472 &_swigt__p_wxPyCommandEvent,
34473 &_swigt__p_wxPyDataObjectSimple,
34474 &_swigt__p_wxPyDropSource,
34475 &_swigt__p_wxPyDropTarget,
34476 &_swigt__p_wxPyEvent,
34477 &_swigt__p_wxPyFileDropTarget,
34478 &_swigt__p_wxPyImageHandler,
34479 &_swigt__p_wxPyLog,
34480 &_swigt__p_wxPyProcess,
34481 &_swigt__p_wxPySizer,
34482 &_swigt__p_wxPyTextDataObject,
34483 &_swigt__p_wxPyTextDropTarget,
34484 &_swigt__p_wxPyTimer,
34485 &_swigt__p_wxPyTipProvider,
34486 &_swigt__p_wxPyValidator,
34487 &_swigt__p_wxQueryNewPaletteEvent,
34488 &_swigt__p_wxRect,
34489 &_swigt__p_wxScrollEvent,
34490 &_swigt__p_wxScrollWinEvent,
34491 &_swigt__p_wxSetCursorEvent,
34492 &_swigt__p_wxShowEvent,
34493 &_swigt__p_wxSingleInstanceChecker,
34494 &_swigt__p_wxSize,
34495 &_swigt__p_wxSizeEvent,
34496 &_swigt__p_wxSizer,
34497 &_swigt__p_wxSizerItem,
34498 &_swigt__p_wxSound,
34499 &_swigt__p_wxStandardPaths,
34500 &_swigt__p_wxStaticBoxSizer,
34501 &_swigt__p_wxStdDialogButtonSizer,
34502 &_swigt__p_wxStopWatch,
34503 &_swigt__p_wxString,
34504 &_swigt__p_wxSysColourChangedEvent,
34505 &_swigt__p_wxSystemOptions,
34506 &_swigt__p_wxSystemSettings,
34507 &_swigt__p_wxTIFFHandler,
34508 &_swigt__p_wxTextCtrl,
34509 &_swigt__p_wxTextDataObject,
34510 &_swigt__p_wxTimeSpan,
34511 &_swigt__p_wxTimer,
34512 &_swigt__p_wxTimerEvent,
34513 &_swigt__p_wxTimerRunner,
34514 &_swigt__p_wxTipProvider,
34515 &_swigt__p_wxToolTip,
34516 &_swigt__p_wxURLDataObject,
34517 &_swigt__p_wxUpdateUIEvent,
34518 &_swigt__p_wxValidator,
34519 &_swigt__p_wxVideoMode,
34520 &_swigt__p_wxWindow,
34521 &_swigt__p_wxWindowCreateEvent,
34522 &_swigt__p_wxWindowDestroyEvent,
34523 &_swigt__p_wxWindowDisabler,
34524 &_swigt__p_wxXPMHandler,
34525 &_swigt__ptrdiff_t,
34526 &_swigt__std__ptrdiff_t,
34527 &_swigt__unsigned_int,
34528 };
34529
34530 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
34531 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
34532 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
34533 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
34534 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
34535 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
34536 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
34537 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
34538 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
34539 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}};
34540 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
34541 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
34542 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
34543 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
34544 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
34545 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
34546 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
34547 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
34548 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}};
34549 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
34550 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
34551 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
34552 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
34553 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
34554 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}};
34555 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
34556 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}};
34557 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
34558 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
34559 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
34560 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
34561 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
34562 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
34563 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
34564 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
34565 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
34566 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
34567 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
34568 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
34569 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
34570 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
34571 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
34572 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
34573 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
34574 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
34575 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
34576 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
34577 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
34578 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
34579 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
34580 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
34581 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
34582 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
34583 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
34584 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34585 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34586 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34587 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
34588 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
34589 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
34590 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
34591 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
34592 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
34593 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
34594 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
34595 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
34596 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
34597 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
34598 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}};
34599 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
34600 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
34601 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
34602 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
34603 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
34604 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
34605 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}};
34606 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
34607 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
34608 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
34609 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
34610 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
34611 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
34612 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
34613 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
34614 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
34615 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
34616 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
34617 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}};
34618 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
34619 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
34620 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
34621 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
34622 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
34623 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
34624 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
34625 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
34626 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
34627 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
34628 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
34629 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
34630 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
34631 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
34632 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
34633 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
34634 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
34635 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
34636 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
34637 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
34638 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
34639 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
34640 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
34641 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
34642 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
34643 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
34644 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
34645 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
34646 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
34647 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
34648 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
34649 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
34650 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
34651 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
34652 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
34653 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
34654 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
34655 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
34656 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
34657 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
34658 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
34659 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
34660 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
34661 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}};
34662 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
34663 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
34664 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
34665 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
34666 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
34667 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
34668 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
34669 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
34670 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}};
34671 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
34672 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
34673 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
34674 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
34675 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
34676 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
34677 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
34678 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
34679 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
34680 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
34681 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
34682 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
34683 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
34684 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
34685 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
34686 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
34687 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
34688 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}};
34689 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
34690 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
34691 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
34692 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
34693 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}};
34694 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
34695 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
34696 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
34697 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}};
34698 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
34699 static swig_cast_info _swigc__ptrdiff_t[] = { {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
34700 static swig_cast_info _swigc__std__ptrdiff_t[] = { {&_swigt__std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
34701 static swig_cast_info _swigc__unsigned_int[] = { {&_swigt__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
34702
34703 static swig_cast_info *swig_cast_initial[] = {
34704 _swigc__p_char,
34705 _swigc__p_form_ops_t,
34706 _swigc__p_int,
34707 _swigc__p_unsigned_char,
34708 _swigc__p_unsigned_int,
34709 _swigc__p_unsigned_long,
34710 _swigc__p_void,
34711 _swigc__p_wxANIHandler,
34712 _swigc__p_wxAcceleratorTable,
34713 _swigc__p_wxActivateEvent,
34714 _swigc__p_wxArrayString,
34715 _swigc__p_wxBMPHandler,
34716 _swigc__p_wxBitmap,
34717 _swigc__p_wxBitmapDataObject,
34718 _swigc__p_wxBoxSizer,
34719 _swigc__p_wxBusyCursor,
34720 _swigc__p_wxBusyInfo,
34721 _swigc__p_wxCURHandler,
34722 _swigc__p_wxCaret,
34723 _swigc__p_wxChar,
34724 _swigc__p_wxChildFocusEvent,
34725 _swigc__p_wxClipboard,
34726 _swigc__p_wxClipboardLocker,
34727 _swigc__p_wxCloseEvent,
34728 _swigc__p_wxColour,
34729 _swigc__p_wxCommandEvent,
34730 _swigc__p_wxConfig,
34731 _swigc__p_wxConfigBase,
34732 _swigc__p_wxConfigPathChanger,
34733 _swigc__p_wxContextMenuEvent,
34734 _swigc__p_wxControl,
34735 _swigc__p_wxControlWithItems,
34736 _swigc__p_wxCursor,
34737 _swigc__p_wxCustomDataObject,
34738 _swigc__p_wxDC,
34739 _swigc__p_wxDataFormat,
34740 _swigc__p_wxDataObject,
34741 _swigc__p_wxDataObjectComposite,
34742 _swigc__p_wxDataObjectSimple,
34743 _swigc__p_wxDateEvent,
34744 _swigc__p_wxDateSpan,
34745 _swigc__p_wxDateTime,
34746 _swigc__p_wxDateTime__TimeZone,
34747 _swigc__p_wxDisplay,
34748 _swigc__p_wxDisplayChangedEvent,
34749 _swigc__p_wxDropFilesEvent,
34750 _swigc__p_wxDuplexMode,
34751 _swigc__p_wxEraseEvent,
34752 _swigc__p_wxEvent,
34753 _swigc__p_wxEvtHandler,
34754 _swigc__p_wxFSFile,
34755 _swigc__p_wxFileConfig,
34756 _swigc__p_wxFileDataObject,
34757 _swigc__p_wxFileHistory,
34758 _swigc__p_wxFileSystem,
34759 _swigc__p_wxFileType,
34760 _swigc__p_wxFileTypeInfo,
34761 _swigc__p_wxFlexGridSizer,
34762 _swigc__p_wxFocusEvent,
34763 _swigc__p_wxFont,
34764 _swigc__p_wxFrame,
34765 _swigc__p_wxGBSizerItem,
34766 _swigc__p_wxGIFHandler,
34767 _swigc__p_wxGridBagSizer,
34768 _swigc__p_wxGridSizer,
34769 _swigc__p_wxICOHandler,
34770 _swigc__p_wxIcon,
34771 _swigc__p_wxIconizeEvent,
34772 _swigc__p_wxIdleEvent,
34773 _swigc__p_wxImage,
34774 _swigc__p_wxImageHandler,
34775 _swigc__p_wxIndividualLayoutConstraint,
34776 _swigc__p_wxInitDialogEvent,
34777 _swigc__p_wxJPEGHandler,
34778 _swigc__p_wxJoystick,
34779 _swigc__p_wxJoystickEvent,
34780 _swigc__p_wxKeyEvent,
34781 _swigc__p_wxKillError,
34782 _swigc__p_wxLayoutConstraints,
34783 _swigc__p_wxLog,
34784 _swigc__p_wxLogBuffer,
34785 _swigc__p_wxLogChain,
34786 _swigc__p_wxLogGui,
34787 _swigc__p_wxLogNull,
34788 _swigc__p_wxLogStderr,
34789 _swigc__p_wxLogTextCtrl,
34790 _swigc__p_wxLogWindow,
34791 _swigc__p_wxMaximizeEvent,
34792 _swigc__p_wxMemorySize,
34793 _swigc__p_wxMenu,
34794 _swigc__p_wxMenuBar,
34795 _swigc__p_wxMenuEvent,
34796 _swigc__p_wxMenuItem,
34797 _swigc__p_wxMetafileDataObject,
34798 _swigc__p_wxMimeTypesManager,
34799 _swigc__p_wxMouseCaptureChangedEvent,
34800 _swigc__p_wxMouseEvent,
34801 _swigc__p_wxMouseState,
34802 _swigc__p_wxMoveEvent,
34803 _swigc__p_wxMutexGuiLocker,
34804 _swigc__p_wxNavigationKeyEvent,
34805 _swigc__p_wxNcPaintEvent,
34806 _swigc__p_wxNotifyEvent,
34807 _swigc__p_wxObject,
34808 _swigc__p_wxOutputStream,
34809 _swigc__p_wxPCXHandler,
34810 _swigc__p_wxPNGHandler,
34811 _swigc__p_wxPNMHandler,
34812 _swigc__p_wxPaintEvent,
34813 _swigc__p_wxPaletteChangedEvent,
34814 _swigc__p_wxPaperSize,
34815 _swigc__p_wxPoint,
34816 _swigc__p_wxProcessEvent,
34817 _swigc__p_wxPyApp,
34818 _swigc__p_wxPyArtProvider,
34819 _swigc__p_wxPyBitmapDataObject,
34820 _swigc__p_wxPyCommandEvent,
34821 _swigc__p_wxPyDataObjectSimple,
34822 _swigc__p_wxPyDropSource,
34823 _swigc__p_wxPyDropTarget,
34824 _swigc__p_wxPyEvent,
34825 _swigc__p_wxPyFileDropTarget,
34826 _swigc__p_wxPyImageHandler,
34827 _swigc__p_wxPyLog,
34828 _swigc__p_wxPyProcess,
34829 _swigc__p_wxPySizer,
34830 _swigc__p_wxPyTextDataObject,
34831 _swigc__p_wxPyTextDropTarget,
34832 _swigc__p_wxPyTimer,
34833 _swigc__p_wxPyTipProvider,
34834 _swigc__p_wxPyValidator,
34835 _swigc__p_wxQueryNewPaletteEvent,
34836 _swigc__p_wxRect,
34837 _swigc__p_wxScrollEvent,
34838 _swigc__p_wxScrollWinEvent,
34839 _swigc__p_wxSetCursorEvent,
34840 _swigc__p_wxShowEvent,
34841 _swigc__p_wxSingleInstanceChecker,
34842 _swigc__p_wxSize,
34843 _swigc__p_wxSizeEvent,
34844 _swigc__p_wxSizer,
34845 _swigc__p_wxSizerItem,
34846 _swigc__p_wxSound,
34847 _swigc__p_wxStandardPaths,
34848 _swigc__p_wxStaticBoxSizer,
34849 _swigc__p_wxStdDialogButtonSizer,
34850 _swigc__p_wxStopWatch,
34851 _swigc__p_wxString,
34852 _swigc__p_wxSysColourChangedEvent,
34853 _swigc__p_wxSystemOptions,
34854 _swigc__p_wxSystemSettings,
34855 _swigc__p_wxTIFFHandler,
34856 _swigc__p_wxTextCtrl,
34857 _swigc__p_wxTextDataObject,
34858 _swigc__p_wxTimeSpan,
34859 _swigc__p_wxTimer,
34860 _swigc__p_wxTimerEvent,
34861 _swigc__p_wxTimerRunner,
34862 _swigc__p_wxTipProvider,
34863 _swigc__p_wxToolTip,
34864 _swigc__p_wxURLDataObject,
34865 _swigc__p_wxUpdateUIEvent,
34866 _swigc__p_wxValidator,
34867 _swigc__p_wxVideoMode,
34868 _swigc__p_wxWindow,
34869 _swigc__p_wxWindowCreateEvent,
34870 _swigc__p_wxWindowDestroyEvent,
34871 _swigc__p_wxWindowDisabler,
34872 _swigc__p_wxXPMHandler,
34873 _swigc__ptrdiff_t,
34874 _swigc__std__ptrdiff_t,
34875 _swigc__unsigned_int,
34876 };
34877
34878
34879 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
34880
34881 static swig_const_info swig_const_table[] = {
34882 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
34883 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
34884 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
34885 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
34886 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
34887 {0, 0, 0, 0.0, 0, 0}};
34888
34889 #ifdef __cplusplus
34890 }
34891 #endif
34892 /*************************************************************************
34893 * Type initialization:
34894 * This problem is tough by the requirement that no dynamic
34895 * memory is used. Also, since swig_type_info structures store pointers to
34896 * swig_cast_info structures and swig_cast_info structures store pointers back
34897 * to swig_type_info structures, we need some lookup code at initialization.
34898 * The idea is that swig generates all the structures that are needed.
34899 * The runtime then collects these partially filled structures.
34900 * The SWIG_InitializeModule function takes these initial arrays out of
34901 * swig_module, and does all the lookup, filling in the swig_module.types
34902 * array with the correct data and linking the correct swig_cast_info
34903 * structures together.
34904
34905 * The generated swig_type_info structures are assigned staticly to an initial
34906 * array. We just loop though that array, and handle each type individually.
34907 * First we lookup if this type has been already loaded, and if so, use the
34908 * loaded structure instead of the generated one. Then we have to fill in the
34909 * cast linked list. The cast data is initially stored in something like a
34910 * two-dimensional array. Each row corresponds to a type (there are the same
34911 * number of rows as there are in the swig_type_initial array). Each entry in
34912 * a column is one of the swig_cast_info structures for that type.
34913 * The cast_initial array is actually an array of arrays, because each row has
34914 * a variable number of columns. So to actually build the cast linked list,
34915 * we find the array of casts associated with the type, and loop through it
34916 * adding the casts to the list. The one last trick we need to do is making
34917 * sure the type pointer in the swig_cast_info struct is correct.
34918
34919 * First off, we lookup the cast->type name to see if it is already loaded.
34920 * There are three cases to handle:
34921 * 1) If the cast->type has already been loaded AND the type we are adding
34922 * casting info to has not been loaded (it is in this module), THEN we
34923 * replace the cast->type pointer with the type pointer that has already
34924 * been loaded.
34925 * 2) If BOTH types (the one we are adding casting info to, and the
34926 * cast->type) are loaded, THEN the cast info has already been loaded by
34927 * the previous module so we just ignore it.
34928 * 3) Finally, if cast->type has not already been loaded, then we add that
34929 * swig_cast_info to the linked list (because the cast->type) pointer will
34930 * be correct.
34931 **/
34932
34933 #ifdef __cplusplus
34934 extern "C" {
34935 #if 0
34936 } /* c-mode */
34937 #endif
34938 #endif
34939
34940 #if 0
34941 #define SWIGRUNTIME_DEBUG
34942 #endif
34943
34944 SWIGRUNTIME void
34945 SWIG_InitializeModule(void *clientdata) {
34946 size_t i;
34947 swig_module_info *module_head;
34948 static int init_run = 0;
34949
34950 clientdata = clientdata;
34951
34952 if (init_run) return;
34953 init_run = 1;
34954
34955 /* Initialize the swig_module */
34956 swig_module.type_initial = swig_type_initial;
34957 swig_module.cast_initial = swig_cast_initial;
34958
34959 /* Try and load any already created modules */
34960 module_head = SWIG_GetModule(clientdata);
34961 if (module_head) {
34962 swig_module.next = module_head->next;
34963 module_head->next = &swig_module;
34964 } else {
34965 /* This is the first module loaded */
34966 swig_module.next = &swig_module;
34967 SWIG_SetModule(clientdata, &swig_module);
34968 }
34969
34970 /* Now work on filling in swig_module.types */
34971 #ifdef SWIGRUNTIME_DEBUG
34972 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
34973 #endif
34974 for (i = 0; i < swig_module.size; ++i) {
34975 swig_type_info *type = 0;
34976 swig_type_info *ret;
34977 swig_cast_info *cast;
34978
34979 #ifdef SWIGRUNTIME_DEBUG
34980 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
34981 #endif
34982
34983 /* if there is another module already loaded */
34984 if (swig_module.next != &swig_module) {
34985 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
34986 }
34987 if (type) {
34988 /* Overwrite clientdata field */
34989 #ifdef SWIGRUNTIME_DEBUG
34990 printf("SWIG_InitializeModule: found type %s\n", type->name);
34991 #endif
34992 if (swig_module.type_initial[i]->clientdata) {
34993 type->clientdata = swig_module.type_initial[i]->clientdata;
34994 #ifdef SWIGRUNTIME_DEBUG
34995 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
34996 #endif
34997 }
34998 } else {
34999 type = swig_module.type_initial[i];
35000 }
35001
35002 /* Insert casting types */
35003 cast = swig_module.cast_initial[i];
35004 while (cast->type) {
35005 /* Don't need to add information already in the list */
35006 ret = 0;
35007 #ifdef SWIGRUNTIME_DEBUG
35008 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
35009 #endif
35010 if (swig_module.next != &swig_module) {
35011 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
35012 #ifdef SWIGRUNTIME_DEBUG
35013 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
35014 #endif
35015 }
35016 if (ret) {
35017 if (type == swig_module.type_initial[i]) {
35018 #ifdef SWIGRUNTIME_DEBUG
35019 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
35020 #endif
35021 cast->type = ret;
35022 ret = 0;
35023 } else {
35024 /* Check for casting already in the list */
35025 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
35026 #ifdef SWIGRUNTIME_DEBUG
35027 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
35028 #endif
35029 if (!ocast) ret = 0;
35030 }
35031 }
35032
35033 if (!ret) {
35034 #ifdef SWIGRUNTIME_DEBUG
35035 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
35036 #endif
35037 if (type->cast) {
35038 type->cast->prev = cast;
35039 cast->next = type->cast;
35040 }
35041 type->cast = cast;
35042 }
35043 cast++;
35044 }
35045 /* Set entry in modules->types array equal to the type */
35046 swig_module.types[i] = type;
35047 }
35048 swig_module.types[i] = 0;
35049
35050 #ifdef SWIGRUNTIME_DEBUG
35051 printf("**** SWIG_InitializeModule: Cast List ******\n");
35052 for (i = 0; i < swig_module.size; ++i) {
35053 int j = 0;
35054 swig_cast_info *cast = swig_module.cast_initial[i];
35055 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
35056 while (cast->type) {
35057 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
35058 cast++;
35059 ++j;
35060 }
35061 printf("---- Total casts: %d\n",j);
35062 }
35063 printf("**** SWIG_InitializeModule: Cast List ******\n");
35064 #endif
35065 }
35066
35067 /* This function will propagate the clientdata field of type to
35068 * any new swig_type_info structures that have been added into the list
35069 * of equivalent types. It is like calling
35070 * SWIG_TypeClientData(type, clientdata) a second time.
35071 */
35072 SWIGRUNTIME void
35073 SWIG_PropagateClientData(void) {
35074 size_t i;
35075 swig_cast_info *equiv;
35076 static int init_run = 0;
35077
35078 if (init_run) return;
35079 init_run = 1;
35080
35081 for (i = 0; i < swig_module.size; i++) {
35082 if (swig_module.types[i]->clientdata) {
35083 equiv = swig_module.types[i]->cast;
35084 while (equiv) {
35085 if (!equiv->converter) {
35086 if (equiv->type && !equiv->type->clientdata)
35087 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
35088 }
35089 equiv = equiv->next;
35090 }
35091 }
35092 }
35093 }
35094
35095 #ifdef __cplusplus
35096 #if 0
35097 {
35098 /* c-mode */
35099 #endif
35100 }
35101 #endif
35102
35103
35104
35105 #ifdef __cplusplus
35106 extern "C" {
35107 #endif
35108
35109 /* Python-specific SWIG API */
35110 #define SWIG_newvarlink() SWIG_Python_newvarlink()
35111 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
35112 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
35113
35114 /* -----------------------------------------------------------------------------
35115 * global variable support code.
35116 * ----------------------------------------------------------------------------- */
35117
35118 typedef struct swig_globalvar {
35119 char *name; /* Name of global variable */
35120 PyObject *(*get_attr)(void); /* Return the current value */
35121 int (*set_attr)(PyObject *); /* Set the value */
35122 struct swig_globalvar *next;
35123 } swig_globalvar;
35124
35125 typedef struct swig_varlinkobject {
35126 PyObject_HEAD
35127 swig_globalvar *vars;
35128 } swig_varlinkobject;
35129
35130 SWIGINTERN PyObject *
35131 swig_varlink_repr(swig_varlinkobject *v) {
35132 v = v;
35133 return PyString_FromString("<Swig global variables>");
35134 }
35135
35136 SWIGINTERN int
35137 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
35138 swig_globalvar *var;
35139 flags = flags;
35140 fprintf(fp,"Swig global variables { ");
35141 for (var = v->vars; var; var=var->next) {
35142 fprintf(fp,"%s", var->name);
35143 if (var->next) fprintf(fp,", ");
35144 }
35145 fprintf(fp," }\n");
35146 return 0;
35147 }
35148
35149 SWIGINTERN PyObject *
35150 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
35151 swig_globalvar *var = v->vars;
35152 while (var) {
35153 if (strcmp(var->name,n) == 0) {
35154 return (*var->get_attr)();
35155 }
35156 var = var->next;
35157 }
35158 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
35159 return NULL;
35160 }
35161
35162 SWIGINTERN int
35163 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
35164 swig_globalvar *var = v->vars;
35165 while (var) {
35166 if (strcmp(var->name,n) == 0) {
35167 return (*var->set_attr)(p);
35168 }
35169 var = var->next;
35170 }
35171 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
35172 return 1;
35173 }
35174
35175 SWIGINTERN PyTypeObject*
35176 swig_varlink_type(void) {
35177 static char varlink__doc__[] = "Swig var link object";
35178 static PyTypeObject varlink_type
35179 #if !defined(__cplusplus)
35180 ;
35181 static int type_init = 0;
35182 if (!type_init) {
35183 PyTypeObject tmp
35184 #endif
35185 = {
35186 PyObject_HEAD_INIT(&PyType_Type)
35187 0, /* Number of items in variable part (ob_size) */
35188 (char *)"swigvarlink", /* Type name (tp_name) */
35189 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
35190 0, /* Itemsize (tp_itemsize) */
35191 0, /* Deallocator (tp_dealloc) */
35192 (printfunc) swig_varlink_print, /* Print (tp_print) */
35193 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
35194 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
35195 0, /* tp_compare */
35196 (reprfunc) swig_varlink_repr, /* tp_repr */
35197 0, /* tp_as_number */
35198 0, /* tp_as_sequence */
35199 0, /* tp_as_mapping */
35200 0, /* tp_hash */
35201 0, /* tp_call */
35202 0, /* tp_str */
35203 0, /* tp_getattro */
35204 0, /* tp_setattro */
35205 0, /* tp_as_buffer */
35206 0, /* tp_flags */
35207 varlink__doc__, /* tp_doc */
35208 #if PY_VERSION_HEX >= 0x02000000
35209 0, /* tp_traverse */
35210 0, /* tp_clear */
35211 #endif
35212 #if PY_VERSION_HEX >= 0x02010000
35213 0, /* tp_richcompare */
35214 0, /* tp_weaklistoffset */
35215 #endif
35216 #if PY_VERSION_HEX >= 0x02020000
35217 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
35218 #endif
35219 #if PY_VERSION_HEX >= 0x02030000
35220 0, /* tp_del */
35221 #endif
35222 #ifdef COUNT_ALLOCS
35223 0,0,0,0 /* tp_alloc -> tp_next */
35224 #endif
35225 };
35226 #if !defined(__cplusplus)
35227 varlink_type = tmp;
35228 type_init = 1;
35229 }
35230 #endif
35231 return &varlink_type;
35232 }
35233
35234 /* Create a variable linking object for use later */
35235 SWIGINTERN PyObject *
35236 SWIG_Python_newvarlink(void) {
35237 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
35238 if (result) {
35239 result->vars = 0;
35240 }
35241 return ((PyObject*) result);
35242 }
35243
35244 SWIGINTERN void
35245 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
35246 swig_varlinkobject *v = (swig_varlinkobject *) p;
35247 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
35248 if (gv) {
35249 size_t size = strlen(name)+1;
35250 gv->name = (char *)malloc(size);
35251 if (gv->name) {
35252 strncpy(gv->name,name,size);
35253 gv->get_attr = get_attr;
35254 gv->set_attr = set_attr;
35255 gv->next = v->vars;
35256 }
35257 }
35258 v->vars = gv;
35259 }
35260
35261 /* -----------------------------------------------------------------------------
35262 * constants/methods manipulation
35263 * ----------------------------------------------------------------------------- */
35264
35265 /* Install Constants */
35266 SWIGINTERN void
35267 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
35268 PyObject *obj = 0;
35269 size_t i;
35270 for (i = 0; constants[i].type; ++i) {
35271 switch(constants[i].type) {
35272 case SWIG_PY_INT:
35273 obj = PyInt_FromLong(constants[i].lvalue);
35274 break;
35275 case SWIG_PY_FLOAT:
35276 obj = PyFloat_FromDouble(constants[i].dvalue);
35277 break;
35278 case SWIG_PY_STRING:
35279 if (constants[i].pvalue) {
35280 obj = PyString_FromString((char *) constants[i].pvalue);
35281 } else {
35282 Py_INCREF(Py_None);
35283 obj = Py_None;
35284 }
35285 break;
35286 case SWIG_PY_POINTER:
35287 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
35288 break;
35289 case SWIG_PY_BINARY:
35290 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
35291 break;
35292 default:
35293 obj = 0;
35294 break;
35295 }
35296 if (obj) {
35297 PyDict_SetItemString(d,constants[i].name,obj);
35298 Py_DECREF(obj);
35299 }
35300 }
35301 }
35302
35303 /* -----------------------------------------------------------------------------*/
35304 /* Fix SwigMethods to carry the callback ptrs when needed */
35305 /* -----------------------------------------------------------------------------*/
35306
35307 SWIGINTERN void
35308 SWIG_Python_FixMethods(PyMethodDef *methods,
35309 swig_const_info *const_table,
35310 swig_type_info **types,
35311 swig_type_info **types_initial) {
35312 size_t i;
35313 for (i = 0; methods[i].ml_name; ++i) {
35314 char *c = methods[i].ml_doc;
35315 if (c && (c = strstr(c, "swig_ptr: "))) {
35316 int j;
35317 swig_const_info *ci = 0;
35318 char *name = c + 10;
35319 for (j = 0; const_table[j].type; ++j) {
35320 if (strncmp(const_table[j].name, name,
35321 strlen(const_table[j].name)) == 0) {
35322 ci = &(const_table[j]);
35323 break;
35324 }
35325 }
35326 if (ci) {
35327 size_t shift = (ci->ptype) - types;
35328 swig_type_info *ty = types_initial[shift];
35329 size_t ldoc = (c - methods[i].ml_doc);
35330 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
35331 char *ndoc = (char*)malloc(ldoc + lptr + 10);
35332 if (ndoc) {
35333 char *buff = ndoc;
35334 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
35335 if (ptr) {
35336 strncpy(buff, methods[i].ml_doc, ldoc);
35337 buff += ldoc;
35338 strncpy(buff, "swig_ptr: ", 10);
35339 buff += 10;
35340 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
35341 methods[i].ml_doc = ndoc;
35342 }
35343 }
35344 }
35345 }
35346 }
35347 }
35348
35349 /* -----------------------------------------------------------------------------*
35350 * Initialize type list
35351 * -----------------------------------------------------------------------------*/
35352
35353 #ifdef __cplusplus
35354 }
35355 #endif
35356
35357 /* -----------------------------------------------------------------------------*
35358 * Partial Init method
35359 * -----------------------------------------------------------------------------*/
35360
35361 #ifdef __cplusplus
35362 extern "C"
35363 #endif
35364 SWIGEXPORT void SWIG_init(void) {
35365 static PyObject *SWIG_globals = 0;
35366 PyObject *m, *d;
35367 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
35368
35369 /* Fix SwigMethods to carry the callback ptrs when needed */
35370 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
35371
35372 m = Py_InitModule((char *) SWIG_name, SwigMethods);
35373 d = PyModule_GetDict(m);
35374
35375 SWIG_InitializeModule(0);
35376 SWIG_InstallConstants(d,swig_const_table);
35377
35378 {
35379 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int(static_cast<int >(wxSYS_OEM_FIXED_FONT)));
35380 }
35381 {
35382 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int(static_cast<int >(wxSYS_ANSI_FIXED_FONT)));
35383 }
35384 {
35385 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int(static_cast<int >(wxSYS_ANSI_VAR_FONT)));
35386 }
35387 {
35388 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int(static_cast<int >(wxSYS_SYSTEM_FONT)));
35389 }
35390 {
35391 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int(static_cast<int >(wxSYS_DEVICE_DEFAULT_FONT)));
35392 }
35393 {
35394 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int(static_cast<int >(wxSYS_DEFAULT_PALETTE)));
35395 }
35396 {
35397 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int(static_cast<int >(wxSYS_SYSTEM_FIXED_FONT)));
35398 }
35399 {
35400 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int(static_cast<int >(wxSYS_DEFAULT_GUI_FONT)));
35401 }
35402 {
35403 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int(static_cast<int >(wxSYS_ICONTITLE_FONT)));
35404 }
35405 {
35406 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_SCROLLBAR)));
35407 }
35408 {
35409 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BACKGROUND)));
35410 }
35411 {
35412 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_DESKTOP)));
35413 }
35414 {
35415 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_ACTIVECAPTION)));
35416 }
35417 {
35418 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INACTIVECAPTION)));
35419 }
35420 {
35421 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MENU)));
35422 }
35423 {
35424 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_WINDOW)));
35425 }
35426 {
35427 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_WINDOWFRAME)));
35428 }
35429 {
35430 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MENUTEXT)));
35431 }
35432 {
35433 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_WINDOWTEXT)));
35434 }
35435 {
35436 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_CAPTIONTEXT)));
35437 }
35438 {
35439 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_ACTIVEBORDER)));
35440 }
35441 {
35442 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INACTIVEBORDER)));
35443 }
35444 {
35445 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_APPWORKSPACE)));
35446 }
35447 {
35448 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_HIGHLIGHT)));
35449 }
35450 {
35451 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
35452 }
35453 {
35454 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNFACE)));
35455 }
35456 {
35457 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DFACE)));
35458 }
35459 {
35460 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNSHADOW)));
35461 }
35462 {
35463 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DSHADOW)));
35464 }
35465 {
35466 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_GRAYTEXT)));
35467 }
35468 {
35469 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNTEXT)));
35470 }
35471 {
35472 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
35473 }
35474 {
35475 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
35476 }
35477 {
35478 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_BTNHILIGHT)));
35479 }
35480 {
35481 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DHIGHLIGHT)));
35482 }
35483 {
35484 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DHILIGHT)));
35485 }
35486 {
35487 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DDKSHADOW)));
35488 }
35489 {
35490 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_3DLIGHT)));
35491 }
35492 {
35493 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INFOTEXT)));
35494 }
35495 {
35496 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_INFOBK)));
35497 }
35498 {
35499 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_LISTBOX)));
35500 }
35501 {
35502 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_HOTLIGHT)));
35503 }
35504 {
35505 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
35506 }
35507 {
35508 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
35509 }
35510 {
35511 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MENUHILIGHT)));
35512 }
35513 {
35514 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MENUBAR)));
35515 }
35516 {
35517 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int(static_cast<int >(wxSYS_COLOUR_MAX)));
35518 }
35519 {
35520 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int(static_cast<int >(wxSYS_MOUSE_BUTTONS)));
35521 }
35522 {
35523 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int(static_cast<int >(wxSYS_BORDER_X)));
35524 }
35525 {
35526 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int(static_cast<int >(wxSYS_BORDER_Y)));
35527 }
35528 {
35529 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int(static_cast<int >(wxSYS_CURSOR_X)));
35530 }
35531 {
35532 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int(static_cast<int >(wxSYS_CURSOR_Y)));
35533 }
35534 {
35535 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int(static_cast<int >(wxSYS_DCLICK_X)));
35536 }
35537 {
35538 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int(static_cast<int >(wxSYS_DCLICK_Y)));
35539 }
35540 {
35541 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int(static_cast<int >(wxSYS_DRAG_X)));
35542 }
35543 {
35544 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int(static_cast<int >(wxSYS_DRAG_Y)));
35545 }
35546 {
35547 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int(static_cast<int >(wxSYS_EDGE_X)));
35548 }
35549 {
35550 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int(static_cast<int >(wxSYS_EDGE_Y)));
35551 }
35552 {
35553 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int(static_cast<int >(wxSYS_HSCROLL_ARROW_X)));
35554 }
35555 {
35556 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int(static_cast<int >(wxSYS_HSCROLL_ARROW_Y)));
35557 }
35558 {
35559 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int(static_cast<int >(wxSYS_HTHUMB_X)));
35560 }
35561 {
35562 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int(static_cast<int >(wxSYS_ICON_X)));
35563 }
35564 {
35565 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int(static_cast<int >(wxSYS_ICON_Y)));
35566 }
35567 {
35568 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int(static_cast<int >(wxSYS_ICONSPACING_X)));
35569 }
35570 {
35571 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int(static_cast<int >(wxSYS_ICONSPACING_Y)));
35572 }
35573 {
35574 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int(static_cast<int >(wxSYS_WINDOWMIN_X)));
35575 }
35576 {
35577 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int(static_cast<int >(wxSYS_WINDOWMIN_Y)));
35578 }
35579 {
35580 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_X)));
35581 }
35582 {
35583 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_Y)));
35584 }
35585 {
35586 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int(static_cast<int >(wxSYS_FRAMESIZE_X)));
35587 }
35588 {
35589 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int(static_cast<int >(wxSYS_FRAMESIZE_Y)));
35590 }
35591 {
35592 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int(static_cast<int >(wxSYS_SMALLICON_X)));
35593 }
35594 {
35595 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int(static_cast<int >(wxSYS_SMALLICON_Y)));
35596 }
35597 {
35598 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int(static_cast<int >(wxSYS_HSCROLL_Y)));
35599 }
35600 {
35601 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int(static_cast<int >(wxSYS_VSCROLL_X)));
35602 }
35603 {
35604 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int(static_cast<int >(wxSYS_VSCROLL_ARROW_X)));
35605 }
35606 {
35607 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int(static_cast<int >(wxSYS_VSCROLL_ARROW_Y)));
35608 }
35609 {
35610 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int(static_cast<int >(wxSYS_VTHUMB_Y)));
35611 }
35612 {
35613 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int(static_cast<int >(wxSYS_CAPTION_Y)));
35614 }
35615 {
35616 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int(static_cast<int >(wxSYS_MENU_Y)));
35617 }
35618 {
35619 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int(static_cast<int >(wxSYS_NETWORK_PRESENT)));
35620 }
35621 {
35622 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int(static_cast<int >(wxSYS_PENWINDOWS_PRESENT)));
35623 }
35624 {
35625 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int(static_cast<int >(wxSYS_SHOW_SOUNDS)));
35626 }
35627 {
35628 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int(static_cast<int >(wxSYS_SWAP_BUTTONS)));
35629 }
35630 {
35631 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int(static_cast<int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
35632 }
35633 {
35634 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int(static_cast<int >(wxSYS_CAN_ICONIZE_FRAME)));
35635 }
35636 {
35637 PyDict_SetItemString(d,"SYS_TABLET_PRESENT", SWIG_From_int(static_cast<int >(wxSYS_TABLET_PRESENT)));
35638 }
35639 {
35640 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_NONE)));
35641 }
35642 {
35643 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_TINY)));
35644 }
35645 {
35646 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_PDA)));
35647 }
35648 {
35649 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_SMALL)));
35650 }
35651 {
35652 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int(static_cast<int >(wxSYS_SCREEN_DESKTOP)));
35653 }
35654 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
35655 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
35656 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
35657 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
35658 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
35659 {
35660 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int(static_cast<int >(wxSHUTDOWN_POWEROFF)));
35661 }
35662 {
35663 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int(static_cast<int >(wxSHUTDOWN_REBOOT)));
35664 }
35665 {
35666 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int(static_cast<int >(wxTIMER_CONTINUOUS)));
35667 }
35668 {
35669 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int(static_cast<int >(wxTIMER_ONE_SHOT)));
35670 }
35671 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
35672
35673 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
35674
35675 {
35676 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int(static_cast<int >(wxLOG_FatalError)));
35677 }
35678 {
35679 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int(static_cast<int >(wxLOG_Error)));
35680 }
35681 {
35682 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int(static_cast<int >(wxLOG_Warning)));
35683 }
35684 {
35685 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int(static_cast<int >(wxLOG_Message)));
35686 }
35687 {
35688 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int(static_cast<int >(wxLOG_Status)));
35689 }
35690 {
35691 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int(static_cast<int >(wxLOG_Info)));
35692 }
35693 {
35694 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int(static_cast<int >(wxLOG_Debug)));
35695 }
35696 {
35697 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int(static_cast<int >(wxLOG_Trace)));
35698 }
35699 {
35700 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int(static_cast<int >(wxLOG_Progress)));
35701 }
35702 {
35703 PyDict_SetItemString(d,"LOG_User", SWIG_From_int(static_cast<int >(wxLOG_User)));
35704 }
35705 {
35706 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int(static_cast<int >(wxLOG_Max)));
35707 }
35708 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
35709 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
35710 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
35711 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
35712 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
35713 {
35714 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int(static_cast<int >(0x0001)));
35715 }
35716 {
35717 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int(static_cast<int >(0x0002)));
35718 }
35719 {
35720 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int(static_cast<int >(0x0004)));
35721 }
35722 {
35723 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int(static_cast<int >(0x0008)));
35724 }
35725 {
35726 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int(static_cast<int >(0x0100)));
35727 }
35728 {
35729 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int(static_cast<int >(wxPROCESS_DEFAULT)));
35730 }
35731 {
35732 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int(static_cast<int >(wxPROCESS_REDIRECT)));
35733 }
35734 {
35735 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int(static_cast<int >(wxKILL_OK)));
35736 }
35737 {
35738 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int(static_cast<int >(wxKILL_BAD_SIGNAL)));
35739 }
35740 {
35741 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int(static_cast<int >(wxKILL_ACCESS_DENIED)));
35742 }
35743 {
35744 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int(static_cast<int >(wxKILL_NO_PROCESS)));
35745 }
35746 {
35747 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int(static_cast<int >(wxKILL_ERROR)));
35748 }
35749 {
35750 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int(static_cast<int >(wxKILL_NOCHILDREN)));
35751 }
35752 {
35753 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int(static_cast<int >(wxKILL_CHILDREN)));
35754 }
35755 {
35756 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int(static_cast<int >(wxSIGNONE)));
35757 }
35758 {
35759 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int(static_cast<int >(wxSIGHUP)));
35760 }
35761 {
35762 PyDict_SetItemString(d,"SIGINT", SWIG_From_int(static_cast<int >(wxSIGINT)));
35763 }
35764 {
35765 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int(static_cast<int >(wxSIGQUIT)));
35766 }
35767 {
35768 PyDict_SetItemString(d,"SIGILL", SWIG_From_int(static_cast<int >(wxSIGILL)));
35769 }
35770 {
35771 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int(static_cast<int >(wxSIGTRAP)));
35772 }
35773 {
35774 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int(static_cast<int >(wxSIGABRT)));
35775 }
35776 {
35777 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int(static_cast<int >(wxSIGIOT)));
35778 }
35779 {
35780 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int(static_cast<int >(wxSIGEMT)));
35781 }
35782 {
35783 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int(static_cast<int >(wxSIGFPE)));
35784 }
35785 {
35786 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int(static_cast<int >(wxSIGKILL)));
35787 }
35788 {
35789 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int(static_cast<int >(wxSIGBUS)));
35790 }
35791 {
35792 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int(static_cast<int >(wxSIGSEGV)));
35793 }
35794 {
35795 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int(static_cast<int >(wxSIGSYS)));
35796 }
35797 {
35798 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int(static_cast<int >(wxSIGPIPE)));
35799 }
35800 {
35801 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int(static_cast<int >(wxSIGALRM)));
35802 }
35803 {
35804 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int(static_cast<int >(wxSIGTERM)));
35805 }
35806 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
35807 {
35808 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int(static_cast<int >(wxEXEC_ASYNC)));
35809 }
35810 {
35811 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int(static_cast<int >(wxEXEC_SYNC)));
35812 }
35813 {
35814 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int(static_cast<int >(wxEXEC_NOHIDE)));
35815 }
35816 {
35817 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int(static_cast<int >(wxEXEC_MAKE_GROUP_LEADER)));
35818 }
35819 {
35820 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int(static_cast<int >(wxEXEC_NODISABLE)));
35821 }
35822
35823 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
35824
35825 {
35826 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int(static_cast<int >(wxJOYSTICK1)));
35827 }
35828 {
35829 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int(static_cast<int >(wxJOYSTICK2)));
35830 }
35831 {
35832 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int(static_cast<int >(wxJOY_BUTTON_ANY)));
35833 }
35834 {
35835 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int(static_cast<int >(wxJOY_BUTTON1)));
35836 }
35837 {
35838 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int(static_cast<int >(wxJOY_BUTTON2)));
35839 }
35840 {
35841 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int(static_cast<int >(wxJOY_BUTTON3)));
35842 }
35843 {
35844 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int(static_cast<int >(wxJOY_BUTTON4)));
35845 }
35846 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
35847 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
35848 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
35849 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
35850 {
35851 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int(static_cast<int >(wxSOUND_SYNC)));
35852 }
35853 {
35854 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int(static_cast<int >(wxSOUND_ASYNC)));
35855 }
35856 {
35857 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int(static_cast<int >(wxSOUND_LOOP)));
35858 }
35859 {
35860 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int(static_cast<int >(wxMAILCAP_STANDARD)));
35861 }
35862 {
35863 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int(static_cast<int >(wxMAILCAP_NETSCAPE)));
35864 }
35865 {
35866 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int(static_cast<int >(wxMAILCAP_KDE)));
35867 }
35868 {
35869 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int(static_cast<int >(wxMAILCAP_GNOME)));
35870 }
35871 {
35872 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int(static_cast<int >(wxMAILCAP_ALL)));
35873 }
35874 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
35875 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
35876 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
35877 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
35878 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
35879 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
35880 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
35881 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
35882 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
35883 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
35884 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
35885 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
35886 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
35887 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
35888 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
35889 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
35890 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
35891 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
35892 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
35893 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
35894 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
35895 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
35896 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
35897 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
35898 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
35899 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
35900 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
35901 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
35902 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
35903 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
35904 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
35905 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
35906 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
35907 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
35908 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
35909 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
35910 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
35911 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
35912 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
35913 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
35914 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
35915 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
35916 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
35917 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
35918 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
35919 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
35920 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
35921 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
35922 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
35923 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
35924 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
35925 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW",_wrap_ART_NEW_get, _wrap_ART_NEW_set);
35926 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
35927 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
35928 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
35929 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
35930 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
35931
35932 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
35933
35934 {
35935 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int(static_cast<int >(wxCONFIG_USE_LOCAL_FILE)));
35936 }
35937 {
35938 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int(static_cast<int >(wxCONFIG_USE_GLOBAL_FILE)));
35939 }
35940 {
35941 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int(static_cast<int >(wxCONFIG_USE_RELATIVE_PATH)));
35942 }
35943 {
35944 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int(static_cast<int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
35945 }
35946 {
35947 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int(static_cast<int >(wxConfigBase::Type_Unknown)));
35948 }
35949 {
35950 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int(static_cast<int >(wxConfigBase::Type_String)));
35951 }
35952 {
35953 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int(static_cast<int >(wxConfigBase::Type_Boolean)));
35954 }
35955 {
35956 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int(static_cast<int >(wxConfigBase::Type_Integer)));
35957 }
35958 {
35959 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int(static_cast<int >(wxConfigBase::Type_Float)));
35960 }
35961 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
35962 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
35963 {
35964 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int(static_cast<int >(wxDateTime::Local)));
35965 }
35966 {
35967 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int(static_cast<int >(wxDateTime::GMT_12)));
35968 }
35969 {
35970 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int(static_cast<int >(wxDateTime::GMT_11)));
35971 }
35972 {
35973 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int(static_cast<int >(wxDateTime::GMT_10)));
35974 }
35975 {
35976 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int(static_cast<int >(wxDateTime::GMT_9)));
35977 }
35978 {
35979 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int(static_cast<int >(wxDateTime::GMT_8)));
35980 }
35981 {
35982 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int(static_cast<int >(wxDateTime::GMT_7)));
35983 }
35984 {
35985 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int(static_cast<int >(wxDateTime::GMT_6)));
35986 }
35987 {
35988 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int(static_cast<int >(wxDateTime::GMT_5)));
35989 }
35990 {
35991 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int(static_cast<int >(wxDateTime::GMT_4)));
35992 }
35993 {
35994 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int(static_cast<int >(wxDateTime::GMT_3)));
35995 }
35996 {
35997 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int(static_cast<int >(wxDateTime::GMT_2)));
35998 }
35999 {
36000 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int(static_cast<int >(wxDateTime::GMT_1)));
36001 }
36002 {
36003 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int(static_cast<int >(wxDateTime::GMT0)));
36004 }
36005 {
36006 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int(static_cast<int >(wxDateTime::GMT1)));
36007 }
36008 {
36009 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int(static_cast<int >(wxDateTime::GMT2)));
36010 }
36011 {
36012 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int(static_cast<int >(wxDateTime::GMT3)));
36013 }
36014 {
36015 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int(static_cast<int >(wxDateTime::GMT4)));
36016 }
36017 {
36018 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int(static_cast<int >(wxDateTime::GMT5)));
36019 }
36020 {
36021 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int(static_cast<int >(wxDateTime::GMT6)));
36022 }
36023 {
36024 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int(static_cast<int >(wxDateTime::GMT7)));
36025 }
36026 {
36027 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int(static_cast<int >(wxDateTime::GMT8)));
36028 }
36029 {
36030 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int(static_cast<int >(wxDateTime::GMT9)));
36031 }
36032 {
36033 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int(static_cast<int >(wxDateTime::GMT10)));
36034 }
36035 {
36036 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int(static_cast<int >(wxDateTime::GMT11)));
36037 }
36038 {
36039 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int(static_cast<int >(wxDateTime::GMT12)));
36040 }
36041 {
36042 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int(static_cast<int >(wxDateTime::WET)));
36043 }
36044 {
36045 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int(static_cast<int >(wxDateTime::WEST)));
36046 }
36047 {
36048 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int(static_cast<int >(wxDateTime::CET)));
36049 }
36050 {
36051 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int(static_cast<int >(wxDateTime::CEST)));
36052 }
36053 {
36054 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int(static_cast<int >(wxDateTime::EET)));
36055 }
36056 {
36057 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int(static_cast<int >(wxDateTime::EEST)));
36058 }
36059 {
36060 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int(static_cast<int >(wxDateTime::MSK)));
36061 }
36062 {
36063 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int(static_cast<int >(wxDateTime::MSD)));
36064 }
36065 {
36066 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int(static_cast<int >(wxDateTime::AST)));
36067 }
36068 {
36069 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int(static_cast<int >(wxDateTime::ADT)));
36070 }
36071 {
36072 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int(static_cast<int >(wxDateTime::EST)));
36073 }
36074 {
36075 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int(static_cast<int >(wxDateTime::EDT)));
36076 }
36077 {
36078 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int(static_cast<int >(wxDateTime::CST)));
36079 }
36080 {
36081 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int(static_cast<int >(wxDateTime::CDT)));
36082 }
36083 {
36084 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int(static_cast<int >(wxDateTime::MST)));
36085 }
36086 {
36087 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int(static_cast<int >(wxDateTime::MDT)));
36088 }
36089 {
36090 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int(static_cast<int >(wxDateTime::PST)));
36091 }
36092 {
36093 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int(static_cast<int >(wxDateTime::PDT)));
36094 }
36095 {
36096 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int(static_cast<int >(wxDateTime::HST)));
36097 }
36098 {
36099 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int(static_cast<int >(wxDateTime::AKST)));
36100 }
36101 {
36102 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int(static_cast<int >(wxDateTime::AKDT)));
36103 }
36104 {
36105 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int(static_cast<int >(wxDateTime::A_WST)));
36106 }
36107 {
36108 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int(static_cast<int >(wxDateTime::A_CST)));
36109 }
36110 {
36111 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int(static_cast<int >(wxDateTime::A_EST)));
36112 }
36113 {
36114 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int(static_cast<int >(wxDateTime::A_ESST)));
36115 }
36116 {
36117 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int(static_cast<int >(wxDateTime::UTC)));
36118 }
36119 {
36120 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int(static_cast<int >(wxDateTime::Gregorian)));
36121 }
36122 {
36123 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int(static_cast<int >(wxDateTime::Julian)));
36124 }
36125 {
36126 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Unknown)));
36127 }
36128 {
36129 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Standard)));
36130 }
36131 {
36132 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Alaska)));
36133 }
36134 {
36135 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Albania)));
36136 }
36137 {
36138 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria)));
36139 }
36140 {
36141 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Brixen)));
36142 }
36143 {
36144 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Salzburg)));
36145 }
36146 {
36147 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Tyrol)));
36148 }
36149 {
36150 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Carinthia)));
36151 }
36152 {
36153 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Austria_Styria)));
36154 }
36155 {
36156 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Belgium)));
36157 }
36158 {
36159 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Bulgaria)));
36160 }
36161 {
36162 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Bulgaria_1)));
36163 }
36164 {
36165 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Bulgaria_2)));
36166 }
36167 {
36168 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Bulgaria_3)));
36169 }
36170 {
36171 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Canada)));
36172 }
36173 {
36174 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int(static_cast<int >(wxDateTime::Gr_China)));
36175 }
36176 {
36177 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int(static_cast<int >(wxDateTime::Gr_China_1)));
36178 }
36179 {
36180 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int(static_cast<int >(wxDateTime::Gr_China_2)));
36181 }
36182 {
36183 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Czechoslovakia)));
36184 }
36185 {
36186 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Denmark)));
36187 }
36188 {
36189 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Egypt)));
36190 }
36191 {
36192 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Estonia)));
36193 }
36194 {
36195 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Finland)));
36196 }
36197 {
36198 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int(static_cast<int >(wxDateTime::Gr_France)));
36199 }
36200 {
36201 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int(static_cast<int >(wxDateTime::Gr_France_Alsace)));
36202 }
36203 {
36204 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int(static_cast<int >(wxDateTime::Gr_France_Lorraine)));
36205 }
36206 {
36207 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int(static_cast<int >(wxDateTime::Gr_France_Strasbourg)));
36208 }
36209 {
36210 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Germany)));
36211 }
36212 {
36213 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Germany_Catholic)));
36214 }
36215 {
36216 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Germany_Prussia)));
36217 }
36218 {
36219 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Germany_Protestant)));
36220 }
36221 {
36222 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int(static_cast<int >(wxDateTime::Gr_GreatBritain)));
36223 }
36224 {
36225 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Greece)));
36226 }
36227 {
36228 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Hungary)));
36229 }
36230 {
36231 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Ireland)));
36232 }
36233 {
36234 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Italy)));
36235 }
36236 {
36237 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Japan)));
36238 }
36239 {
36240 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Japan_1)));
36241 }
36242 {
36243 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Japan_2)));
36244 }
36245 {
36246 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Japan_3)));
36247 }
36248 {
36249 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Latvia)));
36250 }
36251 {
36252 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Lithuania)));
36253 }
36254 {
36255 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Luxemburg)));
36256 }
36257 {
36258 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands)));
36259 }
36260 {
36261 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands_Groningen)));
36262 }
36263 {
36264 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands_Gelderland)));
36265 }
36266 {
36267 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands_Utrecht)));
36268 }
36269 {
36270 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Netherlands_Friesland)));
36271 }
36272 {
36273 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Norway)));
36274 }
36275 {
36276 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Poland)));
36277 }
36278 {
36279 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Portugal)));
36280 }
36281 {
36282 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Romania)));
36283 }
36284 {
36285 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Russia)));
36286 }
36287 {
36288 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Scotland)));
36289 }
36290 {
36291 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Spain)));
36292 }
36293 {
36294 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Sweden)));
36295 }
36296 {
36297 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Switzerland)));
36298 }
36299 {
36300 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Switzerland_Catholic)));
36301 }
36302 {
36303 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Switzerland_Protestant)));
36304 }
36305 {
36306 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Turkey)));
36307 }
36308 {
36309 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int(static_cast<int >(wxDateTime::Gr_USA)));
36310 }
36311 {
36312 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Wales)));
36313 }
36314 {
36315 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int(static_cast<int >(wxDateTime::Gr_Yugoslavia)));
36316 }
36317 {
36318 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int(static_cast<int >(wxDateTime::Country_Unknown)));
36319 }
36320 {
36321 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int(static_cast<int >(wxDateTime::Country_Default)));
36322 }
36323 {
36324 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int(static_cast<int >(wxDateTime::Country_WesternEurope_Start)));
36325 }
36326 {
36327 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int(static_cast<int >(wxDateTime::Country_EEC)));
36328 }
36329 {
36330 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int(static_cast<int >(wxDateTime::France)));
36331 }
36332 {
36333 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int(static_cast<int >(wxDateTime::Germany)));
36334 }
36335 {
36336 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int(static_cast<int >(wxDateTime::UK)));
36337 }
36338 {
36339 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int(static_cast<int >(wxDateTime::Country_WesternEurope_End)));
36340 }
36341 {
36342 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int(static_cast<int >(wxDateTime::Russia)));
36343 }
36344 {
36345 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int(static_cast<int >(wxDateTime::USA)));
36346 }
36347 {
36348 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int(static_cast<int >(wxDateTime::Jan)));
36349 }
36350 {
36351 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int(static_cast<int >(wxDateTime::Feb)));
36352 }
36353 {
36354 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int(static_cast<int >(wxDateTime::Mar)));
36355 }
36356 {
36357 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int(static_cast<int >(wxDateTime::Apr)));
36358 }
36359 {
36360 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int(static_cast<int >(wxDateTime::May)));
36361 }
36362 {
36363 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int(static_cast<int >(wxDateTime::Jun)));
36364 }
36365 {
36366 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int(static_cast<int >(wxDateTime::Jul)));
36367 }
36368 {
36369 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int(static_cast<int >(wxDateTime::Aug)));
36370 }
36371 {
36372 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int(static_cast<int >(wxDateTime::Sep)));
36373 }
36374 {
36375 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int(static_cast<int >(wxDateTime::Oct)));
36376 }
36377 {
36378 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int(static_cast<int >(wxDateTime::Nov)));
36379 }
36380 {
36381 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int(static_cast<int >(wxDateTime::Dec)));
36382 }
36383 {
36384 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int(static_cast<int >(wxDateTime::Inv_Month)));
36385 }
36386 {
36387 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int(static_cast<int >(wxDateTime::Sun)));
36388 }
36389 {
36390 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int(static_cast<int >(wxDateTime::Mon)));
36391 }
36392 {
36393 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int(static_cast<int >(wxDateTime::Tue)));
36394 }
36395 {
36396 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int(static_cast<int >(wxDateTime::Wed)));
36397 }
36398 {
36399 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int(static_cast<int >(wxDateTime::Thu)));
36400 }
36401 {
36402 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int(static_cast<int >(wxDateTime::Fri)));
36403 }
36404 {
36405 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int(static_cast<int >(wxDateTime::Sat)));
36406 }
36407 {
36408 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int(static_cast<int >(wxDateTime::Inv_WeekDay)));
36409 }
36410 {
36411 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int(static_cast<int >(wxDateTime::Inv_Year)));
36412 }
36413 {
36414 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int(static_cast<int >(wxDateTime::Name_Full)));
36415 }
36416 {
36417 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int(static_cast<int >(wxDateTime::Name_Abbr)));
36418 }
36419 {
36420 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int(static_cast<int >(wxDateTime::Default_First)));
36421 }
36422 {
36423 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int(static_cast<int >(wxDateTime::Monday_First)));
36424 }
36425 {
36426 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int(static_cast<int >(wxDateTime::Sunday_First)));
36427 }
36428 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
36429 {
36430 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int(static_cast<int >(wxDF_INVALID)));
36431 }
36432 {
36433 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int(static_cast<int >(wxDF_TEXT)));
36434 }
36435 {
36436 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int(static_cast<int >(wxDF_BITMAP)));
36437 }
36438 {
36439 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int(static_cast<int >(wxDF_METAFILE)));
36440 }
36441 {
36442 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int(static_cast<int >(wxDF_SYLK)));
36443 }
36444 {
36445 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int(static_cast<int >(wxDF_DIF)));
36446 }
36447 {
36448 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int(static_cast<int >(wxDF_TIFF)));
36449 }
36450 {
36451 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int(static_cast<int >(wxDF_OEMTEXT)));
36452 }
36453 {
36454 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int(static_cast<int >(wxDF_DIB)));
36455 }
36456 {
36457 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int(static_cast<int >(wxDF_PALETTE)));
36458 }
36459 {
36460 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int(static_cast<int >(wxDF_PENDATA)));
36461 }
36462 {
36463 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int(static_cast<int >(wxDF_RIFF)));
36464 }
36465 {
36466 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int(static_cast<int >(wxDF_WAVE)));
36467 }
36468 {
36469 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int(static_cast<int >(wxDF_UNICODETEXT)));
36470 }
36471 {
36472 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int(static_cast<int >(wxDF_ENHMETAFILE)));
36473 }
36474 {
36475 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int(static_cast<int >(wxDF_FILENAME)));
36476 }
36477 {
36478 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int(static_cast<int >(wxDF_LOCALE)));
36479 }
36480 {
36481 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int(static_cast<int >(wxDF_PRIVATE)));
36482 }
36483 {
36484 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int(static_cast<int >(wxDF_HTML)));
36485 }
36486 {
36487 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int(static_cast<int >(wxDF_MAX)));
36488 }
36489 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
36490 {
36491 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int(static_cast<int >(wxDataObject::Get)));
36492 }
36493 {
36494 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int(static_cast<int >(wxDataObject::Set)));
36495 }
36496 {
36497 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int(static_cast<int >(wxDataObject::Both)));
36498 }
36499 {
36500 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int(static_cast<int >(wxDrag_CopyOnly)));
36501 }
36502 {
36503 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int(static_cast<int >(wxDrag_AllowMove)));
36504 }
36505 {
36506 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int(static_cast<int >(wxDrag_DefaultMove)));
36507 }
36508 {
36509 PyDict_SetItemString(d,"DragError", SWIG_From_int(static_cast<int >(wxDragError)));
36510 }
36511 {
36512 PyDict_SetItemString(d,"DragNone", SWIG_From_int(static_cast<int >(wxDragNone)));
36513 }
36514 {
36515 PyDict_SetItemString(d,"DragCopy", SWIG_From_int(static_cast<int >(wxDragCopy)));
36516 }
36517 {
36518 PyDict_SetItemString(d,"DragMove", SWIG_From_int(static_cast<int >(wxDragMove)));
36519 }
36520 {
36521 PyDict_SetItemString(d,"DragLink", SWIG_From_int(static_cast<int >(wxDragLink)));
36522 }
36523 {
36524 PyDict_SetItemString(d,"DragCancel", SWIG_From_int(static_cast<int >(wxDragCancel)));
36525 }
36526
36527 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
36528 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
36529 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
36530 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
36531
36532 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
36533 }
36534