]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
updated with new stuff
[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.24
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 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxFileHistory swig_types[2]
1344 #define SWIGTYPE_p_wxLog swig_types[3]
1345 #define SWIGTYPE_p_wxMenu swig_types[4]
1346 #define SWIGTYPE_p_wxEvent swig_types[5]
1347 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[6]
1348 #define SWIGTYPE_p_wxConfigBase swig_types[7]
1349 #define SWIGTYPE_p_wxDisplay swig_types[8]
1350 #define SWIGTYPE_p_wxFileType swig_types[9]
1351 #define SWIGTYPE_p_wxLogGui swig_types[10]
1352 #define SWIGTYPE_p_wxFont swig_types[11]
1353 #define SWIGTYPE_p_wxDataFormat swig_types[12]
1354 #define SWIGTYPE_p_wxTimerEvent swig_types[13]
1355 #define SWIGTYPE_p_wxCaret swig_types[14]
1356 #define SWIGTYPE_ptrdiff_t swig_types[15]
1357 #define SWIGTYPE_std__ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_p_int swig_types[17]
1359 #define SWIGTYPE_p_wxSize swig_types[18]
1360 #define SWIGTYPE_p_wxClipboard swig_types[19]
1361 #define SWIGTYPE_p_wxStopWatch swig_types[20]
1362 #define SWIGTYPE_p_wxClipboardLocker swig_types[21]
1363 #define SWIGTYPE_p_wxIcon swig_types[22]
1364 #define SWIGTYPE_p_wxLogStderr swig_types[23]
1365 #define SWIGTYPE_p_wxLogTextCtrl swig_types[24]
1366 #define SWIGTYPE_p_wxTextCtrl swig_types[25]
1367 #define SWIGTYPE_p_wxBusyCursor swig_types[26]
1368 #define SWIGTYPE_p_wxBitmapDataObject swig_types[27]
1369 #define SWIGTYPE_p_wxTextDataObject swig_types[28]
1370 #define SWIGTYPE_p_wxDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxPyTextDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxFileDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxCustomDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxURLDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxMetafileDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxSound swig_types[36]
1378 #define SWIGTYPE_p_wxTimerRunner swig_types[37]
1379 #define SWIGTYPE_p_wxLogWindow swig_types[38]
1380 #define SWIGTYPE_p_wxTimeSpan swig_types[39]
1381 #define SWIGTYPE_p_wxArrayString swig_types[40]
1382 #define SWIGTYPE_p_wxWindowDisabler swig_types[41]
1383 #define SWIGTYPE_p_form_ops_t swig_types[42]
1384 #define SWIGTYPE_p_wxToolTip swig_types[43]
1385 #define SWIGTYPE_p_wxDataObjectComposite swig_types[44]
1386 #define SWIGTYPE_p_wxFileConfig swig_types[45]
1387 #define SWIGTYPE_p_wxSystemSettings swig_types[46]
1388 #define SWIGTYPE_p_wxVideoMode swig_types[47]
1389 #define SWIGTYPE_p_wxDataObjectSimple swig_types[48]
1390 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[49]
1391 #define SWIGTYPE_p_wxDuplexMode swig_types[50]
1392 #define SWIGTYPE_p_wxEvtHandler swig_types[51]
1393 #define SWIGTYPE_p_wxRect swig_types[52]
1394 #define SWIGTYPE_p_char swig_types[53]
1395 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[54]
1396 #define SWIGTYPE_p_wxStandardPaths swig_types[55]
1397 #define SWIGTYPE_p_wxFileTypeInfo swig_types[56]
1398 #define SWIGTYPE_p_wxFrame swig_types[57]
1399 #define SWIGTYPE_p_wxTimer swig_types[58]
1400 #define SWIGTYPE_p_wxPaperSize swig_types[59]
1401 #define SWIGTYPE_p_wxMimeTypesManager swig_types[60]
1402 #define SWIGTYPE_p_wxPyArtProvider swig_types[61]
1403 #define SWIGTYPE_p_wxPyTipProvider swig_types[62]
1404 #define SWIGTYPE_p_wxTipProvider swig_types[63]
1405 #define SWIGTYPE_p_wxJoystick swig_types[64]
1406 #define SWIGTYPE_p_wxSystemOptions swig_types[65]
1407 #define SWIGTYPE_p_wxPoint swig_types[66]
1408 #define SWIGTYPE_p_wxJoystickEvent swig_types[67]
1409 #define SWIGTYPE_p_wxCursor swig_types[68]
1410 #define SWIGTYPE_p_wxObject swig_types[69]
1411 #define SWIGTYPE_p_wxOutputStream swig_types[70]
1412 #define SWIGTYPE_p_wxDateTime swig_types[71]
1413 #define SWIGTYPE_p_wxPyDropSource swig_types[72]
1414 #define SWIGTYPE_p_unsigned_long swig_types[73]
1415 #define SWIGTYPE_p_wxKillError swig_types[74]
1416 #define SWIGTYPE_p_wxWindow swig_types[75]
1417 #define SWIGTYPE_p_wxString swig_types[76]
1418 #define SWIGTYPE_p_wxPyProcess swig_types[77]
1419 #define SWIGTYPE_p_wxBitmap swig_types[78]
1420 #define SWIGTYPE_p_wxConfig swig_types[79]
1421 #define SWIGTYPE_unsigned_int swig_types[80]
1422 #define SWIGTYPE_p_unsigned_int swig_types[81]
1423 #define SWIGTYPE_p_unsigned_char swig_types[82]
1424 #define SWIGTYPE_p_wxChar swig_types[83]
1425 #define SWIGTYPE_p_wxBusyInfo swig_types[84]
1426 #define SWIGTYPE_p_wxPyDropTarget swig_types[85]
1427 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[86]
1428 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxProcessEvent swig_types[88]
1430 #define SWIGTYPE_p_wxPyLog swig_types[89]
1431 #define SWIGTYPE_p_wxLogNull swig_types[90]
1432 #define SWIGTYPE_p_wxColour swig_types[91]
1433 #define SWIGTYPE_p_wxPyTimer swig_types[92]
1434 #define SWIGTYPE_p_wxConfigPathChanger swig_types[93]
1435 #define SWIGTYPE_p_wxDateSpan swig_types[94]
1436 static swig_type_info *swig_types[96];
1437
1438 /* -------- TYPES TABLE (END) -------- */
1439
1440
1441 /*-----------------------------------------------
1442 @(target):= _misc_.so
1443 ------------------------------------------------*/
1444 #define SWIG_init init_misc_
1445
1446 #define SWIG_name "_misc_"
1447
1448 #include "wx/wxPython/wxPython.h"
1449 #include "wx/wxPython/pyclasses.h"
1450 #include "wx/wxPython/pyistream.h"
1451
1452 static const wxString wxPyEmptyString(wxEmptyString);
1453
1454
1455
1456 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1457 #define SWIG_From_int PyInt_FromLong
1458 /*@@*/
1459
1460
1461 #include <limits.h>
1462
1463
1464 SWIGINTERN int
1465 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1466 const char *errmsg)
1467 {
1468 if (value < min_value) {
1469 if (errmsg) {
1470 PyErr_Format(PyExc_OverflowError,
1471 "value %ld is less than '%s' minimum %ld",
1472 value, errmsg, min_value);
1473 }
1474 return 0;
1475 } else if (value > max_value) {
1476 if (errmsg) {
1477 PyErr_Format(PyExc_OverflowError,
1478 "value %ld is greater than '%s' maximum %ld",
1479 value, errmsg, max_value);
1480 }
1481 return 0;
1482 }
1483 return 1;
1484 }
1485
1486
1487 SWIGINTERN int
1488 SWIG_AsVal_long(PyObject* obj, long* val)
1489 {
1490 if (PyNumber_Check(obj)) {
1491 if (val) *val = PyInt_AsLong(obj);
1492 return 1;
1493 }
1494 else {
1495 SWIG_type_error("number", obj);
1496 }
1497 return 0;
1498 }
1499
1500
1501 #if INT_MAX != LONG_MAX
1502 SWIGINTERN int
1503 SWIG_AsVal_int(PyObject *obj, int *val)
1504 {
1505 const char* errmsg = val ? "int" : (char*)0;
1506 long v;
1507 if (SWIG_AsVal_long(obj, &v)) {
1508 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1509 if (val) *val = (int)(v);
1510 return 1;
1511 } else {
1512 return 0;
1513 }
1514 } else {
1515 PyErr_Clear();
1516 }
1517 if (val) {
1518 SWIG_type_error(errmsg, obj);
1519 }
1520 return 0;
1521 }
1522 #else
1523 SWIGINTERNSHORT int
1524 SWIG_AsVal_int(PyObject *obj, int *val)
1525 {
1526 return SWIG_AsVal_long(obj,(long*)val);
1527 }
1528 #endif
1529
1530
1531 SWIGINTERNSHORT int
1532 SWIG_As_int(PyObject* obj)
1533 {
1534 int v;
1535 if (!SWIG_AsVal_int(obj, &v)) {
1536 /*
1537 this is needed to make valgrind/purify happier.
1538 */
1539 memset((void*)&v, 0, sizeof(int));
1540 }
1541 return v;
1542 }
1543
1544
1545 SWIGINTERNSHORT int
1546 SWIG_Check_int(PyObject* obj)
1547 {
1548 return SWIG_AsVal_int(obj, (int*)0);
1549 }
1550
1551 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1552
1553 #include <wx/stockitem.h>
1554
1555 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1556 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1557 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1558
1559 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1560 #define SWIG_From_long PyInt_FromLong
1561 /*@@*/
1562
1563
1564 SWIGINTERNSHORT long
1565 SWIG_As_long(PyObject* obj)
1566 {
1567 long v;
1568 if (!SWIG_AsVal_long(obj, &v)) {
1569 /*
1570 this is needed to make valgrind/purify happier.
1571 */
1572 memset((void*)&v, 0, sizeof(long));
1573 }
1574 return v;
1575 }
1576
1577
1578 SWIGINTERNSHORT int
1579 SWIG_Check_long(PyObject* obj)
1580 {
1581 return SWIG_AsVal_long(obj, (long*)0);
1582 }
1583
1584
1585 SWIGINTERN int
1586 SWIG_AsVal_bool(PyObject *obj, bool *val)
1587 {
1588 if (obj == Py_True) {
1589 if (val) *val = true;
1590 return 1;
1591 }
1592 if (obj == Py_False) {
1593 if (val) *val = false;
1594 return 1;
1595 }
1596 int res = 0;
1597 if (SWIG_AsVal_int(obj, &res)) {
1598 if (val) *val = res ? true : false;
1599 return 1;
1600 } else {
1601 PyErr_Clear();
1602 }
1603 if (val) {
1604 SWIG_type_error("bool", obj);
1605 }
1606 return 0;
1607 }
1608
1609
1610 SWIGINTERNSHORT bool
1611 SWIG_As_bool(PyObject* obj)
1612 {
1613 bool v;
1614 if (!SWIG_AsVal_bool(obj, &v)) {
1615 /*
1616 this is needed to make valgrind/purify happier.
1617 */
1618 memset((void*)&v, 0, sizeof(bool));
1619 }
1620 return v;
1621 }
1622
1623
1624 SWIGINTERNSHORT int
1625 SWIG_Check_bool(PyObject* obj)
1626 {
1627 return SWIG_AsVal_bool(obj, (bool*)0);
1628 }
1629
1630
1631 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1632 PyObject* o2;
1633 PyObject* o3;
1634
1635 if (!target) {
1636 target = o;
1637 } else if (target == Py_None) {
1638 Py_DECREF(Py_None);
1639 target = o;
1640 } else {
1641 if (!PyTuple_Check(target)) {
1642 o2 = target;
1643 target = PyTuple_New(1);
1644 PyTuple_SetItem(target, 0, o2);
1645 }
1646 o3 = PyTuple_New(1);
1647 PyTuple_SetItem(o3, 0, o);
1648
1649 o2 = target;
1650 target = PySequence_Concat(o2, o3);
1651 Py_DECREF(o2);
1652 Py_DECREF(o3);
1653 }
1654 return target;
1655 }
1656
1657
1658
1659 long wxGetFreeMemory()
1660 { wxPyRaiseNotImplemented(); return 0; }
1661
1662
1663 SWIGINTERN int
1664 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1665 {
1666 long v = 0;
1667 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1668 SWIG_type_error("unsigned number", obj);
1669 }
1670 else if (val)
1671 *val = (unsigned long)v;
1672 return 1;
1673 }
1674
1675
1676 SWIGINTERNSHORT unsigned long
1677 SWIG_As_unsigned_SS_long(PyObject* obj)
1678 {
1679 unsigned long v;
1680 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1681 /*
1682 this is needed to make valgrind/purify happier.
1683 */
1684 memset((void*)&v, 0, sizeof(unsigned long));
1685 }
1686 return v;
1687 }
1688
1689
1690 SWIGINTERNSHORT int
1691 SWIG_Check_unsigned_SS_long(PyObject* obj)
1692 {
1693 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1694 }
1695
1696
1697 SWIGINTERNSHORT PyObject*
1698 SWIG_From_unsigned_SS_long(unsigned long value)
1699 {
1700 return (value > LONG_MAX) ?
1701 PyLong_FromUnsignedLong(value)
1702 : PyInt_FromLong((long)(value));
1703 }
1704
1705
1706 void wxWakeUpMainThread() {}
1707
1708
1709 bool wxThread_IsMain() {
1710 #ifdef WXP_WITH_THREAD
1711 return wxThread::IsMain();
1712 #else
1713 return true;
1714 #endif
1715 }
1716
1717
1718 int wxCaret_GetBlinkTime() {
1719 return wxCaret::GetBlinkTime();
1720 }
1721
1722 void wxCaret_SetBlinkTime(int milliseconds) {
1723 wxCaret::SetBlinkTime(milliseconds);
1724 }
1725
1726
1727 #include <wx/snglinst.h>
1728
1729
1730 #include <wx/tipdlg.h>
1731
1732
1733 class wxPyTipProvider : public wxTipProvider {
1734 public:
1735 wxPyTipProvider(size_t currentTip)
1736 : wxTipProvider(currentTip) {}
1737
1738 DEC_PYCALLBACK_STRING__pure(GetTip);
1739 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1740 PYPRIVATE;
1741 };
1742
1743 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1744 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1745
1746
1747 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1748
1749 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1750
1751 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1752 : wxTimer(owner, id)
1753 {
1754 if (owner == NULL) SetOwner(this);
1755 }
1756
1757
1758 void wxPyTimer::Notify() {
1759 bool found;
1760 bool blocked = wxPyBeginBlockThreads();
1761 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1762 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1763 wxPyEndBlockThreads(blocked);
1764 if (! found)
1765 wxTimer::Notify();
1766 }
1767 void wxPyTimer::base_Notify() {
1768 wxTimer::Notify();
1769 }
1770
1771
1772
1773 SWIGINTERN PyObject *
1774 SWIG_FromCharPtr(const char* cptr)
1775 {
1776 if (cptr) {
1777 size_t size = strlen(cptr);
1778 if (size > INT_MAX) {
1779 return SWIG_NewPointerObj((char*)(cptr),
1780 SWIG_TypeQuery("char *"), 0);
1781 } else {
1782 if (size != 0) {
1783 return PyString_FromStringAndSize(cptr, size);
1784 } else {
1785 return PyString_FromString(cptr);
1786 }
1787 }
1788 }
1789 Py_INCREF(Py_None);
1790 return Py_None;
1791 }
1792
1793
1794 SWIGINTERNSHORT int
1795 SWIG_CheckUnsignedLongInRange(unsigned long value,
1796 unsigned long max_value,
1797 const char *errmsg)
1798 {
1799 if (value > max_value) {
1800 if (errmsg) {
1801 PyErr_Format(PyExc_OverflowError,
1802 "value %lu is greater than '%s' minimum %lu",
1803 value, errmsg, max_value);
1804 }
1805 return 0;
1806 }
1807 return 1;
1808 }
1809
1810
1811 #if UINT_MAX != ULONG_MAX
1812 SWIGINTERN int
1813 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1814 {
1815 const char* errmsg = val ? "unsigned int" : (char*)0;
1816 unsigned long v;
1817 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1818 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1819 if (val) *val = (unsigned int)(v);
1820 return 1;
1821 }
1822 } else {
1823 PyErr_Clear();
1824 }
1825 if (val) {
1826 SWIG_type_error(errmsg, obj);
1827 }
1828 return 0;
1829 }
1830 #else
1831 SWIGINTERNSHORT unsigned int
1832 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1833 {
1834 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1835 }
1836 #endif
1837
1838
1839 SWIGINTERNSHORT unsigned int
1840 SWIG_As_unsigned_SS_int(PyObject* obj)
1841 {
1842 unsigned int v;
1843 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1844 /*
1845 this is needed to make valgrind/purify happier.
1846 */
1847 memset((void*)&v, 0, sizeof(unsigned int));
1848 }
1849 return v;
1850 }
1851
1852
1853 SWIGINTERNSHORT int
1854 SWIG_Check_unsigned_SS_int(PyObject* obj)
1855 {
1856 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1857 }
1858
1859 static wxString Log_TimeStamp(){
1860 wxString msg;
1861 wxLog::TimeStamp(&msg);
1862 return msg;
1863 }
1864 static void wxLog_Destroy(wxLog *self){ delete self; }
1865 // Make somce wrappers that double any % signs so they are 'escaped'
1866 void wxPyLogFatalError(const wxString& msg)
1867 {
1868 wxString m(msg);
1869 m.Replace(wxT("%"), wxT("%%"));
1870 wxLogFatalError(m);
1871 }
1872
1873 void wxPyLogError(const wxString& msg)
1874 {
1875 wxString m(msg);
1876 m.Replace(wxT("%"), wxT("%%"));
1877 wxLogError(m);
1878 }
1879
1880 void wxPyLogWarning(const wxString& msg)
1881 {
1882 wxString m(msg);
1883 m.Replace(wxT("%"), wxT("%%"));
1884 wxLogWarning(m);
1885 }
1886
1887 void wxPyLogMessage(const wxString& msg)
1888 {
1889 wxString m(msg);
1890 m.Replace(wxT("%"), wxT("%%"));
1891 wxLogMessage(m);
1892 }
1893
1894 void wxPyLogInfo(const wxString& msg)
1895 {
1896 wxString m(msg);
1897 m.Replace(wxT("%"), wxT("%%"));
1898 wxLogInfo(m);
1899 }
1900
1901 void wxPyLogDebug(const wxString& msg)
1902 {
1903 wxString m(msg);
1904 m.Replace(wxT("%"), wxT("%%"));
1905 wxLogDebug(m);
1906 }
1907
1908 void wxPyLogVerbose(const wxString& msg)
1909 {
1910 wxString m(msg);
1911 m.Replace(wxT("%"), wxT("%%"));
1912 wxLogVerbose(m);
1913 }
1914
1915 void wxPyLogStatus(const wxString& msg)
1916 {
1917 wxString m(msg);
1918 m.Replace(wxT("%"), wxT("%%"));
1919 wxLogStatus(m);
1920 }
1921
1922 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
1923 {
1924 wxString m(msg);
1925 m.Replace(wxT("%"), wxT("%%"));
1926 wxLogStatus(pFrame, m);
1927 }
1928
1929 void wxPyLogSysError(const wxString& msg)
1930 {
1931 wxString m(msg);
1932 m.Replace(wxT("%"), wxT("%%"));
1933 wxLogSysError(m);
1934 }
1935
1936 void wxPyLogGeneric(unsigned long level, const wxString& msg)
1937 {
1938 wxString m(msg);
1939 m.Replace(wxT("%"), wxT("%%"));
1940 wxLogGeneric(level, m);
1941 }
1942
1943 void wxPyLogTrace(unsigned long mask, const wxString& msg)
1944 {
1945 wxString m(msg);
1946 m.Replace(wxT("%"), wxT("%%"));
1947 wxLogTrace(mask, m);
1948 }
1949
1950 void wxPyLogTrace(const wxString& mask, const wxString& msg)
1951 {
1952 wxString m(msg);
1953 m.Replace(wxT("%"), wxT("%%"));
1954 wxLogTrace(mask, m);
1955 }
1956
1957
1958
1959 // A wxLog class that can be derived from in wxPython
1960 class wxPyLog : public wxLog {
1961 public:
1962 wxPyLog() : wxLog() {}
1963
1964 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
1965 bool found;
1966 bool blocked = wxPyBeginBlockThreads();
1967 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
1968 PyObject* s = wx2PyString(szString);
1969 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
1970 Py_DECREF(s);
1971 }
1972 wxPyEndBlockThreads(blocked);
1973 if (! found)
1974 wxLog::DoLog(level, szString, t);
1975 }
1976
1977 virtual void DoLogString(const wxChar *szString, time_t t) {
1978 bool found;
1979 bool blocked = wxPyBeginBlockThreads();
1980 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
1981 PyObject* s = wx2PyString(szString);
1982 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
1983 Py_DECREF(s);
1984 }
1985 wxPyEndBlockThreads(blocked);
1986 if (! found)
1987 wxLog::DoLogString(szString, t);
1988 }
1989
1990 PYPRIVATE;
1991 };
1992
1993
1994
1995
1996 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
1997
1998
1999 #include <wx/joystick.h>
2000
2001
2002 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2003 // A C++ stub class for wxJoystick for platforms that don't have it.
2004 class wxJoystick : public wxObject {
2005 public:
2006 wxJoystick(int joystick = wxJOYSTICK1) {
2007 bool blocked = wxPyBeginBlockThreads();
2008 PyErr_SetString(PyExc_NotImplementedError,
2009 "wxJoystick is not available on this platform.");
2010 wxPyEndBlockThreads(blocked);
2011 }
2012 wxPoint GetPosition() { return wxPoint(-1,-1); }
2013 int GetZPosition() { return -1; }
2014 int GetButtonState() { return -1; }
2015 int GetPOVPosition() { return -1; }
2016 int GetPOVCTSPosition() { return -1; }
2017 int GetRudderPosition() { return -1; }
2018 int GetUPosition() { return -1; }
2019 int GetVPosition() { return -1; }
2020 int GetMovementThreshold() { return -1; }
2021 void SetMovementThreshold(int threshold) {}
2022
2023 bool IsOk(void) { return false; }
2024 int GetNumberJoysticks() { return -1; }
2025 int GetManufacturerId() { return -1; }
2026 int GetProductId() { return -1; }
2027 wxString GetProductName() { return wxEmptyString; }
2028 int GetXMin() { return -1; }
2029 int GetYMin() { return -1; }
2030 int GetZMin() { return -1; }
2031 int GetXMax() { return -1; }
2032 int GetYMax() { return -1; }
2033 int GetZMax() { return -1; }
2034 int GetNumberButtons() { return -1; }
2035 int GetNumberAxes() { return -1; }
2036 int GetMaxButtons() { return -1; }
2037 int GetMaxAxes() { return -1; }
2038 int GetPollingMin() { return -1; }
2039 int GetPollingMax() { return -1; }
2040 int GetRudderMin() { return -1; }
2041 int GetRudderMax() { return -1; }
2042 int GetUMin() { return -1; }
2043 int GetUMax() { return -1; }
2044 int GetVMin() { return -1; }
2045 int GetVMax() { return -1; }
2046
2047 bool HasRudder() { return false; }
2048 bool HasZ() { return false; }
2049 bool HasU() { return false; }
2050 bool HasV() { return false; }
2051 bool HasPOV() { return false; }
2052 bool HasPOV4Dir() { return false; }
2053 bool HasPOVCTS() { return false; }
2054
2055 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2056 bool ReleaseCapture() { return false; }
2057 };
2058 #endif
2059
2060
2061 #include <wx/sound.h>
2062
2063
2064 #if !wxUSE_SOUND
2065 // A C++ stub class for wxWave for platforms that don't have it.
2066 class wxSound : public wxObject
2067 {
2068 public:
2069 wxSound() {
2070 bool blocked = wxPyBeginBlockThreads();
2071 PyErr_SetString(PyExc_NotImplementedError,
2072 "wxSound is not available on this platform.");
2073 wxPyEndBlockThreads(blocked);
2074 }
2075 wxSound(const wxString&/*, bool*/) {
2076 bool blocked = wxPyBeginBlockThreads();
2077 PyErr_SetString(PyExc_NotImplementedError,
2078 "wxSound is not available on this platform.");
2079 wxPyEndBlockThreads(blocked);
2080 }
2081 wxSound(int, const wxByte*) {
2082 bool blocked = wxPyBeginBlockThreads();
2083 PyErr_SetString(PyExc_NotImplementedError,
2084 "wxSound is not available on this platform.");
2085 wxPyEndBlockThreads(blocked);
2086 }
2087
2088 ~wxSound() {};
2089
2090 bool Create(const wxString&/*, bool*/) { return false; }
2091 bool Create(int, const wxByte*) { return false; };
2092 bool IsOk() { return false; };
2093 bool Play(unsigned) const { return false; }
2094 static bool Play(const wxString&, unsigned) { return false; }
2095 static void Stop() {}
2096 };
2097
2098 #endif
2099
2100 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2101 if (fileName.Length() == 0)
2102 return new wxSound;
2103 else
2104 return new wxSound(fileName);
2105 }
2106 static wxSound *new_wxSound(PyObject *data){
2107 unsigned char* buffer; int size;
2108 wxSound *sound = NULL;
2109
2110 bool blocked = wxPyBeginBlockThreads();
2111 if (!PyArg_Parse(data, "t#", &buffer, &size))
2112 goto done;
2113 sound = new wxSound(size, buffer);
2114 done:
2115 wxPyEndBlockThreads(blocked);
2116 return sound;
2117 }
2118 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2119 #ifndef __WXMAC__
2120 unsigned char* buffer;
2121 int size;
2122 bool rv = false;
2123
2124 bool blocked = wxPyBeginBlockThreads();
2125 if (!PyArg_Parse(data, "t#", &buffer, &size))
2126 goto done;
2127 rv = self->Create(size, buffer);
2128 done:
2129 wxPyEndBlockThreads(blocked);
2130 return rv;
2131 #else
2132 bool blocked = wxPyBeginBlockThreads();
2133 PyErr_SetString(PyExc_NotImplementedError,
2134 "Create from data is not available on this platform.");
2135 wxPyEndBlockThreads(blocked);
2136 return false;
2137 #endif
2138 }
2139
2140 #include <wx/mimetype.h>
2141
2142 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2143 wxString str;
2144 if (self->GetMimeType(&str))
2145 return wx2PyString(str);
2146 else
2147 RETURN_NONE();
2148 }
2149 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2150 wxArrayString arr;
2151 if (self->GetMimeTypes(arr))
2152 return wxArrayString2PyList_helper(arr);
2153 else
2154 RETURN_NONE();
2155 }
2156 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2157 wxArrayString arr;
2158 if (self->GetExtensions(arr))
2159 return wxArrayString2PyList_helper(arr);
2160 else
2161 RETURN_NONE();
2162 }
2163 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2164 wxIconLocation loc;
2165 if (self->GetIcon(&loc))
2166 return new wxIcon(loc);
2167 else
2168 return NULL;
2169 }
2170 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2171 wxIconLocation loc;
2172 if (self->GetIcon(&loc)) {
2173 wxString iconFile = loc.GetFileName();
2174 int iconIndex = -1;
2175
2176
2177
2178 // Make a tuple and put the values in it
2179 bool blocked = wxPyBeginBlockThreads();
2180 PyObject* tuple = PyTuple_New(3);
2181 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2182 wxT("wxIcon"), true));
2183 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2184 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2185 wxPyEndBlockThreads(blocked);
2186 return tuple;
2187 }
2188 else
2189 RETURN_NONE();
2190 }
2191 static PyObject *wxFileType_GetDescription(wxFileType *self){
2192 wxString str;
2193 if (self->GetDescription(&str))
2194 return wx2PyString(str);
2195 else
2196 RETURN_NONE();
2197 }
2198 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2199 wxString str;
2200 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2201 return wx2PyString(str);
2202 else
2203 RETURN_NONE();
2204 }
2205 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2206 wxString str;
2207 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2208 return wx2PyString(str);
2209 else
2210 RETURN_NONE();
2211 }
2212 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2213 wxArrayString verbs;
2214 wxArrayString commands;
2215 if (self->GetAllCommands(&verbs, &commands,
2216 wxFileType::MessageParameters(filename, mimetype))) {
2217 bool blocked = wxPyBeginBlockThreads();
2218 PyObject* tuple = PyTuple_New(2);
2219 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2220 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2221 wxPyEndBlockThreads(blocked);
2222 return tuple;
2223 }
2224 else
2225 RETURN_NONE();
2226 }
2227 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2228 return wxFileType::ExpandCommand(command,
2229 wxFileType::MessageParameters(filename, mimetype));
2230 }
2231 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2232 wxArrayString arr;
2233 self->EnumAllFileTypes(arr);
2234 return wxArrayString2PyList_helper(arr);
2235 }
2236
2237 #include <wx/artprov.h>
2238
2239 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2240 static const wxString wxPyART_MENU(wxART_MENU);
2241 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2242 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2243 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2244 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2245 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2246 static const wxString wxPyART_OTHER(wxART_OTHER);
2247 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2248 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2249 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2250 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2251 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2252 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2253 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2254 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2255 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2256 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2257 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2258 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2259 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2260 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2261 static const wxString wxPyART_PRINT(wxART_PRINT);
2262 static const wxString wxPyART_HELP(wxART_HELP);
2263 static const wxString wxPyART_TIP(wxART_TIP);
2264 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2265 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2266 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2267 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2268 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2269 static const wxString wxPyART_CDROM(wxART_CDROM);
2270 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2271 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2272 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2273 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2274 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2275 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2276 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2277 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2278 static const wxString wxPyART_ERROR(wxART_ERROR);
2279 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2280 static const wxString wxPyART_WARNING(wxART_WARNING);
2281 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2282 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2283 // Python aware wxArtProvider
2284 class wxPyArtProvider : public wxArtProvider {
2285 public:
2286
2287 virtual wxBitmap CreateBitmap(const wxArtID& id,
2288 const wxArtClient& client,
2289 const wxSize& size) {
2290 wxBitmap rval = wxNullBitmap;
2291 bool blocked = wxPyBeginBlockThreads();
2292 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2293 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2294 PyObject* ro;
2295 wxBitmap* ptr;
2296 PyObject* s1, *s2;
2297 s1 = wx2PyString(id);
2298 s2 = wx2PyString(client);
2299 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2300 Py_DECREF(so);
2301 Py_DECREF(s1);
2302 Py_DECREF(s2);
2303 if (ro) {
2304 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2305 rval = *ptr;
2306 Py_DECREF(ro);
2307 }
2308 }
2309 wxPyEndBlockThreads(blocked);
2310 return rval;
2311 }
2312
2313 PYPRIVATE;
2314 };
2315
2316 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2317
2318
2319
2320 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2321 PyObject* ret = PyTuple_New(3);
2322 if (ret) {
2323 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2324 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2325 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2326 }
2327 return ret;
2328 }
2329
2330 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2331 bool cont;
2332 long index = 0;
2333 wxString value;
2334
2335 cont = self->GetFirstGroup(value, index);
2336 return __EnumerationHelper(cont, value, index);
2337 }
2338 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2339 bool cont;
2340 wxString value;
2341
2342 cont = self->GetNextGroup(value, index);
2343 return __EnumerationHelper(cont, value, index);
2344 }
2345 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2346 bool cont;
2347 long index = 0;
2348 wxString value;
2349
2350 cont = self->GetFirstEntry(value, index);
2351 return __EnumerationHelper(cont, value, index);
2352 }
2353 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2354 bool cont;
2355 wxString value;
2356
2357 cont = self->GetNextEntry(value, index);
2358 return __EnumerationHelper(cont, value, index);
2359 }
2360 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2361 long rv;
2362 self->Read(key, &rv, defaultVal);
2363 return rv;
2364 }
2365
2366 SWIGINTERN int
2367 SWIG_AsVal_double(PyObject *obj, double* val)
2368 {
2369 if (PyNumber_Check(obj)) {
2370 if (val) *val = PyFloat_AsDouble(obj);
2371 return 1;
2372 }
2373 else {
2374 SWIG_type_error("number", obj);
2375 }
2376 return 0;
2377 }
2378
2379
2380 SWIGINTERNSHORT double
2381 SWIG_As_double(PyObject* obj)
2382 {
2383 double v;
2384 if (!SWIG_AsVal_double(obj, &v)) {
2385 /*
2386 this is needed to make valgrind/purify happier.
2387 */
2388 memset((void*)&v, 0, sizeof(double));
2389 }
2390 return v;
2391 }
2392
2393
2394 SWIGINTERNSHORT int
2395 SWIG_Check_double(PyObject* obj)
2396 {
2397 return SWIG_AsVal_double(obj, (double*)0);
2398 }
2399
2400 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2401 double rv;
2402 self->Read(key, &rv, defaultVal);
2403 return rv;
2404 }
2405
2406 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2407 #define SWIG_From_double PyFloat_FromDouble
2408 /*@@*/
2409
2410 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2411 bool rv;
2412 self->Read(key, &rv, defaultVal);
2413 return rv;
2414 }
2415
2416 #include <wx/datetime.h>
2417
2418 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2419 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2420
2421 #define LOCAL_TZ wxDateTime::Local
2422
2423
2424 #if UINT_MAX < LONG_MAX
2425 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2426 #define SWIG_From_unsigned_SS_int SWIG_From_long
2427 /*@@*/
2428 #else
2429 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2430 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2431 /*@@*/
2432 #endif
2433
2434 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2435 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2436 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2437 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2438 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2439 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2440 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2441 return (*self < *other);
2442 }
2443 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2444 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2445 return (*self <= *other);
2446 }
2447 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2448 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2449 return (*self > *other);
2450 }
2451 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2452 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2453 return (*self >= *other);
2454 }
2455 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2456 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2457 return (*self == *other);
2458 }
2459 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2460 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2461 return (*self != *other);
2462 }
2463 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2464 const wxChar* rv;
2465 const wxChar* _date = date;
2466 rv = self->ParseRfc822Date(_date);
2467 if (rv == NULL) return -1;
2468 return rv - _date;
2469 }
2470 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2471 const wxChar* rv;
2472 const wxChar* _date = date;
2473 rv = self->ParseFormat(_date, format, dateDef);
2474 if (rv == NULL) return -1;
2475 return rv - _date;
2476 }
2477 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2478 const wxChar* rv;
2479 const wxChar* _datetime = datetime;
2480 rv = self->ParseDateTime(_datetime);
2481 if (rv == NULL) return -1;
2482 return rv - _datetime;
2483 }
2484 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2485 const wxChar* rv;
2486 const wxChar* _date = date;
2487 rv = self->ParseDate(_date);
2488 if (rv == NULL) return -1;
2489 return rv - _date;
2490 }
2491 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2492 const wxChar* rv;
2493 const wxChar* _time = time;
2494 rv = self->ParseTime(_time);
2495 if (rv == NULL) return -1;
2496 return rv - _time;
2497 }
2498 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2499 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2500 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2501 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2502 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2503 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2504 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2505 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2506 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2507 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2508 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2509 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2510 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2511 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2512 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2513 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2514
2515 #include <wx/dataobj.h>
2516
2517 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2518 size_t count = self->GetFormatCount(dir);
2519 wxDataFormat* formats = new wxDataFormat[count];
2520 self->GetAllFormats(formats, dir);
2521
2522 bool blocked = wxPyBeginBlockThreads();
2523 PyObject* list = PyList_New(count);
2524 for (size_t i=0; i<count; i++) {
2525 wxDataFormat* format = new wxDataFormat(formats[i]);
2526 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2527 PyList_Append(list, obj);
2528 Py_DECREF(obj);
2529 }
2530 wxPyEndBlockThreads(blocked);
2531 delete [] formats;
2532 return list;
2533 }
2534 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2535 PyObject* rval = NULL;
2536 size_t size = self->GetDataSize(format);
2537 bool blocked = wxPyBeginBlockThreads();
2538 if (size) {
2539 char* buf = new char[size];
2540 if (self->GetDataHere(format, buf))
2541 rval = PyString_FromStringAndSize(buf, size);
2542 delete [] buf;
2543 }
2544 if (! rval) {
2545 rval = Py_None;
2546 Py_INCREF(rval);
2547 }
2548 wxPyEndBlockThreads(blocked);
2549 return rval;
2550 }
2551 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2552 bool rval;
2553 bool blocked = wxPyBeginBlockThreads();
2554 if (PyString_Check(data)) {
2555 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2556 }
2557 else {
2558 // raise a TypeError if not a string
2559 PyErr_SetString(PyExc_TypeError, "String expected.");
2560 rval = false;
2561 }
2562 wxPyEndBlockThreads(blocked);
2563 return rval;
2564 }
2565 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2566 PyObject* rval = NULL;
2567 size_t size = self->GetDataSize();
2568 bool blocked = wxPyBeginBlockThreads();
2569 if (size) {
2570 char* buf = new char[size];
2571 if (self->GetDataHere(buf))
2572 rval = PyString_FromStringAndSize(buf, size);
2573 delete [] buf;
2574 }
2575 if (! rval) {
2576 rval = Py_None;
2577 Py_INCREF(rval);
2578 }
2579 wxPyEndBlockThreads(blocked);
2580 return rval;
2581 }
2582 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2583 bool rval;
2584 bool blocked = wxPyBeginBlockThreads();
2585 if (PyString_Check(data)) {
2586 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2587 }
2588 else {
2589 // raise a TypeError if not a string
2590 PyErr_SetString(PyExc_TypeError, "String expected.");
2591 rval = false;
2592 }
2593 wxPyEndBlockThreads(blocked);
2594 return rval;
2595 }
2596 // Create a new class for wxPython to use
2597 class wxPyDataObjectSimple : public wxDataObjectSimple {
2598 public:
2599 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2600 : wxDataObjectSimple(format) {}
2601
2602 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2603 bool GetDataHere(void *buf) const;
2604 bool SetData(size_t len, const void *buf) const;
2605 PYPRIVATE;
2606 };
2607
2608 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2609
2610 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2611 // We need to get the data for this object and write it to buf. I think
2612 // the best way to do this for wxPython is to have the Python method
2613 // return either a string or None and then act appropriately with the
2614 // C++ version.
2615
2616 bool rval = false;
2617 bool blocked = wxPyBeginBlockThreads();
2618 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2619 PyObject* ro;
2620 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2621 if (ro) {
2622 rval = (ro != Py_None && PyString_Check(ro));
2623 if (rval)
2624 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2625 Py_DECREF(ro);
2626 }
2627 }
2628 wxPyEndBlockThreads(blocked);
2629 return rval;
2630 }
2631
2632 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2633 // For this one we simply need to make a string from buf and len
2634 // and send it to the Python method.
2635 bool rval = false;
2636 bool blocked = wxPyBeginBlockThreads();
2637 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2638 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2639 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2640 Py_DECREF(data);
2641 }
2642 wxPyEndBlockThreads(blocked);
2643 return rval;
2644 }
2645
2646 // Create a new class for wxPython to use
2647 class wxPyTextDataObject : public wxTextDataObject {
2648 public:
2649 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2650 : wxTextDataObject(text) {}
2651
2652 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2653 DEC_PYCALLBACK_STRING__const(GetText);
2654 DEC_PYCALLBACK__STRING(SetText);
2655 PYPRIVATE;
2656 };
2657
2658 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2659 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2660 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2661
2662
2663 // Create a new class for wxPython to use
2664 class wxPyBitmapDataObject : public wxBitmapDataObject {
2665 public:
2666 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2667 : wxBitmapDataObject(bitmap) {}
2668
2669 wxBitmap GetBitmap() const;
2670 void SetBitmap(const wxBitmap& bitmap);
2671 PYPRIVATE;
2672 };
2673
2674 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2675 wxBitmap* rval = &wxNullBitmap;
2676 bool blocked = wxPyBeginBlockThreads();
2677 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2678 PyObject* ro;
2679 wxBitmap* ptr;
2680 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2681 if (ro) {
2682 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2683 rval = ptr;
2684 Py_DECREF(ro);
2685 }
2686 }
2687 wxPyEndBlockThreads(blocked);
2688 return *rval;
2689 }
2690
2691 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2692 bool blocked = wxPyBeginBlockThreads();
2693 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2694 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2695 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2696 Py_DECREF(bo);
2697 }
2698 wxPyEndBlockThreads(blocked);
2699 }
2700
2701 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2702 return new wxCustomDataObject(wxDataFormat(formatName));
2703 }
2704 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2705 bool rval;
2706 bool blocked = wxPyBeginBlockThreads();
2707 if (PyString_Check(data)) {
2708 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2709 }
2710 else {
2711 // raise a TypeError if not a string
2712 PyErr_SetString(PyExc_TypeError, "String expected.");
2713 rval = false;
2714 }
2715 wxPyEndBlockThreads(blocked);
2716 return rval;
2717 }
2718 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2719 PyObject* obj;
2720 bool blocked = wxPyBeginBlockThreads();
2721 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2722 wxPyEndBlockThreads(blocked);
2723 return obj;
2724 }
2725
2726 class wxMetafileDataObject : public wxDataObjectSimple
2727 {
2728 public:
2729 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
2730 };
2731
2732
2733 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2734
2735
2736 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2737 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2738 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2739 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2740 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2741
2742
2743 class wxPyTextDropTarget : public wxTextDropTarget {
2744 public:
2745 wxPyTextDropTarget() {}
2746
2747 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2748
2749 DEC_PYCALLBACK__(OnLeave);
2750 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2751 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2752 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2753 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2754
2755 PYPRIVATE;
2756 };
2757
2758 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2759 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2760 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2761 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2762 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2763 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2764
2765
2766
2767 class wxPyFileDropTarget : public wxFileDropTarget {
2768 public:
2769 wxPyFileDropTarget() {}
2770
2771 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2772
2773 DEC_PYCALLBACK__(OnLeave);
2774 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2775 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2776 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2777 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2778
2779 PYPRIVATE;
2780 };
2781
2782 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2783 const wxArrayString& filenames) {
2784 bool rval = false;
2785 bool blocked = wxPyBeginBlockThreads();
2786 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2787 PyObject* list = wxArrayString2PyList_helper(filenames);
2788 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2789 Py_DECREF(list);
2790 }
2791 wxPyEndBlockThreads(blocked);
2792 return rval;
2793 }
2794
2795
2796
2797 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2798 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2799 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2800 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2801 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2802
2803
2804
2805
2806 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2807
2808 #include <wx/display.h>
2809
2810 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2811 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2812
2813 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2814 #if !wxUSE_DISPLAY
2815 #include <wx/dynarray.h>
2816 #include <wx/vidmode.h>
2817
2818 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2819 #include "wx/arrimpl.cpp"
2820 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2821 const wxVideoMode wxDefaultVideoMode;
2822
2823 class wxDisplay
2824 {
2825 public:
2826 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2827 ~wxDisplay() {}
2828
2829 static size_t GetCount()
2830 { wxPyRaiseNotImplemented(); return 0; }
2831
2832 static int GetFromPoint(const wxPoint& pt)
2833 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2834 static int GetFromWindow(wxWindow *window)
2835 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2836
2837 virtual bool IsOk() const { return false; }
2838 virtual wxRect GetGeometry() const { wxRect r; return r; }
2839 virtual wxString GetName() const { return wxEmptyString; }
2840 bool IsPrimary() const { return false; }
2841
2842 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2843 { wxArrayVideoModes a; return a; }
2844
2845 virtual wxVideoMode GetCurrentMode() const
2846 { return wxDefaultVideoMode; }
2847
2848 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2849 { return false; }
2850
2851 void ResetMode() {}
2852 };
2853 #endif
2854
2855 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2856 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2857 PyObject* pyList = NULL;
2858 wxArrayVideoModes arr = self->GetModes(mode);
2859 bool blocked = wxPyBeginBlockThreads();
2860 pyList = PyList_New(0);
2861 for (int i=0; i < arr.GetCount(); i++) {
2862 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2863 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2864 PyList_Append(pyList, pyObj);
2865 Py_DECREF(pyObj);
2866 }
2867 wxPyEndBlockThreads(blocked);
2868 return pyList;
2869 }
2870
2871 #include <wx/stdpaths.h>
2872
2873 static wxStandardPaths *StandardPaths_Get(){
2874 return (wxStandardPaths*) &wxStandardPaths::Get();
2875 }
2876 #ifdef __cplusplus
2877 extern "C" {
2878 #endif
2879 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2880 PyObject *resultobj;
2881 wxSystemColour arg1 ;
2882 wxColour result;
2883 PyObject * obj0 = 0 ;
2884 char *kwnames[] = {
2885 (char *) "index", NULL
2886 };
2887
2888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2889 {
2890 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2891 if (SWIG_arg_fail(1)) SWIG_fail;
2892 }
2893 {
2894 if (!wxPyCheckForApp()) SWIG_fail;
2895 PyThreadState* __tstate = wxPyBeginAllowThreads();
2896 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2897
2898 wxPyEndAllowThreads(__tstate);
2899 if (PyErr_Occurred()) SWIG_fail;
2900 }
2901 {
2902 wxColour * resultptr;
2903 resultptr = new wxColour((wxColour &)(result));
2904 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
2905 }
2906 return resultobj;
2907 fail:
2908 return NULL;
2909 }
2910
2911
2912 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
2913 PyObject *resultobj;
2914 wxSystemFont arg1 ;
2915 wxFont result;
2916 PyObject * obj0 = 0 ;
2917 char *kwnames[] = {
2918 (char *) "index", NULL
2919 };
2920
2921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
2922 {
2923 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
2924 if (SWIG_arg_fail(1)) SWIG_fail;
2925 }
2926 {
2927 if (!wxPyCheckForApp()) SWIG_fail;
2928 PyThreadState* __tstate = wxPyBeginAllowThreads();
2929 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
2930
2931 wxPyEndAllowThreads(__tstate);
2932 if (PyErr_Occurred()) SWIG_fail;
2933 }
2934 {
2935 wxFont * resultptr;
2936 resultptr = new wxFont((wxFont &)(result));
2937 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
2938 }
2939 return resultobj;
2940 fail:
2941 return NULL;
2942 }
2943
2944
2945 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
2946 PyObject *resultobj;
2947 wxSystemMetric arg1 ;
2948 int result;
2949 PyObject * obj0 = 0 ;
2950 char *kwnames[] = {
2951 (char *) "index", NULL
2952 };
2953
2954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
2955 {
2956 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
2957 if (SWIG_arg_fail(1)) SWIG_fail;
2958 }
2959 {
2960 if (!wxPyCheckForApp()) SWIG_fail;
2961 PyThreadState* __tstate = wxPyBeginAllowThreads();
2962 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
2963
2964 wxPyEndAllowThreads(__tstate);
2965 if (PyErr_Occurred()) SWIG_fail;
2966 }
2967 {
2968 resultobj = SWIG_From_int((int)(result));
2969 }
2970 return resultobj;
2971 fail:
2972 return NULL;
2973 }
2974
2975
2976 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
2977 PyObject *resultobj;
2978 wxSystemFeature arg1 ;
2979 bool result;
2980 PyObject * obj0 = 0 ;
2981 char *kwnames[] = {
2982 (char *) "index", NULL
2983 };
2984
2985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
2986 {
2987 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
2988 if (SWIG_arg_fail(1)) SWIG_fail;
2989 }
2990 {
2991 if (!wxPyCheckForApp()) SWIG_fail;
2992 PyThreadState* __tstate = wxPyBeginAllowThreads();
2993 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
2994
2995 wxPyEndAllowThreads(__tstate);
2996 if (PyErr_Occurred()) SWIG_fail;
2997 }
2998 {
2999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3000 }
3001 return resultobj;
3002 fail:
3003 return NULL;
3004 }
3005
3006
3007 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3008 PyObject *resultobj;
3009 wxSystemScreenType result;
3010 char *kwnames[] = {
3011 NULL
3012 };
3013
3014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3015 {
3016 if (!wxPyCheckForApp()) SWIG_fail;
3017 PyThreadState* __tstate = wxPyBeginAllowThreads();
3018 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3019
3020 wxPyEndAllowThreads(__tstate);
3021 if (PyErr_Occurred()) SWIG_fail;
3022 }
3023 resultobj = SWIG_From_int((result));
3024 return resultobj;
3025 fail:
3026 return NULL;
3027 }
3028
3029
3030 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3031 PyObject *resultobj;
3032 wxSystemScreenType arg1 ;
3033 PyObject * obj0 = 0 ;
3034 char *kwnames[] = {
3035 (char *) "screen", NULL
3036 };
3037
3038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3039 {
3040 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3041 if (SWIG_arg_fail(1)) SWIG_fail;
3042 }
3043 {
3044 if (!wxPyCheckForApp()) SWIG_fail;
3045 PyThreadState* __tstate = wxPyBeginAllowThreads();
3046 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3047
3048 wxPyEndAllowThreads(__tstate);
3049 if (PyErr_Occurred()) SWIG_fail;
3050 }
3051 Py_INCREF(Py_None); resultobj = Py_None;
3052 return resultobj;
3053 fail:
3054 return NULL;
3055 }
3056
3057
3058 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3059 PyObject *obj;
3060 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3061 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3062 Py_INCREF(obj);
3063 return Py_BuildValue((char *)"");
3064 }
3065 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3066 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3067 return 1;
3068 }
3069
3070
3071 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3072 PyObject *pyobj;
3073
3074 {
3075 #if wxUSE_UNICODE
3076 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3077 #else
3078 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3079 #endif
3080 }
3081 return pyobj;
3082 }
3083
3084
3085 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3086 PyObject *resultobj;
3087 wxSystemOptions *result;
3088 char *kwnames[] = {
3089 NULL
3090 };
3091
3092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3093 {
3094 PyThreadState* __tstate = wxPyBeginAllowThreads();
3095 result = (wxSystemOptions *)new wxSystemOptions();
3096
3097 wxPyEndAllowThreads(__tstate);
3098 if (PyErr_Occurred()) SWIG_fail;
3099 }
3100 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3101 return resultobj;
3102 fail:
3103 return NULL;
3104 }
3105
3106
3107 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3108 PyObject *resultobj;
3109 wxString *arg1 = 0 ;
3110 wxString *arg2 = 0 ;
3111 bool temp1 = false ;
3112 bool temp2 = false ;
3113 PyObject * obj0 = 0 ;
3114 PyObject * obj1 = 0 ;
3115 char *kwnames[] = {
3116 (char *) "name",(char *) "value", NULL
3117 };
3118
3119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3120 {
3121 arg1 = wxString_in_helper(obj0);
3122 if (arg1 == NULL) SWIG_fail;
3123 temp1 = true;
3124 }
3125 {
3126 arg2 = wxString_in_helper(obj1);
3127 if (arg2 == NULL) SWIG_fail;
3128 temp2 = true;
3129 }
3130 {
3131 PyThreadState* __tstate = wxPyBeginAllowThreads();
3132 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3133
3134 wxPyEndAllowThreads(__tstate);
3135 if (PyErr_Occurred()) SWIG_fail;
3136 }
3137 Py_INCREF(Py_None); resultobj = Py_None;
3138 {
3139 if (temp1)
3140 delete arg1;
3141 }
3142 {
3143 if (temp2)
3144 delete arg2;
3145 }
3146 return resultobj;
3147 fail:
3148 {
3149 if (temp1)
3150 delete arg1;
3151 }
3152 {
3153 if (temp2)
3154 delete arg2;
3155 }
3156 return NULL;
3157 }
3158
3159
3160 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3161 PyObject *resultobj;
3162 wxString *arg1 = 0 ;
3163 int arg2 ;
3164 bool temp1 = false ;
3165 PyObject * obj0 = 0 ;
3166 PyObject * obj1 = 0 ;
3167 char *kwnames[] = {
3168 (char *) "name",(char *) "value", NULL
3169 };
3170
3171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3172 {
3173 arg1 = wxString_in_helper(obj0);
3174 if (arg1 == NULL) SWIG_fail;
3175 temp1 = true;
3176 }
3177 {
3178 arg2 = (int)(SWIG_As_int(obj1));
3179 if (SWIG_arg_fail(2)) SWIG_fail;
3180 }
3181 {
3182 PyThreadState* __tstate = wxPyBeginAllowThreads();
3183 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3184
3185 wxPyEndAllowThreads(__tstate);
3186 if (PyErr_Occurred()) SWIG_fail;
3187 }
3188 Py_INCREF(Py_None); resultobj = Py_None;
3189 {
3190 if (temp1)
3191 delete arg1;
3192 }
3193 return resultobj;
3194 fail:
3195 {
3196 if (temp1)
3197 delete arg1;
3198 }
3199 return NULL;
3200 }
3201
3202
3203 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3204 PyObject *resultobj;
3205 wxString *arg1 = 0 ;
3206 wxString result;
3207 bool temp1 = false ;
3208 PyObject * obj0 = 0 ;
3209 char *kwnames[] = {
3210 (char *) "name", NULL
3211 };
3212
3213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3214 {
3215 arg1 = wxString_in_helper(obj0);
3216 if (arg1 == NULL) SWIG_fail;
3217 temp1 = true;
3218 }
3219 {
3220 PyThreadState* __tstate = wxPyBeginAllowThreads();
3221 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3222
3223 wxPyEndAllowThreads(__tstate);
3224 if (PyErr_Occurred()) SWIG_fail;
3225 }
3226 {
3227 #if wxUSE_UNICODE
3228 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3229 #else
3230 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3231 #endif
3232 }
3233 {
3234 if (temp1)
3235 delete arg1;
3236 }
3237 return resultobj;
3238 fail:
3239 {
3240 if (temp1)
3241 delete arg1;
3242 }
3243 return NULL;
3244 }
3245
3246
3247 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3248 PyObject *resultobj;
3249 wxString *arg1 = 0 ;
3250 int result;
3251 bool temp1 = false ;
3252 PyObject * obj0 = 0 ;
3253 char *kwnames[] = {
3254 (char *) "name", NULL
3255 };
3256
3257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3258 {
3259 arg1 = wxString_in_helper(obj0);
3260 if (arg1 == NULL) SWIG_fail;
3261 temp1 = true;
3262 }
3263 {
3264 PyThreadState* __tstate = wxPyBeginAllowThreads();
3265 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3266
3267 wxPyEndAllowThreads(__tstate);
3268 if (PyErr_Occurred()) SWIG_fail;
3269 }
3270 {
3271 resultobj = SWIG_From_int((int)(result));
3272 }
3273 {
3274 if (temp1)
3275 delete arg1;
3276 }
3277 return resultobj;
3278 fail:
3279 {
3280 if (temp1)
3281 delete arg1;
3282 }
3283 return NULL;
3284 }
3285
3286
3287 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3288 PyObject *resultobj;
3289 wxString *arg1 = 0 ;
3290 bool result;
3291 bool temp1 = false ;
3292 PyObject * obj0 = 0 ;
3293 char *kwnames[] = {
3294 (char *) "name", NULL
3295 };
3296
3297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3298 {
3299 arg1 = wxString_in_helper(obj0);
3300 if (arg1 == NULL) SWIG_fail;
3301 temp1 = true;
3302 }
3303 {
3304 PyThreadState* __tstate = wxPyBeginAllowThreads();
3305 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3306
3307 wxPyEndAllowThreads(__tstate);
3308 if (PyErr_Occurred()) SWIG_fail;
3309 }
3310 {
3311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3312 }
3313 {
3314 if (temp1)
3315 delete arg1;
3316 }
3317 return resultobj;
3318 fail:
3319 {
3320 if (temp1)
3321 delete arg1;
3322 }
3323 return NULL;
3324 }
3325
3326
3327 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3328 PyObject *obj;
3329 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3330 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3331 Py_INCREF(obj);
3332 return Py_BuildValue((char *)"");
3333 }
3334 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3335 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3336 return 1;
3337 }
3338
3339
3340 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3341 PyObject *pyobj;
3342
3343 {
3344 #if wxUSE_UNICODE
3345 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3346 #else
3347 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3348 #endif
3349 }
3350 return pyobj;
3351 }
3352
3353
3354 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3355 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3356 return 1;
3357 }
3358
3359
3360 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3361 PyObject *pyobj;
3362
3363 {
3364 #if wxUSE_UNICODE
3365 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3366 #else
3367 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3368 #endif
3369 }
3370 return pyobj;
3371 }
3372
3373
3374 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3375 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3376 return 1;
3377 }
3378
3379
3380 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3381 PyObject *pyobj;
3382
3383 {
3384 #if wxUSE_UNICODE
3385 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3386 #else
3387 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3388 #endif
3389 }
3390 return pyobj;
3391 }
3392
3393
3394 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3395 PyObject *resultobj;
3396 long result;
3397 char *kwnames[] = {
3398 NULL
3399 };
3400
3401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3402 {
3403 PyThreadState* __tstate = wxPyBeginAllowThreads();
3404 result = (long)wxNewId();
3405
3406 wxPyEndAllowThreads(__tstate);
3407 if (PyErr_Occurred()) SWIG_fail;
3408 }
3409 {
3410 resultobj = SWIG_From_long((long)(result));
3411 }
3412 return resultobj;
3413 fail:
3414 return NULL;
3415 }
3416
3417
3418 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3419 PyObject *resultobj;
3420 long arg1 ;
3421 PyObject * obj0 = 0 ;
3422 char *kwnames[] = {
3423 (char *) "id", NULL
3424 };
3425
3426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3427 {
3428 arg1 = (long)(SWIG_As_long(obj0));
3429 if (SWIG_arg_fail(1)) SWIG_fail;
3430 }
3431 {
3432 PyThreadState* __tstate = wxPyBeginAllowThreads();
3433 wxRegisterId(arg1);
3434
3435 wxPyEndAllowThreads(__tstate);
3436 if (PyErr_Occurred()) SWIG_fail;
3437 }
3438 Py_INCREF(Py_None); resultobj = Py_None;
3439 return resultobj;
3440 fail:
3441 return NULL;
3442 }
3443
3444
3445 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3446 PyObject *resultobj;
3447 long result;
3448 char *kwnames[] = {
3449 NULL
3450 };
3451
3452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3453 {
3454 PyThreadState* __tstate = wxPyBeginAllowThreads();
3455 result = (long)wxGetCurrentId();
3456
3457 wxPyEndAllowThreads(__tstate);
3458 if (PyErr_Occurred()) SWIG_fail;
3459 }
3460 {
3461 resultobj = SWIG_From_long((long)(result));
3462 }
3463 return resultobj;
3464 fail:
3465 return NULL;
3466 }
3467
3468
3469 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3470 PyObject *resultobj;
3471 int arg1 ;
3472 bool result;
3473 PyObject * obj0 = 0 ;
3474 char *kwnames[] = {
3475 (char *) "id", NULL
3476 };
3477
3478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3479 {
3480 arg1 = (int)(SWIG_As_int(obj0));
3481 if (SWIG_arg_fail(1)) SWIG_fail;
3482 }
3483 {
3484 PyThreadState* __tstate = wxPyBeginAllowThreads();
3485 result = (bool)wxIsStockID(arg1);
3486
3487 wxPyEndAllowThreads(__tstate);
3488 if (PyErr_Occurred()) SWIG_fail;
3489 }
3490 {
3491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3492 }
3493 return resultobj;
3494 fail:
3495 return NULL;
3496 }
3497
3498
3499 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3500 PyObject *resultobj;
3501 int arg1 ;
3502 wxString *arg2 = 0 ;
3503 bool result;
3504 bool temp2 = false ;
3505 PyObject * obj0 = 0 ;
3506 PyObject * obj1 = 0 ;
3507 char *kwnames[] = {
3508 (char *) "id",(char *) "label", NULL
3509 };
3510
3511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3512 {
3513 arg1 = (int)(SWIG_As_int(obj0));
3514 if (SWIG_arg_fail(1)) SWIG_fail;
3515 }
3516 {
3517 arg2 = wxString_in_helper(obj1);
3518 if (arg2 == NULL) SWIG_fail;
3519 temp2 = true;
3520 }
3521 {
3522 PyThreadState* __tstate = wxPyBeginAllowThreads();
3523 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3524
3525 wxPyEndAllowThreads(__tstate);
3526 if (PyErr_Occurred()) SWIG_fail;
3527 }
3528 {
3529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3530 }
3531 {
3532 if (temp2)
3533 delete arg2;
3534 }
3535 return resultobj;
3536 fail:
3537 {
3538 if (temp2)
3539 delete arg2;
3540 }
3541 return NULL;
3542 }
3543
3544
3545 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3546 PyObject *resultobj;
3547 int arg1 ;
3548 bool arg2 = (bool) true ;
3549 wxString arg3 = (wxString) wxPyEmptyString ;
3550 wxString result;
3551 PyObject * obj0 = 0 ;
3552 PyObject * obj1 = 0 ;
3553 PyObject * obj2 = 0 ;
3554 char *kwnames[] = {
3555 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3556 };
3557
3558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3559 {
3560 arg1 = (int)(SWIG_As_int(obj0));
3561 if (SWIG_arg_fail(1)) SWIG_fail;
3562 }
3563 if (obj1) {
3564 {
3565 arg2 = (bool)(SWIG_As_bool(obj1));
3566 if (SWIG_arg_fail(2)) SWIG_fail;
3567 }
3568 }
3569 if (obj2) {
3570 {
3571 wxString* sptr = wxString_in_helper(obj2);
3572 if (sptr == NULL) SWIG_fail;
3573 arg3 = *sptr;
3574 delete sptr;
3575 }
3576 }
3577 {
3578 PyThreadState* __tstate = wxPyBeginAllowThreads();
3579 result = wxGetStockLabel(arg1,arg2,arg3);
3580
3581 wxPyEndAllowThreads(__tstate);
3582 if (PyErr_Occurred()) SWIG_fail;
3583 }
3584 {
3585 #if wxUSE_UNICODE
3586 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3587 #else
3588 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3589 #endif
3590 }
3591 return resultobj;
3592 fail:
3593 return NULL;
3594 }
3595
3596
3597 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3598 PyObject *resultobj;
3599 char *kwnames[] = {
3600 NULL
3601 };
3602
3603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3604 {
3605 if (!wxPyCheckForApp()) SWIG_fail;
3606 PyThreadState* __tstate = wxPyBeginAllowThreads();
3607 wxBell();
3608
3609 wxPyEndAllowThreads(__tstate);
3610 if (PyErr_Occurred()) SWIG_fail;
3611 }
3612 Py_INCREF(Py_None); resultobj = Py_None;
3613 return resultobj;
3614 fail:
3615 return NULL;
3616 }
3617
3618
3619 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3620 PyObject *resultobj;
3621 char *kwnames[] = {
3622 NULL
3623 };
3624
3625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3626 {
3627 if (!wxPyCheckForApp()) SWIG_fail;
3628 PyThreadState* __tstate = wxPyBeginAllowThreads();
3629 wxEndBusyCursor();
3630
3631 wxPyEndAllowThreads(__tstate);
3632 if (PyErr_Occurred()) SWIG_fail;
3633 }
3634 Py_INCREF(Py_None); resultobj = Py_None;
3635 return resultobj;
3636 fail:
3637 return NULL;
3638 }
3639
3640
3641 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3642 PyObject *resultobj;
3643 bool arg1 = (bool) true ;
3644 long result;
3645 PyObject * obj0 = 0 ;
3646 char *kwnames[] = {
3647 (char *) "resetTimer", NULL
3648 };
3649
3650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3651 if (obj0) {
3652 {
3653 arg1 = (bool)(SWIG_As_bool(obj0));
3654 if (SWIG_arg_fail(1)) SWIG_fail;
3655 }
3656 }
3657 {
3658 PyThreadState* __tstate = wxPyBeginAllowThreads();
3659 result = (long)wxGetElapsedTime(arg1);
3660
3661 wxPyEndAllowThreads(__tstate);
3662 if (PyErr_Occurred()) SWIG_fail;
3663 }
3664 {
3665 resultobj = SWIG_From_long((long)(result));
3666 }
3667 return resultobj;
3668 fail:
3669 return NULL;
3670 }
3671
3672
3673 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3674 PyObject *resultobj;
3675 int *arg1 = (int *) 0 ;
3676 int *arg2 = (int *) 0 ;
3677 int temp1 ;
3678 int res1 = 0 ;
3679 int temp2 ;
3680 int res2 = 0 ;
3681 char *kwnames[] = {
3682 NULL
3683 };
3684
3685 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3686 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3688 {
3689 if (!wxPyCheckForApp()) SWIG_fail;
3690 PyThreadState* __tstate = wxPyBeginAllowThreads();
3691 wxGetMousePosition(arg1,arg2);
3692
3693 wxPyEndAllowThreads(__tstate);
3694 if (PyErr_Occurred()) SWIG_fail;
3695 }
3696 Py_INCREF(Py_None); resultobj = Py_None;
3697 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3698 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3699 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3700 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3701 return resultobj;
3702 fail:
3703 return NULL;
3704 }
3705
3706
3707 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3708 PyObject *resultobj;
3709 bool result;
3710 char *kwnames[] = {
3711 NULL
3712 };
3713
3714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3715 {
3716 PyThreadState* __tstate = wxPyBeginAllowThreads();
3717 result = (bool)wxIsBusy();
3718
3719 wxPyEndAllowThreads(__tstate);
3720 if (PyErr_Occurred()) SWIG_fail;
3721 }
3722 {
3723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3724 }
3725 return resultobj;
3726 fail:
3727 return NULL;
3728 }
3729
3730
3731 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3732 PyObject *resultobj;
3733 wxString result;
3734 char *kwnames[] = {
3735 NULL
3736 };
3737
3738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3739 {
3740 PyThreadState* __tstate = wxPyBeginAllowThreads();
3741 result = wxNow();
3742
3743 wxPyEndAllowThreads(__tstate);
3744 if (PyErr_Occurred()) SWIG_fail;
3745 }
3746 {
3747 #if wxUSE_UNICODE
3748 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3749 #else
3750 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3751 #endif
3752 }
3753 return resultobj;
3754 fail:
3755 return NULL;
3756 }
3757
3758
3759 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3760 PyObject *resultobj;
3761 wxString const &arg1_defvalue = wxPyEmptyString ;
3762 wxString *arg1 = (wxString *) &arg1_defvalue ;
3763 bool result;
3764 bool temp1 = false ;
3765 PyObject * obj0 = 0 ;
3766 char *kwnames[] = {
3767 (char *) "command", NULL
3768 };
3769
3770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3771 if (obj0) {
3772 {
3773 arg1 = wxString_in_helper(obj0);
3774 if (arg1 == NULL) SWIG_fail;
3775 temp1 = true;
3776 }
3777 }
3778 {
3779 PyThreadState* __tstate = wxPyBeginAllowThreads();
3780 result = (bool)wxShell((wxString const &)*arg1);
3781
3782 wxPyEndAllowThreads(__tstate);
3783 if (PyErr_Occurred()) SWIG_fail;
3784 }
3785 {
3786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3787 }
3788 {
3789 if (temp1)
3790 delete arg1;
3791 }
3792 return resultobj;
3793 fail:
3794 {
3795 if (temp1)
3796 delete arg1;
3797 }
3798 return NULL;
3799 }
3800
3801
3802 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3803 PyObject *resultobj;
3804 char *kwnames[] = {
3805 NULL
3806 };
3807
3808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3809 {
3810 PyThreadState* __tstate = wxPyBeginAllowThreads();
3811 wxStartTimer();
3812
3813 wxPyEndAllowThreads(__tstate);
3814 if (PyErr_Occurred()) SWIG_fail;
3815 }
3816 Py_INCREF(Py_None); resultobj = Py_None;
3817 return resultobj;
3818 fail:
3819 return NULL;
3820 }
3821
3822
3823 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3824 PyObject *resultobj;
3825 int *arg1 = (int *) 0 ;
3826 int *arg2 = (int *) 0 ;
3827 int result;
3828 int temp1 ;
3829 int res1 = 0 ;
3830 int temp2 ;
3831 int res2 = 0 ;
3832 char *kwnames[] = {
3833 NULL
3834 };
3835
3836 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3837 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3839 {
3840 PyThreadState* __tstate = wxPyBeginAllowThreads();
3841 result = (int)wxGetOsVersion(arg1,arg2);
3842
3843 wxPyEndAllowThreads(__tstate);
3844 if (PyErr_Occurred()) SWIG_fail;
3845 }
3846 {
3847 resultobj = SWIG_From_int((int)(result));
3848 }
3849 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3850 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3851 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3852 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3853 return resultobj;
3854 fail:
3855 return NULL;
3856 }
3857
3858
3859 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3860 PyObject *resultobj;
3861 wxString result;
3862 char *kwnames[] = {
3863 NULL
3864 };
3865
3866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3867 {
3868 PyThreadState* __tstate = wxPyBeginAllowThreads();
3869 result = wxGetOsDescription();
3870
3871 wxPyEndAllowThreads(__tstate);
3872 if (PyErr_Occurred()) SWIG_fail;
3873 }
3874 {
3875 #if wxUSE_UNICODE
3876 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3877 #else
3878 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3879 #endif
3880 }
3881 return resultobj;
3882 fail:
3883 return NULL;
3884 }
3885
3886
3887 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3888 PyObject *resultobj;
3889 long result;
3890 char *kwnames[] = {
3891 NULL
3892 };
3893
3894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3895 {
3896 PyThreadState* __tstate = wxPyBeginAllowThreads();
3897 result = (long)wxGetFreeMemory();
3898
3899 wxPyEndAllowThreads(__tstate);
3900 if (PyErr_Occurred()) SWIG_fail;
3901 }
3902 {
3903 resultobj = SWIG_From_long((long)(result));
3904 }
3905 return resultobj;
3906 fail:
3907 return NULL;
3908 }
3909
3910
3911 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
3912 PyObject *resultobj;
3913 wxShutdownFlags arg1 ;
3914 bool result;
3915 PyObject * obj0 = 0 ;
3916 char *kwnames[] = {
3917 (char *) "wFlags", NULL
3918 };
3919
3920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
3921 {
3922 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
3923 if (SWIG_arg_fail(1)) SWIG_fail;
3924 }
3925 {
3926 if (!wxPyCheckForApp()) SWIG_fail;
3927 PyThreadState* __tstate = wxPyBeginAllowThreads();
3928 result = (bool)wxShutdown((wxShutdownFlags )arg1);
3929
3930 wxPyEndAllowThreads(__tstate);
3931 if (PyErr_Occurred()) SWIG_fail;
3932 }
3933 {
3934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3935 }
3936 return resultobj;
3937 fail:
3938 return NULL;
3939 }
3940
3941
3942 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
3943 PyObject *resultobj;
3944 int arg1 ;
3945 PyObject * obj0 = 0 ;
3946 char *kwnames[] = {
3947 (char *) "secs", NULL
3948 };
3949
3950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
3951 {
3952 arg1 = (int)(SWIG_As_int(obj0));
3953 if (SWIG_arg_fail(1)) SWIG_fail;
3954 }
3955 {
3956 PyThreadState* __tstate = wxPyBeginAllowThreads();
3957 wxSleep(arg1);
3958
3959 wxPyEndAllowThreads(__tstate);
3960 if (PyErr_Occurred()) SWIG_fail;
3961 }
3962 Py_INCREF(Py_None); resultobj = Py_None;
3963 return resultobj;
3964 fail:
3965 return NULL;
3966 }
3967
3968
3969 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3970 PyObject *resultobj;
3971 unsigned long arg1 ;
3972 PyObject * obj0 = 0 ;
3973 char *kwnames[] = {
3974 (char *) "milliseconds", NULL
3975 };
3976
3977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
3978 {
3979 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
3980 if (SWIG_arg_fail(1)) SWIG_fail;
3981 }
3982 {
3983 PyThreadState* __tstate = wxPyBeginAllowThreads();
3984 wxMilliSleep(arg1);
3985
3986 wxPyEndAllowThreads(__tstate);
3987 if (PyErr_Occurred()) SWIG_fail;
3988 }
3989 Py_INCREF(Py_None); resultobj = Py_None;
3990 return resultobj;
3991 fail:
3992 return NULL;
3993 }
3994
3995
3996 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
3997 PyObject *resultobj;
3998 unsigned long arg1 ;
3999 PyObject * obj0 = 0 ;
4000 char *kwnames[] = {
4001 (char *) "microseconds", NULL
4002 };
4003
4004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4005 {
4006 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4007 if (SWIG_arg_fail(1)) SWIG_fail;
4008 }
4009 {
4010 PyThreadState* __tstate = wxPyBeginAllowThreads();
4011 wxMicroSleep(arg1);
4012
4013 wxPyEndAllowThreads(__tstate);
4014 if (PyErr_Occurred()) SWIG_fail;
4015 }
4016 Py_INCREF(Py_None); resultobj = Py_None;
4017 return resultobj;
4018 fail:
4019 return NULL;
4020 }
4021
4022
4023 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4024 PyObject *resultobj;
4025 bool arg1 ;
4026 PyObject * obj0 = 0 ;
4027 char *kwnames[] = {
4028 (char *) "enable", NULL
4029 };
4030
4031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4032 {
4033 arg1 = (bool)(SWIG_As_bool(obj0));
4034 if (SWIG_arg_fail(1)) SWIG_fail;
4035 }
4036 {
4037 PyThreadState* __tstate = wxPyBeginAllowThreads();
4038 wxEnableTopLevelWindows(arg1);
4039
4040 wxPyEndAllowThreads(__tstate);
4041 if (PyErr_Occurred()) SWIG_fail;
4042 }
4043 Py_INCREF(Py_None); resultobj = Py_None;
4044 return resultobj;
4045 fail:
4046 return NULL;
4047 }
4048
4049
4050 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4051 PyObject *resultobj;
4052 wxString *arg1 = 0 ;
4053 wxString result;
4054 bool temp1 = false ;
4055 PyObject * obj0 = 0 ;
4056 char *kwnames[] = {
4057 (char *) "in", NULL
4058 };
4059
4060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4061 {
4062 arg1 = wxString_in_helper(obj0);
4063 if (arg1 == NULL) SWIG_fail;
4064 temp1 = true;
4065 }
4066 {
4067 PyThreadState* __tstate = wxPyBeginAllowThreads();
4068 result = wxStripMenuCodes((wxString const &)*arg1);
4069
4070 wxPyEndAllowThreads(__tstate);
4071 if (PyErr_Occurred()) SWIG_fail;
4072 }
4073 {
4074 #if wxUSE_UNICODE
4075 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4076 #else
4077 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4078 #endif
4079 }
4080 {
4081 if (temp1)
4082 delete arg1;
4083 }
4084 return resultobj;
4085 fail:
4086 {
4087 if (temp1)
4088 delete arg1;
4089 }
4090 return NULL;
4091 }
4092
4093
4094 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4095 PyObject *resultobj;
4096 wxString result;
4097 char *kwnames[] = {
4098 NULL
4099 };
4100
4101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4102 {
4103 PyThreadState* __tstate = wxPyBeginAllowThreads();
4104 result = wxGetEmailAddress();
4105
4106 wxPyEndAllowThreads(__tstate);
4107 if (PyErr_Occurred()) SWIG_fail;
4108 }
4109 {
4110 #if wxUSE_UNICODE
4111 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4112 #else
4113 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4114 #endif
4115 }
4116 return resultobj;
4117 fail:
4118 return NULL;
4119 }
4120
4121
4122 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4123 PyObject *resultobj;
4124 wxString result;
4125 char *kwnames[] = {
4126 NULL
4127 };
4128
4129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4130 {
4131 PyThreadState* __tstate = wxPyBeginAllowThreads();
4132 result = wxGetHostName();
4133
4134 wxPyEndAllowThreads(__tstate);
4135 if (PyErr_Occurred()) SWIG_fail;
4136 }
4137 {
4138 #if wxUSE_UNICODE
4139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4140 #else
4141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4142 #endif
4143 }
4144 return resultobj;
4145 fail:
4146 return NULL;
4147 }
4148
4149
4150 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4151 PyObject *resultobj;
4152 wxString result;
4153 char *kwnames[] = {
4154 NULL
4155 };
4156
4157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4158 {
4159 PyThreadState* __tstate = wxPyBeginAllowThreads();
4160 result = wxGetFullHostName();
4161
4162 wxPyEndAllowThreads(__tstate);
4163 if (PyErr_Occurred()) SWIG_fail;
4164 }
4165 {
4166 #if wxUSE_UNICODE
4167 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4168 #else
4169 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4170 #endif
4171 }
4172 return resultobj;
4173 fail:
4174 return NULL;
4175 }
4176
4177
4178 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4179 PyObject *resultobj;
4180 wxString result;
4181 char *kwnames[] = {
4182 NULL
4183 };
4184
4185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4186 {
4187 PyThreadState* __tstate = wxPyBeginAllowThreads();
4188 result = wxGetUserId();
4189
4190 wxPyEndAllowThreads(__tstate);
4191 if (PyErr_Occurred()) SWIG_fail;
4192 }
4193 {
4194 #if wxUSE_UNICODE
4195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4196 #else
4197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4198 #endif
4199 }
4200 return resultobj;
4201 fail:
4202 return NULL;
4203 }
4204
4205
4206 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4207 PyObject *resultobj;
4208 wxString result;
4209 char *kwnames[] = {
4210 NULL
4211 };
4212
4213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4214 {
4215 PyThreadState* __tstate = wxPyBeginAllowThreads();
4216 result = wxGetUserName();
4217
4218 wxPyEndAllowThreads(__tstate);
4219 if (PyErr_Occurred()) SWIG_fail;
4220 }
4221 {
4222 #if wxUSE_UNICODE
4223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4224 #else
4225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4226 #endif
4227 }
4228 return resultobj;
4229 fail:
4230 return NULL;
4231 }
4232
4233
4234 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4235 PyObject *resultobj;
4236 wxString result;
4237 char *kwnames[] = {
4238 NULL
4239 };
4240
4241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4242 {
4243 PyThreadState* __tstate = wxPyBeginAllowThreads();
4244 result = wxGetHomeDir();
4245
4246 wxPyEndAllowThreads(__tstate);
4247 if (PyErr_Occurred()) SWIG_fail;
4248 }
4249 {
4250 #if wxUSE_UNICODE
4251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4252 #else
4253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4254 #endif
4255 }
4256 return resultobj;
4257 fail:
4258 return NULL;
4259 }
4260
4261
4262 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4263 PyObject *resultobj;
4264 wxString const &arg1_defvalue = wxPyEmptyString ;
4265 wxString *arg1 = (wxString *) &arg1_defvalue ;
4266 wxString result;
4267 bool temp1 = false ;
4268 PyObject * obj0 = 0 ;
4269 char *kwnames[] = {
4270 (char *) "user", NULL
4271 };
4272
4273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4274 if (obj0) {
4275 {
4276 arg1 = wxString_in_helper(obj0);
4277 if (arg1 == NULL) SWIG_fail;
4278 temp1 = true;
4279 }
4280 }
4281 {
4282 PyThreadState* __tstate = wxPyBeginAllowThreads();
4283 result = wxGetUserHome((wxString const &)*arg1);
4284
4285 wxPyEndAllowThreads(__tstate);
4286 if (PyErr_Occurred()) SWIG_fail;
4287 }
4288 {
4289 #if wxUSE_UNICODE
4290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4291 #else
4292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4293 #endif
4294 }
4295 {
4296 if (temp1)
4297 delete arg1;
4298 }
4299 return resultobj;
4300 fail:
4301 {
4302 if (temp1)
4303 delete arg1;
4304 }
4305 return NULL;
4306 }
4307
4308
4309 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4310 PyObject *resultobj;
4311 unsigned long result;
4312 char *kwnames[] = {
4313 NULL
4314 };
4315
4316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4317 {
4318 PyThreadState* __tstate = wxPyBeginAllowThreads();
4319 result = (unsigned long)wxGetProcessId();
4320
4321 wxPyEndAllowThreads(__tstate);
4322 if (PyErr_Occurred()) SWIG_fail;
4323 }
4324 {
4325 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4326 }
4327 return resultobj;
4328 fail:
4329 return NULL;
4330 }
4331
4332
4333 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4334 PyObject *resultobj;
4335 char *kwnames[] = {
4336 NULL
4337 };
4338
4339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4340 {
4341 PyThreadState* __tstate = wxPyBeginAllowThreads();
4342 wxTrap();
4343
4344 wxPyEndAllowThreads(__tstate);
4345 if (PyErr_Occurred()) SWIG_fail;
4346 }
4347 Py_INCREF(Py_None); resultobj = Py_None;
4348 return resultobj;
4349 fail:
4350 return NULL;
4351 }
4352
4353
4354 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4355 PyObject *resultobj;
4356 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4357 wxString *arg1 = (wxString *) &arg1_defvalue ;
4358 wxString const &arg2_defvalue = wxPyEmptyString ;
4359 wxString *arg2 = (wxString *) &arg2_defvalue ;
4360 wxString const &arg3_defvalue = wxPyEmptyString ;
4361 wxString *arg3 = (wxString *) &arg3_defvalue ;
4362 wxString const &arg4_defvalue = wxPyEmptyString ;
4363 wxString *arg4 = (wxString *) &arg4_defvalue ;
4364 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4365 wxString *arg5 = (wxString *) &arg5_defvalue ;
4366 int arg6 = (int) 0 ;
4367 wxWindow *arg7 = (wxWindow *) NULL ;
4368 int arg8 = (int) -1 ;
4369 int arg9 = (int) -1 ;
4370 wxString result;
4371 bool temp1 = false ;
4372 bool temp2 = false ;
4373 bool temp3 = false ;
4374 bool temp4 = false ;
4375 bool temp5 = false ;
4376 PyObject * obj0 = 0 ;
4377 PyObject * obj1 = 0 ;
4378 PyObject * obj2 = 0 ;
4379 PyObject * obj3 = 0 ;
4380 PyObject * obj4 = 0 ;
4381 PyObject * obj5 = 0 ;
4382 PyObject * obj6 = 0 ;
4383 PyObject * obj7 = 0 ;
4384 PyObject * obj8 = 0 ;
4385 char *kwnames[] = {
4386 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4387 };
4388
4389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4390 if (obj0) {
4391 {
4392 arg1 = wxString_in_helper(obj0);
4393 if (arg1 == NULL) SWIG_fail;
4394 temp1 = true;
4395 }
4396 }
4397 if (obj1) {
4398 {
4399 arg2 = wxString_in_helper(obj1);
4400 if (arg2 == NULL) SWIG_fail;
4401 temp2 = true;
4402 }
4403 }
4404 if (obj2) {
4405 {
4406 arg3 = wxString_in_helper(obj2);
4407 if (arg3 == NULL) SWIG_fail;
4408 temp3 = true;
4409 }
4410 }
4411 if (obj3) {
4412 {
4413 arg4 = wxString_in_helper(obj3);
4414 if (arg4 == NULL) SWIG_fail;
4415 temp4 = true;
4416 }
4417 }
4418 if (obj4) {
4419 {
4420 arg5 = wxString_in_helper(obj4);
4421 if (arg5 == NULL) SWIG_fail;
4422 temp5 = true;
4423 }
4424 }
4425 if (obj5) {
4426 {
4427 arg6 = (int)(SWIG_As_int(obj5));
4428 if (SWIG_arg_fail(6)) SWIG_fail;
4429 }
4430 }
4431 if (obj6) {
4432 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4433 if (SWIG_arg_fail(7)) SWIG_fail;
4434 }
4435 if (obj7) {
4436 {
4437 arg8 = (int)(SWIG_As_int(obj7));
4438 if (SWIG_arg_fail(8)) SWIG_fail;
4439 }
4440 }
4441 if (obj8) {
4442 {
4443 arg9 = (int)(SWIG_As_int(obj8));
4444 if (SWIG_arg_fail(9)) SWIG_fail;
4445 }
4446 }
4447 {
4448 if (!wxPyCheckForApp()) SWIG_fail;
4449 PyThreadState* __tstate = wxPyBeginAllowThreads();
4450 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4451
4452 wxPyEndAllowThreads(__tstate);
4453 if (PyErr_Occurred()) SWIG_fail;
4454 }
4455 {
4456 #if wxUSE_UNICODE
4457 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4458 #else
4459 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4460 #endif
4461 }
4462 {
4463 if (temp1)
4464 delete arg1;
4465 }
4466 {
4467 if (temp2)
4468 delete arg2;
4469 }
4470 {
4471 if (temp3)
4472 delete arg3;
4473 }
4474 {
4475 if (temp4)
4476 delete arg4;
4477 }
4478 {
4479 if (temp5)
4480 delete arg5;
4481 }
4482 return resultobj;
4483 fail:
4484 {
4485 if (temp1)
4486 delete arg1;
4487 }
4488 {
4489 if (temp2)
4490 delete arg2;
4491 }
4492 {
4493 if (temp3)
4494 delete arg3;
4495 }
4496 {
4497 if (temp4)
4498 delete arg4;
4499 }
4500 {
4501 if (temp5)
4502 delete arg5;
4503 }
4504 return NULL;
4505 }
4506
4507
4508 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4509 PyObject *resultobj;
4510 wxString *arg1 = 0 ;
4511 wxString *arg2 = 0 ;
4512 wxString const &arg3_defvalue = wxPyEmptyString ;
4513 wxString *arg3 = (wxString *) &arg3_defvalue ;
4514 wxWindow *arg4 = (wxWindow *) NULL ;
4515 wxString result;
4516 bool temp1 = false ;
4517 bool temp2 = false ;
4518 bool temp3 = false ;
4519 PyObject * obj0 = 0 ;
4520 PyObject * obj1 = 0 ;
4521 PyObject * obj2 = 0 ;
4522 PyObject * obj3 = 0 ;
4523 char *kwnames[] = {
4524 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4525 };
4526
4527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4528 {
4529 arg1 = wxString_in_helper(obj0);
4530 if (arg1 == NULL) SWIG_fail;
4531 temp1 = true;
4532 }
4533 {
4534 arg2 = wxString_in_helper(obj1);
4535 if (arg2 == NULL) SWIG_fail;
4536 temp2 = true;
4537 }
4538 if (obj2) {
4539 {
4540 arg3 = wxString_in_helper(obj2);
4541 if (arg3 == NULL) SWIG_fail;
4542 temp3 = true;
4543 }
4544 }
4545 if (obj3) {
4546 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4547 if (SWIG_arg_fail(4)) SWIG_fail;
4548 }
4549 {
4550 if (!wxPyCheckForApp()) SWIG_fail;
4551 PyThreadState* __tstate = wxPyBeginAllowThreads();
4552 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4553
4554 wxPyEndAllowThreads(__tstate);
4555 if (PyErr_Occurred()) SWIG_fail;
4556 }
4557 {
4558 #if wxUSE_UNICODE
4559 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4560 #else
4561 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4562 #endif
4563 }
4564 {
4565 if (temp1)
4566 delete arg1;
4567 }
4568 {
4569 if (temp2)
4570 delete arg2;
4571 }
4572 {
4573 if (temp3)
4574 delete arg3;
4575 }
4576 return resultobj;
4577 fail:
4578 {
4579 if (temp1)
4580 delete arg1;
4581 }
4582 {
4583 if (temp2)
4584 delete arg2;
4585 }
4586 {
4587 if (temp3)
4588 delete arg3;
4589 }
4590 return NULL;
4591 }
4592
4593
4594 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4595 PyObject *resultobj;
4596 wxString *arg1 = 0 ;
4597 wxString *arg2 = 0 ;
4598 wxString const &arg3_defvalue = wxPyEmptyString ;
4599 wxString *arg3 = (wxString *) &arg3_defvalue ;
4600 wxWindow *arg4 = (wxWindow *) NULL ;
4601 wxString result;
4602 bool temp1 = false ;
4603 bool temp2 = false ;
4604 bool temp3 = false ;
4605 PyObject * obj0 = 0 ;
4606 PyObject * obj1 = 0 ;
4607 PyObject * obj2 = 0 ;
4608 PyObject * obj3 = 0 ;
4609 char *kwnames[] = {
4610 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4611 };
4612
4613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4614 {
4615 arg1 = wxString_in_helper(obj0);
4616 if (arg1 == NULL) SWIG_fail;
4617 temp1 = true;
4618 }
4619 {
4620 arg2 = wxString_in_helper(obj1);
4621 if (arg2 == NULL) SWIG_fail;
4622 temp2 = true;
4623 }
4624 if (obj2) {
4625 {
4626 arg3 = wxString_in_helper(obj2);
4627 if (arg3 == NULL) SWIG_fail;
4628 temp3 = true;
4629 }
4630 }
4631 if (obj3) {
4632 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4633 if (SWIG_arg_fail(4)) SWIG_fail;
4634 }
4635 {
4636 if (!wxPyCheckForApp()) SWIG_fail;
4637 PyThreadState* __tstate = wxPyBeginAllowThreads();
4638 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4639
4640 wxPyEndAllowThreads(__tstate);
4641 if (PyErr_Occurred()) SWIG_fail;
4642 }
4643 {
4644 #if wxUSE_UNICODE
4645 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4646 #else
4647 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4648 #endif
4649 }
4650 {
4651 if (temp1)
4652 delete arg1;
4653 }
4654 {
4655 if (temp2)
4656 delete arg2;
4657 }
4658 {
4659 if (temp3)
4660 delete arg3;
4661 }
4662 return resultobj;
4663 fail:
4664 {
4665 if (temp1)
4666 delete arg1;
4667 }
4668 {
4669 if (temp2)
4670 delete arg2;
4671 }
4672 {
4673 if (temp3)
4674 delete arg3;
4675 }
4676 return NULL;
4677 }
4678
4679
4680 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4681 PyObject *resultobj;
4682 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4683 wxString *arg1 = (wxString *) &arg1_defvalue ;
4684 wxString const &arg2_defvalue = wxPyEmptyString ;
4685 wxString *arg2 = (wxString *) &arg2_defvalue ;
4686 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4687 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4688 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4689 wxWindow *arg5 = (wxWindow *) NULL ;
4690 wxString result;
4691 bool temp1 = false ;
4692 bool temp2 = false ;
4693 wxPoint temp4 ;
4694 PyObject * obj0 = 0 ;
4695 PyObject * obj1 = 0 ;
4696 PyObject * obj2 = 0 ;
4697 PyObject * obj3 = 0 ;
4698 PyObject * obj4 = 0 ;
4699 char *kwnames[] = {
4700 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4701 };
4702
4703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4704 if (obj0) {
4705 {
4706 arg1 = wxString_in_helper(obj0);
4707 if (arg1 == NULL) SWIG_fail;
4708 temp1 = true;
4709 }
4710 }
4711 if (obj1) {
4712 {
4713 arg2 = wxString_in_helper(obj1);
4714 if (arg2 == NULL) SWIG_fail;
4715 temp2 = true;
4716 }
4717 }
4718 if (obj2) {
4719 {
4720 arg3 = (long)(SWIG_As_long(obj2));
4721 if (SWIG_arg_fail(3)) SWIG_fail;
4722 }
4723 }
4724 if (obj3) {
4725 {
4726 arg4 = &temp4;
4727 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4728 }
4729 }
4730 if (obj4) {
4731 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4732 if (SWIG_arg_fail(5)) SWIG_fail;
4733 }
4734 {
4735 if (!wxPyCheckForApp()) SWIG_fail;
4736 PyThreadState* __tstate = wxPyBeginAllowThreads();
4737 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4738
4739 wxPyEndAllowThreads(__tstate);
4740 if (PyErr_Occurred()) SWIG_fail;
4741 }
4742 {
4743 #if wxUSE_UNICODE
4744 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4745 #else
4746 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4747 #endif
4748 }
4749 {
4750 if (temp1)
4751 delete arg1;
4752 }
4753 {
4754 if (temp2)
4755 delete arg2;
4756 }
4757 return resultobj;
4758 fail:
4759 {
4760 if (temp1)
4761 delete arg1;
4762 }
4763 {
4764 if (temp2)
4765 delete arg2;
4766 }
4767 return NULL;
4768 }
4769
4770
4771 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4772 PyObject *resultobj;
4773 wxString *arg1 = 0 ;
4774 wxString const &arg2_defvalue = wxPyEmptyString ;
4775 wxString *arg2 = (wxString *) &arg2_defvalue ;
4776 wxString const &arg3_defvalue = wxPyEmptyString ;
4777 wxString *arg3 = (wxString *) &arg3_defvalue ;
4778 wxWindow *arg4 = (wxWindow *) NULL ;
4779 int arg5 = (int) -1 ;
4780 int arg6 = (int) -1 ;
4781 bool arg7 = (bool) true ;
4782 wxString result;
4783 bool temp1 = false ;
4784 bool temp2 = false ;
4785 bool temp3 = false ;
4786 PyObject * obj0 = 0 ;
4787 PyObject * obj1 = 0 ;
4788 PyObject * obj2 = 0 ;
4789 PyObject * obj3 = 0 ;
4790 PyObject * obj4 = 0 ;
4791 PyObject * obj5 = 0 ;
4792 PyObject * obj6 = 0 ;
4793 char *kwnames[] = {
4794 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4795 };
4796
4797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4798 {
4799 arg1 = wxString_in_helper(obj0);
4800 if (arg1 == NULL) SWIG_fail;
4801 temp1 = true;
4802 }
4803 if (obj1) {
4804 {
4805 arg2 = wxString_in_helper(obj1);
4806 if (arg2 == NULL) SWIG_fail;
4807 temp2 = true;
4808 }
4809 }
4810 if (obj2) {
4811 {
4812 arg3 = wxString_in_helper(obj2);
4813 if (arg3 == NULL) SWIG_fail;
4814 temp3 = true;
4815 }
4816 }
4817 if (obj3) {
4818 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4819 if (SWIG_arg_fail(4)) SWIG_fail;
4820 }
4821 if (obj4) {
4822 {
4823 arg5 = (int)(SWIG_As_int(obj4));
4824 if (SWIG_arg_fail(5)) SWIG_fail;
4825 }
4826 }
4827 if (obj5) {
4828 {
4829 arg6 = (int)(SWIG_As_int(obj5));
4830 if (SWIG_arg_fail(6)) SWIG_fail;
4831 }
4832 }
4833 if (obj6) {
4834 {
4835 arg7 = (bool)(SWIG_As_bool(obj6));
4836 if (SWIG_arg_fail(7)) SWIG_fail;
4837 }
4838 }
4839 {
4840 if (!wxPyCheckForApp()) SWIG_fail;
4841 PyThreadState* __tstate = wxPyBeginAllowThreads();
4842 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4843
4844 wxPyEndAllowThreads(__tstate);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 {
4848 #if wxUSE_UNICODE
4849 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4850 #else
4851 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4852 #endif
4853 }
4854 {
4855 if (temp1)
4856 delete arg1;
4857 }
4858 {
4859 if (temp2)
4860 delete arg2;
4861 }
4862 {
4863 if (temp3)
4864 delete arg3;
4865 }
4866 return resultobj;
4867 fail:
4868 {
4869 if (temp1)
4870 delete arg1;
4871 }
4872 {
4873 if (temp2)
4874 delete arg2;
4875 }
4876 {
4877 if (temp3)
4878 delete arg3;
4879 }
4880 return NULL;
4881 }
4882
4883
4884 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4885 PyObject *resultobj;
4886 wxString *arg1 = 0 ;
4887 wxString const &arg2_defvalue = wxPyEmptyString ;
4888 wxString *arg2 = (wxString *) &arg2_defvalue ;
4889 wxString const &arg3_defvalue = wxPyEmptyString ;
4890 wxString *arg3 = (wxString *) &arg3_defvalue ;
4891 wxWindow *arg4 = (wxWindow *) NULL ;
4892 wxString result;
4893 bool temp1 = false ;
4894 bool temp2 = false ;
4895 bool temp3 = false ;
4896 PyObject * obj0 = 0 ;
4897 PyObject * obj1 = 0 ;
4898 PyObject * obj2 = 0 ;
4899 PyObject * obj3 = 0 ;
4900 char *kwnames[] = {
4901 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
4902 };
4903
4904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4905 {
4906 arg1 = wxString_in_helper(obj0);
4907 if (arg1 == NULL) SWIG_fail;
4908 temp1 = true;
4909 }
4910 if (obj1) {
4911 {
4912 arg2 = wxString_in_helper(obj1);
4913 if (arg2 == NULL) SWIG_fail;
4914 temp2 = true;
4915 }
4916 }
4917 if (obj2) {
4918 {
4919 arg3 = wxString_in_helper(obj2);
4920 if (arg3 == NULL) SWIG_fail;
4921 temp3 = true;
4922 }
4923 }
4924 if (obj3) {
4925 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4926 if (SWIG_arg_fail(4)) SWIG_fail;
4927 }
4928 {
4929 if (!wxPyCheckForApp()) SWIG_fail;
4930 PyThreadState* __tstate = wxPyBeginAllowThreads();
4931 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4932
4933 wxPyEndAllowThreads(__tstate);
4934 if (PyErr_Occurred()) SWIG_fail;
4935 }
4936 {
4937 #if wxUSE_UNICODE
4938 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4939 #else
4940 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4941 #endif
4942 }
4943 {
4944 if (temp1)
4945 delete arg1;
4946 }
4947 {
4948 if (temp2)
4949 delete arg2;
4950 }
4951 {
4952 if (temp3)
4953 delete arg3;
4954 }
4955 return resultobj;
4956 fail:
4957 {
4958 if (temp1)
4959 delete arg1;
4960 }
4961 {
4962 if (temp2)
4963 delete arg2;
4964 }
4965 {
4966 if (temp3)
4967 delete arg3;
4968 }
4969 return NULL;
4970 }
4971
4972
4973 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
4974 PyObject *resultobj;
4975 wxString *arg1 = 0 ;
4976 wxString *arg2 = 0 ;
4977 int arg3 ;
4978 wxString *arg4 = (wxString *) 0 ;
4979 wxWindow *arg5 = (wxWindow *) NULL ;
4980 int arg6 = (int) -1 ;
4981 int arg7 = (int) -1 ;
4982 bool arg8 = (bool) true ;
4983 int arg9 = (int) 150 ;
4984 int arg10 = (int) 200 ;
4985 wxString result;
4986 bool temp1 = false ;
4987 bool temp2 = false ;
4988 PyObject * obj0 = 0 ;
4989 PyObject * obj1 = 0 ;
4990 PyObject * obj2 = 0 ;
4991 PyObject * obj3 = 0 ;
4992 PyObject * obj4 = 0 ;
4993 PyObject * obj5 = 0 ;
4994 PyObject * obj6 = 0 ;
4995 PyObject * obj7 = 0 ;
4996 PyObject * obj8 = 0 ;
4997 char *kwnames[] = {
4998 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
4999 };
5000
5001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5002 {
5003 arg1 = wxString_in_helper(obj0);
5004 if (arg1 == NULL) SWIG_fail;
5005 temp1 = true;
5006 }
5007 {
5008 arg2 = wxString_in_helper(obj1);
5009 if (arg2 == NULL) SWIG_fail;
5010 temp2 = true;
5011 }
5012 {
5013 arg3 = PyList_Size(obj2);
5014 arg4 = wxString_LIST_helper(obj2);
5015 if (arg4 == NULL) SWIG_fail;
5016 }
5017 if (obj3) {
5018 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5019 if (SWIG_arg_fail(5)) SWIG_fail;
5020 }
5021 if (obj4) {
5022 {
5023 arg6 = (int)(SWIG_As_int(obj4));
5024 if (SWIG_arg_fail(6)) SWIG_fail;
5025 }
5026 }
5027 if (obj5) {
5028 {
5029 arg7 = (int)(SWIG_As_int(obj5));
5030 if (SWIG_arg_fail(7)) SWIG_fail;
5031 }
5032 }
5033 if (obj6) {
5034 {
5035 arg8 = (bool)(SWIG_As_bool(obj6));
5036 if (SWIG_arg_fail(8)) SWIG_fail;
5037 }
5038 }
5039 if (obj7) {
5040 {
5041 arg9 = (int)(SWIG_As_int(obj7));
5042 if (SWIG_arg_fail(9)) SWIG_fail;
5043 }
5044 }
5045 if (obj8) {
5046 {
5047 arg10 = (int)(SWIG_As_int(obj8));
5048 if (SWIG_arg_fail(10)) SWIG_fail;
5049 }
5050 }
5051 {
5052 if (!wxPyCheckForApp()) SWIG_fail;
5053 PyThreadState* __tstate = wxPyBeginAllowThreads();
5054 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5055
5056 wxPyEndAllowThreads(__tstate);
5057 if (PyErr_Occurred()) SWIG_fail;
5058 }
5059 {
5060 #if wxUSE_UNICODE
5061 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5062 #else
5063 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5064 #endif
5065 }
5066 {
5067 if (temp1)
5068 delete arg1;
5069 }
5070 {
5071 if (temp2)
5072 delete arg2;
5073 }
5074 {
5075 if (arg4) delete [] arg4;
5076 }
5077 return resultobj;
5078 fail:
5079 {
5080 if (temp1)
5081 delete arg1;
5082 }
5083 {
5084 if (temp2)
5085 delete arg2;
5086 }
5087 {
5088 if (arg4) delete [] arg4;
5089 }
5090 return NULL;
5091 }
5092
5093
5094 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5095 PyObject *resultobj;
5096 wxString *arg1 = 0 ;
5097 wxString *arg2 = 0 ;
5098 int arg3 ;
5099 wxString *arg4 = (wxString *) 0 ;
5100 wxWindow *arg5 = (wxWindow *) NULL ;
5101 int arg6 = (int) -1 ;
5102 int arg7 = (int) -1 ;
5103 bool arg8 = (bool) true ;
5104 int arg9 = (int) 150 ;
5105 int arg10 = (int) 200 ;
5106 int result;
5107 bool temp1 = false ;
5108 bool temp2 = false ;
5109 PyObject * obj0 = 0 ;
5110 PyObject * obj1 = 0 ;
5111 PyObject * obj2 = 0 ;
5112 PyObject * obj3 = 0 ;
5113 PyObject * obj4 = 0 ;
5114 PyObject * obj5 = 0 ;
5115 PyObject * obj6 = 0 ;
5116 PyObject * obj7 = 0 ;
5117 PyObject * obj8 = 0 ;
5118 char *kwnames[] = {
5119 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5120 };
5121
5122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5123 {
5124 arg1 = wxString_in_helper(obj0);
5125 if (arg1 == NULL) SWIG_fail;
5126 temp1 = true;
5127 }
5128 {
5129 arg2 = wxString_in_helper(obj1);
5130 if (arg2 == NULL) SWIG_fail;
5131 temp2 = true;
5132 }
5133 {
5134 arg3 = PyList_Size(obj2);
5135 arg4 = wxString_LIST_helper(obj2);
5136 if (arg4 == NULL) SWIG_fail;
5137 }
5138 if (obj3) {
5139 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5140 if (SWIG_arg_fail(5)) SWIG_fail;
5141 }
5142 if (obj4) {
5143 {
5144 arg6 = (int)(SWIG_As_int(obj4));
5145 if (SWIG_arg_fail(6)) SWIG_fail;
5146 }
5147 }
5148 if (obj5) {
5149 {
5150 arg7 = (int)(SWIG_As_int(obj5));
5151 if (SWIG_arg_fail(7)) SWIG_fail;
5152 }
5153 }
5154 if (obj6) {
5155 {
5156 arg8 = (bool)(SWIG_As_bool(obj6));
5157 if (SWIG_arg_fail(8)) SWIG_fail;
5158 }
5159 }
5160 if (obj7) {
5161 {
5162 arg9 = (int)(SWIG_As_int(obj7));
5163 if (SWIG_arg_fail(9)) SWIG_fail;
5164 }
5165 }
5166 if (obj8) {
5167 {
5168 arg10 = (int)(SWIG_As_int(obj8));
5169 if (SWIG_arg_fail(10)) SWIG_fail;
5170 }
5171 }
5172 {
5173 if (!wxPyCheckForApp()) SWIG_fail;
5174 PyThreadState* __tstate = wxPyBeginAllowThreads();
5175 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5176
5177 wxPyEndAllowThreads(__tstate);
5178 if (PyErr_Occurred()) SWIG_fail;
5179 }
5180 {
5181 resultobj = SWIG_From_int((int)(result));
5182 }
5183 {
5184 if (temp1)
5185 delete arg1;
5186 }
5187 {
5188 if (temp2)
5189 delete arg2;
5190 }
5191 {
5192 if (arg4) delete [] arg4;
5193 }
5194 return resultobj;
5195 fail:
5196 {
5197 if (temp1)
5198 delete arg1;
5199 }
5200 {
5201 if (temp2)
5202 delete arg2;
5203 }
5204 {
5205 if (arg4) delete [] arg4;
5206 }
5207 return NULL;
5208 }
5209
5210
5211 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5212 PyObject *resultobj;
5213 wxString *arg1 = 0 ;
5214 wxString const &arg2_defvalue = wxPyEmptyString ;
5215 wxString *arg2 = (wxString *) &arg2_defvalue ;
5216 int arg3 = (int) wxOK|wxCENTRE ;
5217 wxWindow *arg4 = (wxWindow *) NULL ;
5218 int arg5 = (int) -1 ;
5219 int arg6 = (int) -1 ;
5220 int result;
5221 bool temp1 = false ;
5222 bool temp2 = false ;
5223 PyObject * obj0 = 0 ;
5224 PyObject * obj1 = 0 ;
5225 PyObject * obj2 = 0 ;
5226 PyObject * obj3 = 0 ;
5227 PyObject * obj4 = 0 ;
5228 PyObject * obj5 = 0 ;
5229 char *kwnames[] = {
5230 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5231 };
5232
5233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5234 {
5235 arg1 = wxString_in_helper(obj0);
5236 if (arg1 == NULL) SWIG_fail;
5237 temp1 = true;
5238 }
5239 if (obj1) {
5240 {
5241 arg2 = wxString_in_helper(obj1);
5242 if (arg2 == NULL) SWIG_fail;
5243 temp2 = true;
5244 }
5245 }
5246 if (obj2) {
5247 {
5248 arg3 = (int)(SWIG_As_int(obj2));
5249 if (SWIG_arg_fail(3)) SWIG_fail;
5250 }
5251 }
5252 if (obj3) {
5253 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5254 if (SWIG_arg_fail(4)) SWIG_fail;
5255 }
5256 if (obj4) {
5257 {
5258 arg5 = (int)(SWIG_As_int(obj4));
5259 if (SWIG_arg_fail(5)) SWIG_fail;
5260 }
5261 }
5262 if (obj5) {
5263 {
5264 arg6 = (int)(SWIG_As_int(obj5));
5265 if (SWIG_arg_fail(6)) SWIG_fail;
5266 }
5267 }
5268 {
5269 if (!wxPyCheckForApp()) SWIG_fail;
5270 PyThreadState* __tstate = wxPyBeginAllowThreads();
5271 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5272
5273 wxPyEndAllowThreads(__tstate);
5274 if (PyErr_Occurred()) SWIG_fail;
5275 }
5276 {
5277 resultobj = SWIG_From_int((int)(result));
5278 }
5279 {
5280 if (temp1)
5281 delete arg1;
5282 }
5283 {
5284 if (temp2)
5285 delete arg2;
5286 }
5287 return resultobj;
5288 fail:
5289 {
5290 if (temp1)
5291 delete arg1;
5292 }
5293 {
5294 if (temp2)
5295 delete arg2;
5296 }
5297 return NULL;
5298 }
5299
5300
5301 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5302 PyObject *resultobj;
5303 wxString *arg1 = 0 ;
5304 wxString *arg2 = 0 ;
5305 wxString *arg3 = 0 ;
5306 long arg4 ;
5307 long arg5 = (long) 0 ;
5308 long arg6 = (long) 100 ;
5309 wxWindow *arg7 = (wxWindow *) NULL ;
5310 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5311 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5312 long result;
5313 bool temp1 = false ;
5314 bool temp2 = false ;
5315 bool temp3 = false ;
5316 wxPoint temp8 ;
5317 PyObject * obj0 = 0 ;
5318 PyObject * obj1 = 0 ;
5319 PyObject * obj2 = 0 ;
5320 PyObject * obj3 = 0 ;
5321 PyObject * obj4 = 0 ;
5322 PyObject * obj5 = 0 ;
5323 PyObject * obj6 = 0 ;
5324 PyObject * obj7 = 0 ;
5325 char *kwnames[] = {
5326 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5327 };
5328
5329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5330 {
5331 arg1 = wxString_in_helper(obj0);
5332 if (arg1 == NULL) SWIG_fail;
5333 temp1 = true;
5334 }
5335 {
5336 arg2 = wxString_in_helper(obj1);
5337 if (arg2 == NULL) SWIG_fail;
5338 temp2 = true;
5339 }
5340 {
5341 arg3 = wxString_in_helper(obj2);
5342 if (arg3 == NULL) SWIG_fail;
5343 temp3 = true;
5344 }
5345 {
5346 arg4 = (long)(SWIG_As_long(obj3));
5347 if (SWIG_arg_fail(4)) SWIG_fail;
5348 }
5349 if (obj4) {
5350 {
5351 arg5 = (long)(SWIG_As_long(obj4));
5352 if (SWIG_arg_fail(5)) SWIG_fail;
5353 }
5354 }
5355 if (obj5) {
5356 {
5357 arg6 = (long)(SWIG_As_long(obj5));
5358 if (SWIG_arg_fail(6)) SWIG_fail;
5359 }
5360 }
5361 if (obj6) {
5362 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5363 if (SWIG_arg_fail(7)) SWIG_fail;
5364 }
5365 if (obj7) {
5366 {
5367 arg8 = &temp8;
5368 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5369 }
5370 }
5371 {
5372 if (!wxPyCheckForApp()) SWIG_fail;
5373 PyThreadState* __tstate = wxPyBeginAllowThreads();
5374 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5375
5376 wxPyEndAllowThreads(__tstate);
5377 if (PyErr_Occurred()) SWIG_fail;
5378 }
5379 {
5380 resultobj = SWIG_From_long((long)(result));
5381 }
5382 {
5383 if (temp1)
5384 delete arg1;
5385 }
5386 {
5387 if (temp2)
5388 delete arg2;
5389 }
5390 {
5391 if (temp3)
5392 delete arg3;
5393 }
5394 return resultobj;
5395 fail:
5396 {
5397 if (temp1)
5398 delete arg1;
5399 }
5400 {
5401 if (temp2)
5402 delete arg2;
5403 }
5404 {
5405 if (temp3)
5406 delete arg3;
5407 }
5408 return NULL;
5409 }
5410
5411
5412 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5413 PyObject *resultobj;
5414 bool result;
5415 char *kwnames[] = {
5416 NULL
5417 };
5418
5419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5420 {
5421 if (!wxPyCheckForApp()) SWIG_fail;
5422 PyThreadState* __tstate = wxPyBeginAllowThreads();
5423 result = (bool)wxColourDisplay();
5424
5425 wxPyEndAllowThreads(__tstate);
5426 if (PyErr_Occurred()) SWIG_fail;
5427 }
5428 {
5429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5430 }
5431 return resultobj;
5432 fail:
5433 return NULL;
5434 }
5435
5436
5437 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5438 PyObject *resultobj;
5439 int result;
5440 char *kwnames[] = {
5441 NULL
5442 };
5443
5444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5445 {
5446 if (!wxPyCheckForApp()) SWIG_fail;
5447 PyThreadState* __tstate = wxPyBeginAllowThreads();
5448 result = (int)wxDisplayDepth();
5449
5450 wxPyEndAllowThreads(__tstate);
5451 if (PyErr_Occurred()) SWIG_fail;
5452 }
5453 {
5454 resultobj = SWIG_From_int((int)(result));
5455 }
5456 return resultobj;
5457 fail:
5458 return NULL;
5459 }
5460
5461
5462 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5463 PyObject *resultobj;
5464 int result;
5465 char *kwnames[] = {
5466 NULL
5467 };
5468
5469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5470 {
5471 if (!wxPyCheckForApp()) SWIG_fail;
5472 PyThreadState* __tstate = wxPyBeginAllowThreads();
5473 result = (int)wxGetDisplayDepth();
5474
5475 wxPyEndAllowThreads(__tstate);
5476 if (PyErr_Occurred()) SWIG_fail;
5477 }
5478 {
5479 resultobj = SWIG_From_int((int)(result));
5480 }
5481 return resultobj;
5482 fail:
5483 return NULL;
5484 }
5485
5486
5487 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5488 PyObject *resultobj;
5489 int *arg1 = (int *) 0 ;
5490 int *arg2 = (int *) 0 ;
5491 int temp1 ;
5492 int res1 = 0 ;
5493 int temp2 ;
5494 int res2 = 0 ;
5495 char *kwnames[] = {
5496 NULL
5497 };
5498
5499 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5500 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5502 {
5503 if (!wxPyCheckForApp()) SWIG_fail;
5504 PyThreadState* __tstate = wxPyBeginAllowThreads();
5505 wxDisplaySize(arg1,arg2);
5506
5507 wxPyEndAllowThreads(__tstate);
5508 if (PyErr_Occurred()) SWIG_fail;
5509 }
5510 Py_INCREF(Py_None); resultobj = Py_None;
5511 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5512 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5513 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5514 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5515 return resultobj;
5516 fail:
5517 return NULL;
5518 }
5519
5520
5521 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5522 PyObject *resultobj;
5523 wxSize result;
5524 char *kwnames[] = {
5525 NULL
5526 };
5527
5528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5529 {
5530 if (!wxPyCheckForApp()) SWIG_fail;
5531 PyThreadState* __tstate = wxPyBeginAllowThreads();
5532 result = wxGetDisplaySize();
5533
5534 wxPyEndAllowThreads(__tstate);
5535 if (PyErr_Occurred()) SWIG_fail;
5536 }
5537 {
5538 wxSize * resultptr;
5539 resultptr = new wxSize((wxSize &)(result));
5540 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5541 }
5542 return resultobj;
5543 fail:
5544 return NULL;
5545 }
5546
5547
5548 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5549 PyObject *resultobj;
5550 int *arg1 = (int *) 0 ;
5551 int *arg2 = (int *) 0 ;
5552 int temp1 ;
5553 int res1 = 0 ;
5554 int temp2 ;
5555 int res2 = 0 ;
5556 char *kwnames[] = {
5557 NULL
5558 };
5559
5560 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5561 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5563 {
5564 if (!wxPyCheckForApp()) SWIG_fail;
5565 PyThreadState* __tstate = wxPyBeginAllowThreads();
5566 wxDisplaySizeMM(arg1,arg2);
5567
5568 wxPyEndAllowThreads(__tstate);
5569 if (PyErr_Occurred()) SWIG_fail;
5570 }
5571 Py_INCREF(Py_None); resultobj = Py_None;
5572 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5573 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5574 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5575 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5576 return resultobj;
5577 fail:
5578 return NULL;
5579 }
5580
5581
5582 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5583 PyObject *resultobj;
5584 wxSize result;
5585 char *kwnames[] = {
5586 NULL
5587 };
5588
5589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5590 {
5591 if (!wxPyCheckForApp()) SWIG_fail;
5592 PyThreadState* __tstate = wxPyBeginAllowThreads();
5593 result = wxGetDisplaySizeMM();
5594
5595 wxPyEndAllowThreads(__tstate);
5596 if (PyErr_Occurred()) SWIG_fail;
5597 }
5598 {
5599 wxSize * resultptr;
5600 resultptr = new wxSize((wxSize &)(result));
5601 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5602 }
5603 return resultobj;
5604 fail:
5605 return NULL;
5606 }
5607
5608
5609 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5610 PyObject *resultobj;
5611 int *arg1 = (int *) 0 ;
5612 int *arg2 = (int *) 0 ;
5613 int *arg3 = (int *) 0 ;
5614 int *arg4 = (int *) 0 ;
5615 int temp1 ;
5616 int res1 = 0 ;
5617 int temp2 ;
5618 int res2 = 0 ;
5619 int temp3 ;
5620 int res3 = 0 ;
5621 int temp4 ;
5622 int res4 = 0 ;
5623 char *kwnames[] = {
5624 NULL
5625 };
5626
5627 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5628 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5629 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5630 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5632 {
5633 if (!wxPyCheckForApp()) SWIG_fail;
5634 PyThreadState* __tstate = wxPyBeginAllowThreads();
5635 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5636
5637 wxPyEndAllowThreads(__tstate);
5638 if (PyErr_Occurred()) SWIG_fail;
5639 }
5640 Py_INCREF(Py_None); resultobj = Py_None;
5641 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5642 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5643 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5644 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5645 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5646 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5647 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5648 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5649 return resultobj;
5650 fail:
5651 return NULL;
5652 }
5653
5654
5655 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5656 PyObject *resultobj;
5657 wxRect result;
5658 char *kwnames[] = {
5659 NULL
5660 };
5661
5662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5663 {
5664 if (!wxPyCheckForApp()) SWIG_fail;
5665 PyThreadState* __tstate = wxPyBeginAllowThreads();
5666 result = wxGetClientDisplayRect();
5667
5668 wxPyEndAllowThreads(__tstate);
5669 if (PyErr_Occurred()) SWIG_fail;
5670 }
5671 {
5672 wxRect * resultptr;
5673 resultptr = new wxRect((wxRect &)(result));
5674 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5675 }
5676 return resultobj;
5677 fail:
5678 return NULL;
5679 }
5680
5681
5682 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5683 PyObject *resultobj;
5684 wxCursor *arg1 = 0 ;
5685 PyObject * obj0 = 0 ;
5686 char *kwnames[] = {
5687 (char *) "cursor", NULL
5688 };
5689
5690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5691 {
5692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5693 if (SWIG_arg_fail(1)) SWIG_fail;
5694 if (arg1 == NULL) {
5695 SWIG_null_ref("wxCursor");
5696 }
5697 if (SWIG_arg_fail(1)) SWIG_fail;
5698 }
5699 {
5700 if (!wxPyCheckForApp()) SWIG_fail;
5701 PyThreadState* __tstate = wxPyBeginAllowThreads();
5702 wxSetCursor(*arg1);
5703
5704 wxPyEndAllowThreads(__tstate);
5705 if (PyErr_Occurred()) SWIG_fail;
5706 }
5707 Py_INCREF(Py_None); resultobj = Py_None;
5708 return resultobj;
5709 fail:
5710 return NULL;
5711 }
5712
5713
5714 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5715 PyObject *resultobj;
5716 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5717 PyObject * obj0 = 0 ;
5718 char *kwnames[] = {
5719 (char *) "cursor", NULL
5720 };
5721
5722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5723 if (obj0) {
5724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5725 if (SWIG_arg_fail(1)) SWIG_fail;
5726 }
5727 {
5728 if (!wxPyCheckForApp()) SWIG_fail;
5729 PyThreadState* __tstate = wxPyBeginAllowThreads();
5730 wxBeginBusyCursor(arg1);
5731
5732 wxPyEndAllowThreads(__tstate);
5733 if (PyErr_Occurred()) SWIG_fail;
5734 }
5735 Py_INCREF(Py_None); resultobj = Py_None;
5736 return resultobj;
5737 fail:
5738 return NULL;
5739 }
5740
5741
5742 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5743 PyObject *resultobj;
5744 wxWindow *result;
5745 char *kwnames[] = {
5746 NULL
5747 };
5748
5749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5750 {
5751 if (!wxPyCheckForApp()) SWIG_fail;
5752 PyThreadState* __tstate = wxPyBeginAllowThreads();
5753 result = (wxWindow *)wxGetActiveWindow();
5754
5755 wxPyEndAllowThreads(__tstate);
5756 if (PyErr_Occurred()) SWIG_fail;
5757 }
5758 {
5759 resultobj = wxPyMake_wxObject(result, 0);
5760 }
5761 return resultobj;
5762 fail:
5763 return NULL;
5764 }
5765
5766
5767 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5768 PyObject *resultobj;
5769 wxPoint *arg1 = 0 ;
5770 wxWindow *result;
5771 wxPoint temp1 ;
5772 PyObject * obj0 = 0 ;
5773 char *kwnames[] = {
5774 (char *) "pt", NULL
5775 };
5776
5777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5778 {
5779 arg1 = &temp1;
5780 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5781 }
5782 {
5783 if (!wxPyCheckForApp()) SWIG_fail;
5784 PyThreadState* __tstate = wxPyBeginAllowThreads();
5785 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5786
5787 wxPyEndAllowThreads(__tstate);
5788 if (PyErr_Occurred()) SWIG_fail;
5789 }
5790 {
5791 resultobj = wxPyMake_wxObject(result, 0);
5792 }
5793 return resultobj;
5794 fail:
5795 return NULL;
5796 }
5797
5798
5799 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5800 PyObject *resultobj;
5801 wxPoint *arg1 = 0 ;
5802 wxWindow *result;
5803 wxPoint temp1 ;
5804 PyObject * obj0 = 0 ;
5805 char *kwnames[] = {
5806 (char *) "pt", NULL
5807 };
5808
5809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5810 {
5811 arg1 = &temp1;
5812 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5813 }
5814 {
5815 if (!wxPyCheckForApp()) SWIG_fail;
5816 PyThreadState* __tstate = wxPyBeginAllowThreads();
5817 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5818
5819 wxPyEndAllowThreads(__tstate);
5820 if (PyErr_Occurred()) SWIG_fail;
5821 }
5822 {
5823 resultobj = wxPyMake_wxObject(result, 0);
5824 }
5825 return resultobj;
5826 fail:
5827 return NULL;
5828 }
5829
5830
5831 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5832 PyObject *resultobj;
5833 wxWindow *arg1 = (wxWindow *) 0 ;
5834 wxWindow *result;
5835 PyObject * obj0 = 0 ;
5836 char *kwnames[] = {
5837 (char *) "win", NULL
5838 };
5839
5840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5842 if (SWIG_arg_fail(1)) SWIG_fail;
5843 {
5844 if (!wxPyCheckForApp()) SWIG_fail;
5845 PyThreadState* __tstate = wxPyBeginAllowThreads();
5846 result = (wxWindow *)wxGetTopLevelParent(arg1);
5847
5848 wxPyEndAllowThreads(__tstate);
5849 if (PyErr_Occurred()) SWIG_fail;
5850 }
5851 {
5852 resultobj = wxPyMake_wxObject(result, 0);
5853 }
5854 return resultobj;
5855 fail:
5856 return NULL;
5857 }
5858
5859
5860 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5861 PyObject *resultobj;
5862 wxKeyCode arg1 ;
5863 bool result;
5864 PyObject * obj0 = 0 ;
5865 char *kwnames[] = {
5866 (char *) "key", NULL
5867 };
5868
5869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5870 {
5871 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5872 if (SWIG_arg_fail(1)) SWIG_fail;
5873 }
5874 {
5875 if (!wxPyCheckForApp()) SWIG_fail;
5876 PyThreadState* __tstate = wxPyBeginAllowThreads();
5877 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5878
5879 wxPyEndAllowThreads(__tstate);
5880 if (PyErr_Occurred()) SWIG_fail;
5881 }
5882 {
5883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5884 }
5885 return resultobj;
5886 fail:
5887 return NULL;
5888 }
5889
5890
5891 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5892 PyObject *resultobj;
5893 char *kwnames[] = {
5894 NULL
5895 };
5896
5897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5898 {
5899 if (!wxPyCheckForApp()) SWIG_fail;
5900 PyThreadState* __tstate = wxPyBeginAllowThreads();
5901 wxWakeUpMainThread();
5902
5903 wxPyEndAllowThreads(__tstate);
5904 if (PyErr_Occurred()) SWIG_fail;
5905 }
5906 Py_INCREF(Py_None); resultobj = Py_None;
5907 return resultobj;
5908 fail:
5909 return NULL;
5910 }
5911
5912
5913 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
5914 PyObject *resultobj;
5915 char *kwnames[] = {
5916 NULL
5917 };
5918
5919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
5920 {
5921 if (!wxPyCheckForApp()) SWIG_fail;
5922 PyThreadState* __tstate = wxPyBeginAllowThreads();
5923 wxMutexGuiEnter();
5924
5925 wxPyEndAllowThreads(__tstate);
5926 if (PyErr_Occurred()) SWIG_fail;
5927 }
5928 Py_INCREF(Py_None); resultobj = Py_None;
5929 return resultobj;
5930 fail:
5931 return NULL;
5932 }
5933
5934
5935 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
5936 PyObject *resultobj;
5937 char *kwnames[] = {
5938 NULL
5939 };
5940
5941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
5942 {
5943 if (!wxPyCheckForApp()) SWIG_fail;
5944 PyThreadState* __tstate = wxPyBeginAllowThreads();
5945 wxMutexGuiLeave();
5946
5947 wxPyEndAllowThreads(__tstate);
5948 if (PyErr_Occurred()) SWIG_fail;
5949 }
5950 Py_INCREF(Py_None); resultobj = Py_None;
5951 return resultobj;
5952 fail:
5953 return NULL;
5954 }
5955
5956
5957 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5958 PyObject *resultobj;
5959 wxMutexGuiLocker *result;
5960 char *kwnames[] = {
5961 NULL
5962 };
5963
5964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
5965 {
5966 if (!wxPyCheckForApp()) SWIG_fail;
5967 PyThreadState* __tstate = wxPyBeginAllowThreads();
5968 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
5969
5970 wxPyEndAllowThreads(__tstate);
5971 if (PyErr_Occurred()) SWIG_fail;
5972 }
5973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
5974 return resultobj;
5975 fail:
5976 return NULL;
5977 }
5978
5979
5980 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
5981 PyObject *resultobj;
5982 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
5983 PyObject * obj0 = 0 ;
5984 char *kwnames[] = {
5985 (char *) "self", NULL
5986 };
5987
5988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
5989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
5990 if (SWIG_arg_fail(1)) SWIG_fail;
5991 {
5992 PyThreadState* __tstate = wxPyBeginAllowThreads();
5993 delete arg1;
5994
5995 wxPyEndAllowThreads(__tstate);
5996 if (PyErr_Occurred()) SWIG_fail;
5997 }
5998 Py_INCREF(Py_None); resultobj = Py_None;
5999 return resultobj;
6000 fail:
6001 return NULL;
6002 }
6003
6004
6005 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6006 PyObject *obj;
6007 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6008 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6009 Py_INCREF(obj);
6010 return Py_BuildValue((char *)"");
6011 }
6012 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6013 PyObject *resultobj;
6014 bool result;
6015 char *kwnames[] = {
6016 NULL
6017 };
6018
6019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6020 {
6021 PyThreadState* __tstate = wxPyBeginAllowThreads();
6022 result = (bool)wxThread_IsMain();
6023
6024 wxPyEndAllowThreads(__tstate);
6025 if (PyErr_Occurred()) SWIG_fail;
6026 }
6027 {
6028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6029 }
6030 return resultobj;
6031 fail:
6032 return NULL;
6033 }
6034
6035
6036 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6037 PyObject *resultobj;
6038 wxString *arg1 = 0 ;
6039 wxToolTip *result;
6040 bool temp1 = false ;
6041 PyObject * obj0 = 0 ;
6042 char *kwnames[] = {
6043 (char *) "tip", NULL
6044 };
6045
6046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6047 {
6048 arg1 = wxString_in_helper(obj0);
6049 if (arg1 == NULL) SWIG_fail;
6050 temp1 = true;
6051 }
6052 {
6053 if (!wxPyCheckForApp()) SWIG_fail;
6054 PyThreadState* __tstate = wxPyBeginAllowThreads();
6055 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6056
6057 wxPyEndAllowThreads(__tstate);
6058 if (PyErr_Occurred()) SWIG_fail;
6059 }
6060 {
6061 resultobj = wxPyMake_wxObject(result, 1);
6062 }
6063 {
6064 if (temp1)
6065 delete arg1;
6066 }
6067 return resultobj;
6068 fail:
6069 {
6070 if (temp1)
6071 delete arg1;
6072 }
6073 return NULL;
6074 }
6075
6076
6077 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6078 PyObject *resultobj;
6079 wxToolTip *arg1 = (wxToolTip *) 0 ;
6080 wxString *arg2 = 0 ;
6081 bool temp2 = false ;
6082 PyObject * obj0 = 0 ;
6083 PyObject * obj1 = 0 ;
6084 char *kwnames[] = {
6085 (char *) "self",(char *) "tip", NULL
6086 };
6087
6088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6090 if (SWIG_arg_fail(1)) SWIG_fail;
6091 {
6092 arg2 = wxString_in_helper(obj1);
6093 if (arg2 == NULL) SWIG_fail;
6094 temp2 = true;
6095 }
6096 {
6097 PyThreadState* __tstate = wxPyBeginAllowThreads();
6098 (arg1)->SetTip((wxString const &)*arg2);
6099
6100 wxPyEndAllowThreads(__tstate);
6101 if (PyErr_Occurred()) SWIG_fail;
6102 }
6103 Py_INCREF(Py_None); resultobj = Py_None;
6104 {
6105 if (temp2)
6106 delete arg2;
6107 }
6108 return resultobj;
6109 fail:
6110 {
6111 if (temp2)
6112 delete arg2;
6113 }
6114 return NULL;
6115 }
6116
6117
6118 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6119 PyObject *resultobj;
6120 wxToolTip *arg1 = (wxToolTip *) 0 ;
6121 wxString result;
6122 PyObject * obj0 = 0 ;
6123 char *kwnames[] = {
6124 (char *) "self", NULL
6125 };
6126
6127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6129 if (SWIG_arg_fail(1)) SWIG_fail;
6130 {
6131 PyThreadState* __tstate = wxPyBeginAllowThreads();
6132 result = (arg1)->GetTip();
6133
6134 wxPyEndAllowThreads(__tstate);
6135 if (PyErr_Occurred()) SWIG_fail;
6136 }
6137 {
6138 #if wxUSE_UNICODE
6139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6140 #else
6141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6142 #endif
6143 }
6144 return resultobj;
6145 fail:
6146 return NULL;
6147 }
6148
6149
6150 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6151 PyObject *resultobj;
6152 wxToolTip *arg1 = (wxToolTip *) 0 ;
6153 wxWindow *result;
6154 PyObject * obj0 = 0 ;
6155 char *kwnames[] = {
6156 (char *) "self", NULL
6157 };
6158
6159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6161 if (SWIG_arg_fail(1)) SWIG_fail;
6162 {
6163 PyThreadState* __tstate = wxPyBeginAllowThreads();
6164 result = (wxWindow *)(arg1)->GetWindow();
6165
6166 wxPyEndAllowThreads(__tstate);
6167 if (PyErr_Occurred()) SWIG_fail;
6168 }
6169 {
6170 resultobj = wxPyMake_wxObject(result, 0);
6171 }
6172 return resultobj;
6173 fail:
6174 return NULL;
6175 }
6176
6177
6178 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6179 PyObject *resultobj;
6180 bool arg1 ;
6181 PyObject * obj0 = 0 ;
6182 char *kwnames[] = {
6183 (char *) "flag", NULL
6184 };
6185
6186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6187 {
6188 arg1 = (bool)(SWIG_As_bool(obj0));
6189 if (SWIG_arg_fail(1)) SWIG_fail;
6190 }
6191 {
6192 PyThreadState* __tstate = wxPyBeginAllowThreads();
6193 wxToolTip::Enable(arg1);
6194
6195 wxPyEndAllowThreads(__tstate);
6196 if (PyErr_Occurred()) SWIG_fail;
6197 }
6198 Py_INCREF(Py_None); resultobj = Py_None;
6199 return resultobj;
6200 fail:
6201 return NULL;
6202 }
6203
6204
6205 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6206 PyObject *resultobj;
6207 long arg1 ;
6208 PyObject * obj0 = 0 ;
6209 char *kwnames[] = {
6210 (char *) "milliseconds", NULL
6211 };
6212
6213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6214 {
6215 arg1 = (long)(SWIG_As_long(obj0));
6216 if (SWIG_arg_fail(1)) SWIG_fail;
6217 }
6218 {
6219 PyThreadState* __tstate = wxPyBeginAllowThreads();
6220 wxToolTip::SetDelay(arg1);
6221
6222 wxPyEndAllowThreads(__tstate);
6223 if (PyErr_Occurred()) SWIG_fail;
6224 }
6225 Py_INCREF(Py_None); resultobj = Py_None;
6226 return resultobj;
6227 fail:
6228 return NULL;
6229 }
6230
6231
6232 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6233 PyObject *obj;
6234 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6235 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6236 Py_INCREF(obj);
6237 return Py_BuildValue((char *)"");
6238 }
6239 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6240 PyObject *resultobj;
6241 wxWindow *arg1 = (wxWindow *) 0 ;
6242 wxSize *arg2 = 0 ;
6243 wxCaret *result;
6244 wxSize temp2 ;
6245 PyObject * obj0 = 0 ;
6246 PyObject * obj1 = 0 ;
6247 char *kwnames[] = {
6248 (char *) "window",(char *) "size", NULL
6249 };
6250
6251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6253 if (SWIG_arg_fail(1)) SWIG_fail;
6254 {
6255 arg2 = &temp2;
6256 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6257 }
6258 {
6259 if (!wxPyCheckForApp()) SWIG_fail;
6260 PyThreadState* __tstate = wxPyBeginAllowThreads();
6261 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6262
6263 wxPyEndAllowThreads(__tstate);
6264 if (PyErr_Occurred()) SWIG_fail;
6265 }
6266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6267 return resultobj;
6268 fail:
6269 return NULL;
6270 }
6271
6272
6273 static PyObject *_wrap_delete_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6274 PyObject *resultobj;
6275 wxCaret *arg1 = (wxCaret *) 0 ;
6276 PyObject * obj0 = 0 ;
6277 char *kwnames[] = {
6278 (char *) "self", NULL
6279 };
6280
6281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Caret",kwnames,&obj0)) goto fail;
6282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6283 if (SWIG_arg_fail(1)) SWIG_fail;
6284 {
6285 PyThreadState* __tstate = wxPyBeginAllowThreads();
6286 delete arg1;
6287
6288 wxPyEndAllowThreads(__tstate);
6289 if (PyErr_Occurred()) SWIG_fail;
6290 }
6291 Py_INCREF(Py_None); resultobj = Py_None;
6292 return resultobj;
6293 fail:
6294 return NULL;
6295 }
6296
6297
6298 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6299 PyObject *resultobj;
6300 wxCaret *arg1 = (wxCaret *) 0 ;
6301 bool result;
6302 PyObject * obj0 = 0 ;
6303 char *kwnames[] = {
6304 (char *) "self", NULL
6305 };
6306
6307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6309 if (SWIG_arg_fail(1)) SWIG_fail;
6310 {
6311 PyThreadState* __tstate = wxPyBeginAllowThreads();
6312 result = (bool)(arg1)->IsOk();
6313
6314 wxPyEndAllowThreads(__tstate);
6315 if (PyErr_Occurred()) SWIG_fail;
6316 }
6317 {
6318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6319 }
6320 return resultobj;
6321 fail:
6322 return NULL;
6323 }
6324
6325
6326 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6327 PyObject *resultobj;
6328 wxCaret *arg1 = (wxCaret *) 0 ;
6329 bool result;
6330 PyObject * obj0 = 0 ;
6331 char *kwnames[] = {
6332 (char *) "self", NULL
6333 };
6334
6335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6337 if (SWIG_arg_fail(1)) SWIG_fail;
6338 {
6339 PyThreadState* __tstate = wxPyBeginAllowThreads();
6340 result = (bool)(arg1)->IsVisible();
6341
6342 wxPyEndAllowThreads(__tstate);
6343 if (PyErr_Occurred()) SWIG_fail;
6344 }
6345 {
6346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6347 }
6348 return resultobj;
6349 fail:
6350 return NULL;
6351 }
6352
6353
6354 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6355 PyObject *resultobj;
6356 wxCaret *arg1 = (wxCaret *) 0 ;
6357 wxPoint result;
6358 PyObject * obj0 = 0 ;
6359 char *kwnames[] = {
6360 (char *) "self", NULL
6361 };
6362
6363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6365 if (SWIG_arg_fail(1)) SWIG_fail;
6366 {
6367 PyThreadState* __tstate = wxPyBeginAllowThreads();
6368 result = (arg1)->GetPosition();
6369
6370 wxPyEndAllowThreads(__tstate);
6371 if (PyErr_Occurred()) SWIG_fail;
6372 }
6373 {
6374 wxPoint * resultptr;
6375 resultptr = new wxPoint((wxPoint &)(result));
6376 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6377 }
6378 return resultobj;
6379 fail:
6380 return NULL;
6381 }
6382
6383
6384 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6385 PyObject *resultobj;
6386 wxCaret *arg1 = (wxCaret *) 0 ;
6387 int *arg2 = (int *) 0 ;
6388 int *arg3 = (int *) 0 ;
6389 int temp2 ;
6390 int res2 = 0 ;
6391 int temp3 ;
6392 int res3 = 0 ;
6393 PyObject * obj0 = 0 ;
6394 char *kwnames[] = {
6395 (char *) "self", NULL
6396 };
6397
6398 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6399 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6402 if (SWIG_arg_fail(1)) SWIG_fail;
6403 {
6404 PyThreadState* __tstate = wxPyBeginAllowThreads();
6405 (arg1)->GetPosition(arg2,arg3);
6406
6407 wxPyEndAllowThreads(__tstate);
6408 if (PyErr_Occurred()) SWIG_fail;
6409 }
6410 Py_INCREF(Py_None); resultobj = Py_None;
6411 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6412 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6413 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6414 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6415 return resultobj;
6416 fail:
6417 return NULL;
6418 }
6419
6420
6421 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6422 PyObject *resultobj;
6423 wxCaret *arg1 = (wxCaret *) 0 ;
6424 wxSize result;
6425 PyObject * obj0 = 0 ;
6426 char *kwnames[] = {
6427 (char *) "self", NULL
6428 };
6429
6430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6432 if (SWIG_arg_fail(1)) SWIG_fail;
6433 {
6434 PyThreadState* __tstate = wxPyBeginAllowThreads();
6435 result = (arg1)->GetSize();
6436
6437 wxPyEndAllowThreads(__tstate);
6438 if (PyErr_Occurred()) SWIG_fail;
6439 }
6440 {
6441 wxSize * resultptr;
6442 resultptr = new wxSize((wxSize &)(result));
6443 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6444 }
6445 return resultobj;
6446 fail:
6447 return NULL;
6448 }
6449
6450
6451 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6452 PyObject *resultobj;
6453 wxCaret *arg1 = (wxCaret *) 0 ;
6454 int *arg2 = (int *) 0 ;
6455 int *arg3 = (int *) 0 ;
6456 int temp2 ;
6457 int res2 = 0 ;
6458 int temp3 ;
6459 int res3 = 0 ;
6460 PyObject * obj0 = 0 ;
6461 char *kwnames[] = {
6462 (char *) "self", NULL
6463 };
6464
6465 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6466 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6469 if (SWIG_arg_fail(1)) SWIG_fail;
6470 {
6471 PyThreadState* __tstate = wxPyBeginAllowThreads();
6472 (arg1)->GetSize(arg2,arg3);
6473
6474 wxPyEndAllowThreads(__tstate);
6475 if (PyErr_Occurred()) SWIG_fail;
6476 }
6477 Py_INCREF(Py_None); resultobj = Py_None;
6478 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6479 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6480 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6481 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6482 return resultobj;
6483 fail:
6484 return NULL;
6485 }
6486
6487
6488 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6489 PyObject *resultobj;
6490 wxCaret *arg1 = (wxCaret *) 0 ;
6491 wxWindow *result;
6492 PyObject * obj0 = 0 ;
6493 char *kwnames[] = {
6494 (char *) "self", NULL
6495 };
6496
6497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6499 if (SWIG_arg_fail(1)) SWIG_fail;
6500 {
6501 PyThreadState* __tstate = wxPyBeginAllowThreads();
6502 result = (wxWindow *)(arg1)->GetWindow();
6503
6504 wxPyEndAllowThreads(__tstate);
6505 if (PyErr_Occurred()) SWIG_fail;
6506 }
6507 {
6508 resultobj = wxPyMake_wxObject(result, 0);
6509 }
6510 return resultobj;
6511 fail:
6512 return NULL;
6513 }
6514
6515
6516 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6517 PyObject *resultobj;
6518 wxCaret *arg1 = (wxCaret *) 0 ;
6519 int arg2 ;
6520 int arg3 ;
6521 PyObject * obj0 = 0 ;
6522 PyObject * obj1 = 0 ;
6523 PyObject * obj2 = 0 ;
6524 char *kwnames[] = {
6525 (char *) "self",(char *) "x",(char *) "y", NULL
6526 };
6527
6528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6530 if (SWIG_arg_fail(1)) SWIG_fail;
6531 {
6532 arg2 = (int)(SWIG_As_int(obj1));
6533 if (SWIG_arg_fail(2)) SWIG_fail;
6534 }
6535 {
6536 arg3 = (int)(SWIG_As_int(obj2));
6537 if (SWIG_arg_fail(3)) SWIG_fail;
6538 }
6539 {
6540 PyThreadState* __tstate = wxPyBeginAllowThreads();
6541 (arg1)->Move(arg2,arg3);
6542
6543 wxPyEndAllowThreads(__tstate);
6544 if (PyErr_Occurred()) SWIG_fail;
6545 }
6546 Py_INCREF(Py_None); resultobj = Py_None;
6547 return resultobj;
6548 fail:
6549 return NULL;
6550 }
6551
6552
6553 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6554 PyObject *resultobj;
6555 wxCaret *arg1 = (wxCaret *) 0 ;
6556 wxPoint *arg2 = 0 ;
6557 wxPoint temp2 ;
6558 PyObject * obj0 = 0 ;
6559 PyObject * obj1 = 0 ;
6560 char *kwnames[] = {
6561 (char *) "self",(char *) "pt", NULL
6562 };
6563
6564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6566 if (SWIG_arg_fail(1)) SWIG_fail;
6567 {
6568 arg2 = &temp2;
6569 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6570 }
6571 {
6572 PyThreadState* __tstate = wxPyBeginAllowThreads();
6573 (arg1)->Move((wxPoint const &)*arg2);
6574
6575 wxPyEndAllowThreads(__tstate);
6576 if (PyErr_Occurred()) SWIG_fail;
6577 }
6578 Py_INCREF(Py_None); resultobj = Py_None;
6579 return resultobj;
6580 fail:
6581 return NULL;
6582 }
6583
6584
6585 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6586 PyObject *resultobj;
6587 wxCaret *arg1 = (wxCaret *) 0 ;
6588 int arg2 ;
6589 int arg3 ;
6590 PyObject * obj0 = 0 ;
6591 PyObject * obj1 = 0 ;
6592 PyObject * obj2 = 0 ;
6593 char *kwnames[] = {
6594 (char *) "self",(char *) "width",(char *) "height", NULL
6595 };
6596
6597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6599 if (SWIG_arg_fail(1)) SWIG_fail;
6600 {
6601 arg2 = (int)(SWIG_As_int(obj1));
6602 if (SWIG_arg_fail(2)) SWIG_fail;
6603 }
6604 {
6605 arg3 = (int)(SWIG_As_int(obj2));
6606 if (SWIG_arg_fail(3)) SWIG_fail;
6607 }
6608 {
6609 PyThreadState* __tstate = wxPyBeginAllowThreads();
6610 (arg1)->SetSize(arg2,arg3);
6611
6612 wxPyEndAllowThreads(__tstate);
6613 if (PyErr_Occurred()) SWIG_fail;
6614 }
6615 Py_INCREF(Py_None); resultobj = Py_None;
6616 return resultobj;
6617 fail:
6618 return NULL;
6619 }
6620
6621
6622 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6623 PyObject *resultobj;
6624 wxCaret *arg1 = (wxCaret *) 0 ;
6625 wxSize *arg2 = 0 ;
6626 wxSize temp2 ;
6627 PyObject * obj0 = 0 ;
6628 PyObject * obj1 = 0 ;
6629 char *kwnames[] = {
6630 (char *) "self",(char *) "size", NULL
6631 };
6632
6633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6635 if (SWIG_arg_fail(1)) SWIG_fail;
6636 {
6637 arg2 = &temp2;
6638 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6639 }
6640 {
6641 PyThreadState* __tstate = wxPyBeginAllowThreads();
6642 (arg1)->SetSize((wxSize const &)*arg2);
6643
6644 wxPyEndAllowThreads(__tstate);
6645 if (PyErr_Occurred()) SWIG_fail;
6646 }
6647 Py_INCREF(Py_None); resultobj = Py_None;
6648 return resultobj;
6649 fail:
6650 return NULL;
6651 }
6652
6653
6654 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6655 PyObject *resultobj;
6656 wxCaret *arg1 = (wxCaret *) 0 ;
6657 int arg2 = (int) true ;
6658 PyObject * obj0 = 0 ;
6659 PyObject * obj1 = 0 ;
6660 char *kwnames[] = {
6661 (char *) "self",(char *) "show", NULL
6662 };
6663
6664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6666 if (SWIG_arg_fail(1)) SWIG_fail;
6667 if (obj1) {
6668 {
6669 arg2 = (int)(SWIG_As_int(obj1));
6670 if (SWIG_arg_fail(2)) SWIG_fail;
6671 }
6672 }
6673 {
6674 PyThreadState* __tstate = wxPyBeginAllowThreads();
6675 (arg1)->Show(arg2);
6676
6677 wxPyEndAllowThreads(__tstate);
6678 if (PyErr_Occurred()) SWIG_fail;
6679 }
6680 Py_INCREF(Py_None); resultobj = Py_None;
6681 return resultobj;
6682 fail:
6683 return NULL;
6684 }
6685
6686
6687 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6688 PyObject *resultobj;
6689 wxCaret *arg1 = (wxCaret *) 0 ;
6690 PyObject * obj0 = 0 ;
6691 char *kwnames[] = {
6692 (char *) "self", NULL
6693 };
6694
6695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6697 if (SWIG_arg_fail(1)) SWIG_fail;
6698 {
6699 PyThreadState* __tstate = wxPyBeginAllowThreads();
6700 (arg1)->Hide();
6701
6702 wxPyEndAllowThreads(__tstate);
6703 if (PyErr_Occurred()) SWIG_fail;
6704 }
6705 Py_INCREF(Py_None); resultobj = Py_None;
6706 return resultobj;
6707 fail:
6708 return NULL;
6709 }
6710
6711
6712 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6713 PyObject *obj;
6714 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6715 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6716 Py_INCREF(obj);
6717 return Py_BuildValue((char *)"");
6718 }
6719 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6720 PyObject *resultobj;
6721 int result;
6722 char *kwnames[] = {
6723 NULL
6724 };
6725
6726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6727 {
6728 PyThreadState* __tstate = wxPyBeginAllowThreads();
6729 result = (int)wxCaret_GetBlinkTime();
6730
6731 wxPyEndAllowThreads(__tstate);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 {
6735 resultobj = SWIG_From_int((int)(result));
6736 }
6737 return resultobj;
6738 fail:
6739 return NULL;
6740 }
6741
6742
6743 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6744 PyObject *resultobj;
6745 int arg1 ;
6746 PyObject * obj0 = 0 ;
6747 char *kwnames[] = {
6748 (char *) "milliseconds", NULL
6749 };
6750
6751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6752 {
6753 arg1 = (int)(SWIG_As_int(obj0));
6754 if (SWIG_arg_fail(1)) SWIG_fail;
6755 }
6756 {
6757 PyThreadState* __tstate = wxPyBeginAllowThreads();
6758 wxCaret_SetBlinkTime(arg1);
6759
6760 wxPyEndAllowThreads(__tstate);
6761 if (PyErr_Occurred()) SWIG_fail;
6762 }
6763 Py_INCREF(Py_None); resultobj = Py_None;
6764 return resultobj;
6765 fail:
6766 return NULL;
6767 }
6768
6769
6770 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6771 PyObject *resultobj;
6772 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6773 wxBusyCursor *result;
6774 PyObject * obj0 = 0 ;
6775 char *kwnames[] = {
6776 (char *) "cursor", NULL
6777 };
6778
6779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6780 if (obj0) {
6781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6782 if (SWIG_arg_fail(1)) SWIG_fail;
6783 }
6784 {
6785 if (!wxPyCheckForApp()) SWIG_fail;
6786 PyThreadState* __tstate = wxPyBeginAllowThreads();
6787 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6788
6789 wxPyEndAllowThreads(__tstate);
6790 if (PyErr_Occurred()) SWIG_fail;
6791 }
6792 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6793 return resultobj;
6794 fail:
6795 return NULL;
6796 }
6797
6798
6799 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6800 PyObject *resultobj;
6801 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6802 PyObject * obj0 = 0 ;
6803 char *kwnames[] = {
6804 (char *) "self", NULL
6805 };
6806
6807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6809 if (SWIG_arg_fail(1)) SWIG_fail;
6810 {
6811 PyThreadState* __tstate = wxPyBeginAllowThreads();
6812 delete arg1;
6813
6814 wxPyEndAllowThreads(__tstate);
6815 if (PyErr_Occurred()) SWIG_fail;
6816 }
6817 Py_INCREF(Py_None); resultobj = Py_None;
6818 return resultobj;
6819 fail:
6820 return NULL;
6821 }
6822
6823
6824 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6825 PyObject *obj;
6826 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6827 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6828 Py_INCREF(obj);
6829 return Py_BuildValue((char *)"");
6830 }
6831 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6832 PyObject *resultobj;
6833 wxWindow *arg1 = (wxWindow *) NULL ;
6834 wxWindowDisabler *result;
6835 PyObject * obj0 = 0 ;
6836 char *kwnames[] = {
6837 (char *) "winToSkip", NULL
6838 };
6839
6840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6841 if (obj0) {
6842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6843 if (SWIG_arg_fail(1)) SWIG_fail;
6844 }
6845 {
6846 if (!wxPyCheckForApp()) SWIG_fail;
6847 PyThreadState* __tstate = wxPyBeginAllowThreads();
6848 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6849
6850 wxPyEndAllowThreads(__tstate);
6851 if (PyErr_Occurred()) SWIG_fail;
6852 }
6853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6854 return resultobj;
6855 fail:
6856 return NULL;
6857 }
6858
6859
6860 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6861 PyObject *resultobj;
6862 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6863 PyObject * obj0 = 0 ;
6864 char *kwnames[] = {
6865 (char *) "self", NULL
6866 };
6867
6868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6870 if (SWIG_arg_fail(1)) SWIG_fail;
6871 {
6872 PyThreadState* __tstate = wxPyBeginAllowThreads();
6873 delete arg1;
6874
6875 wxPyEndAllowThreads(__tstate);
6876 if (PyErr_Occurred()) SWIG_fail;
6877 }
6878 Py_INCREF(Py_None); resultobj = Py_None;
6879 return resultobj;
6880 fail:
6881 return NULL;
6882 }
6883
6884
6885 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6886 PyObject *obj;
6887 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6888 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6889 Py_INCREF(obj);
6890 return Py_BuildValue((char *)"");
6891 }
6892 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6893 PyObject *resultobj;
6894 wxString *arg1 = 0 ;
6895 wxBusyInfo *result;
6896 bool temp1 = false ;
6897 PyObject * obj0 = 0 ;
6898 char *kwnames[] = {
6899 (char *) "message", NULL
6900 };
6901
6902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
6903 {
6904 arg1 = wxString_in_helper(obj0);
6905 if (arg1 == NULL) SWIG_fail;
6906 temp1 = true;
6907 }
6908 {
6909 if (!wxPyCheckForApp()) SWIG_fail;
6910 PyThreadState* __tstate = wxPyBeginAllowThreads();
6911 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
6912
6913 wxPyEndAllowThreads(__tstate);
6914 if (PyErr_Occurred()) SWIG_fail;
6915 }
6916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
6917 {
6918 if (temp1)
6919 delete arg1;
6920 }
6921 return resultobj;
6922 fail:
6923 {
6924 if (temp1)
6925 delete arg1;
6926 }
6927 return NULL;
6928 }
6929
6930
6931 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6932 PyObject *resultobj;
6933 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
6934 PyObject * obj0 = 0 ;
6935 char *kwnames[] = {
6936 (char *) "self", NULL
6937 };
6938
6939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
6940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
6941 if (SWIG_arg_fail(1)) SWIG_fail;
6942 {
6943 PyThreadState* __tstate = wxPyBeginAllowThreads();
6944 delete arg1;
6945
6946 wxPyEndAllowThreads(__tstate);
6947 if (PyErr_Occurred()) SWIG_fail;
6948 }
6949 Py_INCREF(Py_None); resultobj = Py_None;
6950 return resultobj;
6951 fail:
6952 return NULL;
6953 }
6954
6955
6956 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
6957 PyObject *obj;
6958 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6959 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
6960 Py_INCREF(obj);
6961 return Py_BuildValue((char *)"");
6962 }
6963 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
6964 PyObject *resultobj;
6965 wxStopWatch *result;
6966 char *kwnames[] = {
6967 NULL
6968 };
6969
6970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
6971 {
6972 PyThreadState* __tstate = wxPyBeginAllowThreads();
6973 result = (wxStopWatch *)new wxStopWatch();
6974
6975 wxPyEndAllowThreads(__tstate);
6976 if (PyErr_Occurred()) SWIG_fail;
6977 }
6978 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
6979 return resultobj;
6980 fail:
6981 return NULL;
6982 }
6983
6984
6985 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
6986 PyObject *resultobj;
6987 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
6988 long arg2 = (long) 0 ;
6989 PyObject * obj0 = 0 ;
6990 PyObject * obj1 = 0 ;
6991 char *kwnames[] = {
6992 (char *) "self",(char *) "t0", NULL
6993 };
6994
6995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
6996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
6997 if (SWIG_arg_fail(1)) SWIG_fail;
6998 if (obj1) {
6999 {
7000 arg2 = (long)(SWIG_As_long(obj1));
7001 if (SWIG_arg_fail(2)) SWIG_fail;
7002 }
7003 }
7004 {
7005 PyThreadState* __tstate = wxPyBeginAllowThreads();
7006 (arg1)->Start(arg2);
7007
7008 wxPyEndAllowThreads(__tstate);
7009 if (PyErr_Occurred()) SWIG_fail;
7010 }
7011 Py_INCREF(Py_None); resultobj = Py_None;
7012 return resultobj;
7013 fail:
7014 return NULL;
7015 }
7016
7017
7018 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7019 PyObject *resultobj;
7020 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7021 PyObject * obj0 = 0 ;
7022 char *kwnames[] = {
7023 (char *) "self", NULL
7024 };
7025
7026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7028 if (SWIG_arg_fail(1)) SWIG_fail;
7029 {
7030 PyThreadState* __tstate = wxPyBeginAllowThreads();
7031 (arg1)->Pause();
7032
7033 wxPyEndAllowThreads(__tstate);
7034 if (PyErr_Occurred()) SWIG_fail;
7035 }
7036 Py_INCREF(Py_None); resultobj = Py_None;
7037 return resultobj;
7038 fail:
7039 return NULL;
7040 }
7041
7042
7043 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7044 PyObject *resultobj;
7045 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7046 PyObject * obj0 = 0 ;
7047 char *kwnames[] = {
7048 (char *) "self", NULL
7049 };
7050
7051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7053 if (SWIG_arg_fail(1)) SWIG_fail;
7054 {
7055 PyThreadState* __tstate = wxPyBeginAllowThreads();
7056 (arg1)->Resume();
7057
7058 wxPyEndAllowThreads(__tstate);
7059 if (PyErr_Occurred()) SWIG_fail;
7060 }
7061 Py_INCREF(Py_None); resultobj = Py_None;
7062 return resultobj;
7063 fail:
7064 return NULL;
7065 }
7066
7067
7068 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7069 PyObject *resultobj;
7070 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7071 long result;
7072 PyObject * obj0 = 0 ;
7073 char *kwnames[] = {
7074 (char *) "self", NULL
7075 };
7076
7077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7079 if (SWIG_arg_fail(1)) SWIG_fail;
7080 {
7081 PyThreadState* __tstate = wxPyBeginAllowThreads();
7082 result = (long)((wxStopWatch const *)arg1)->Time();
7083
7084 wxPyEndAllowThreads(__tstate);
7085 if (PyErr_Occurred()) SWIG_fail;
7086 }
7087 {
7088 resultobj = SWIG_From_long((long)(result));
7089 }
7090 return resultobj;
7091 fail:
7092 return NULL;
7093 }
7094
7095
7096 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7097 PyObject *obj;
7098 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7099 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7100 Py_INCREF(obj);
7101 return Py_BuildValue((char *)"");
7102 }
7103 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7104 PyObject *resultobj;
7105 int arg1 = (int) 9 ;
7106 int arg2 = (int) wxID_FILE1 ;
7107 wxFileHistory *result;
7108 PyObject * obj0 = 0 ;
7109 PyObject * obj1 = 0 ;
7110 char *kwnames[] = {
7111 (char *) "maxFiles",(char *) "idBase", NULL
7112 };
7113
7114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7115 if (obj0) {
7116 {
7117 arg1 = (int)(SWIG_As_int(obj0));
7118 if (SWIG_arg_fail(1)) SWIG_fail;
7119 }
7120 }
7121 if (obj1) {
7122 {
7123 arg2 = (int)(SWIG_As_int(obj1));
7124 if (SWIG_arg_fail(2)) SWIG_fail;
7125 }
7126 }
7127 {
7128 PyThreadState* __tstate = wxPyBeginAllowThreads();
7129 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7130
7131 wxPyEndAllowThreads(__tstate);
7132 if (PyErr_Occurred()) SWIG_fail;
7133 }
7134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7135 return resultobj;
7136 fail:
7137 return NULL;
7138 }
7139
7140
7141 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7142 PyObject *resultobj;
7143 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7144 PyObject * obj0 = 0 ;
7145 char *kwnames[] = {
7146 (char *) "self", NULL
7147 };
7148
7149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7151 if (SWIG_arg_fail(1)) SWIG_fail;
7152 {
7153 PyThreadState* __tstate = wxPyBeginAllowThreads();
7154 delete arg1;
7155
7156 wxPyEndAllowThreads(__tstate);
7157 if (PyErr_Occurred()) SWIG_fail;
7158 }
7159 Py_INCREF(Py_None); resultobj = Py_None;
7160 return resultobj;
7161 fail:
7162 return NULL;
7163 }
7164
7165
7166 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7167 PyObject *resultobj;
7168 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7169 wxString *arg2 = 0 ;
7170 bool temp2 = false ;
7171 PyObject * obj0 = 0 ;
7172 PyObject * obj1 = 0 ;
7173 char *kwnames[] = {
7174 (char *) "self",(char *) "file", NULL
7175 };
7176
7177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7179 if (SWIG_arg_fail(1)) SWIG_fail;
7180 {
7181 arg2 = wxString_in_helper(obj1);
7182 if (arg2 == NULL) SWIG_fail;
7183 temp2 = true;
7184 }
7185 {
7186 PyThreadState* __tstate = wxPyBeginAllowThreads();
7187 (arg1)->AddFileToHistory((wxString const &)*arg2);
7188
7189 wxPyEndAllowThreads(__tstate);
7190 if (PyErr_Occurred()) SWIG_fail;
7191 }
7192 Py_INCREF(Py_None); resultobj = Py_None;
7193 {
7194 if (temp2)
7195 delete arg2;
7196 }
7197 return resultobj;
7198 fail:
7199 {
7200 if (temp2)
7201 delete arg2;
7202 }
7203 return NULL;
7204 }
7205
7206
7207 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7208 PyObject *resultobj;
7209 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7210 int arg2 ;
7211 PyObject * obj0 = 0 ;
7212 PyObject * obj1 = 0 ;
7213 char *kwnames[] = {
7214 (char *) "self",(char *) "i", NULL
7215 };
7216
7217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7219 if (SWIG_arg_fail(1)) SWIG_fail;
7220 {
7221 arg2 = (int)(SWIG_As_int(obj1));
7222 if (SWIG_arg_fail(2)) SWIG_fail;
7223 }
7224 {
7225 PyThreadState* __tstate = wxPyBeginAllowThreads();
7226 (arg1)->RemoveFileFromHistory(arg2);
7227
7228 wxPyEndAllowThreads(__tstate);
7229 if (PyErr_Occurred()) SWIG_fail;
7230 }
7231 Py_INCREF(Py_None); resultobj = Py_None;
7232 return resultobj;
7233 fail:
7234 return NULL;
7235 }
7236
7237
7238 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7239 PyObject *resultobj;
7240 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7241 int result;
7242 PyObject * obj0 = 0 ;
7243 char *kwnames[] = {
7244 (char *) "self", NULL
7245 };
7246
7247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7249 if (SWIG_arg_fail(1)) SWIG_fail;
7250 {
7251 PyThreadState* __tstate = wxPyBeginAllowThreads();
7252 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7253
7254 wxPyEndAllowThreads(__tstate);
7255 if (PyErr_Occurred()) SWIG_fail;
7256 }
7257 {
7258 resultobj = SWIG_From_int((int)(result));
7259 }
7260 return resultobj;
7261 fail:
7262 return NULL;
7263 }
7264
7265
7266 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7267 PyObject *resultobj;
7268 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7269 wxMenu *arg2 = (wxMenu *) 0 ;
7270 PyObject * obj0 = 0 ;
7271 PyObject * obj1 = 0 ;
7272 char *kwnames[] = {
7273 (char *) "self",(char *) "menu", NULL
7274 };
7275
7276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7278 if (SWIG_arg_fail(1)) SWIG_fail;
7279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7280 if (SWIG_arg_fail(2)) SWIG_fail;
7281 {
7282 PyThreadState* __tstate = wxPyBeginAllowThreads();
7283 (arg1)->UseMenu(arg2);
7284
7285 wxPyEndAllowThreads(__tstate);
7286 if (PyErr_Occurred()) SWIG_fail;
7287 }
7288 Py_INCREF(Py_None); resultobj = Py_None;
7289 return resultobj;
7290 fail:
7291 return NULL;
7292 }
7293
7294
7295 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7296 PyObject *resultobj;
7297 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7298 wxMenu *arg2 = (wxMenu *) 0 ;
7299 PyObject * obj0 = 0 ;
7300 PyObject * obj1 = 0 ;
7301 char *kwnames[] = {
7302 (char *) "self",(char *) "menu", NULL
7303 };
7304
7305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7307 if (SWIG_arg_fail(1)) SWIG_fail;
7308 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7309 if (SWIG_arg_fail(2)) SWIG_fail;
7310 {
7311 PyThreadState* __tstate = wxPyBeginAllowThreads();
7312 (arg1)->RemoveMenu(arg2);
7313
7314 wxPyEndAllowThreads(__tstate);
7315 if (PyErr_Occurred()) SWIG_fail;
7316 }
7317 Py_INCREF(Py_None); resultobj = Py_None;
7318 return resultobj;
7319 fail:
7320 return NULL;
7321 }
7322
7323
7324 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7325 PyObject *resultobj;
7326 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7327 wxConfigBase *arg2 = 0 ;
7328 PyObject * obj0 = 0 ;
7329 PyObject * obj1 = 0 ;
7330 char *kwnames[] = {
7331 (char *) "self",(char *) "config", NULL
7332 };
7333
7334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7336 if (SWIG_arg_fail(1)) SWIG_fail;
7337 {
7338 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7339 if (SWIG_arg_fail(2)) SWIG_fail;
7340 if (arg2 == NULL) {
7341 SWIG_null_ref("wxConfigBase");
7342 }
7343 if (SWIG_arg_fail(2)) SWIG_fail;
7344 }
7345 {
7346 PyThreadState* __tstate = wxPyBeginAllowThreads();
7347 (arg1)->Load(*arg2);
7348
7349 wxPyEndAllowThreads(__tstate);
7350 if (PyErr_Occurred()) SWIG_fail;
7351 }
7352 Py_INCREF(Py_None); resultobj = Py_None;
7353 return resultobj;
7354 fail:
7355 return NULL;
7356 }
7357
7358
7359 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7360 PyObject *resultobj;
7361 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7362 wxConfigBase *arg2 = 0 ;
7363 PyObject * obj0 = 0 ;
7364 PyObject * obj1 = 0 ;
7365 char *kwnames[] = {
7366 (char *) "self",(char *) "config", NULL
7367 };
7368
7369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7371 if (SWIG_arg_fail(1)) SWIG_fail;
7372 {
7373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7374 if (SWIG_arg_fail(2)) SWIG_fail;
7375 if (arg2 == NULL) {
7376 SWIG_null_ref("wxConfigBase");
7377 }
7378 if (SWIG_arg_fail(2)) SWIG_fail;
7379 }
7380 {
7381 PyThreadState* __tstate = wxPyBeginAllowThreads();
7382 (arg1)->Save(*arg2);
7383
7384 wxPyEndAllowThreads(__tstate);
7385 if (PyErr_Occurred()) SWIG_fail;
7386 }
7387 Py_INCREF(Py_None); resultobj = Py_None;
7388 return resultobj;
7389 fail:
7390 return NULL;
7391 }
7392
7393
7394 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7395 PyObject *resultobj;
7396 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7397 PyObject * obj0 = 0 ;
7398 char *kwnames[] = {
7399 (char *) "self", NULL
7400 };
7401
7402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7404 if (SWIG_arg_fail(1)) SWIG_fail;
7405 {
7406 PyThreadState* __tstate = wxPyBeginAllowThreads();
7407 (arg1)->AddFilesToMenu();
7408
7409 wxPyEndAllowThreads(__tstate);
7410 if (PyErr_Occurred()) SWIG_fail;
7411 }
7412 Py_INCREF(Py_None); resultobj = Py_None;
7413 return resultobj;
7414 fail:
7415 return NULL;
7416 }
7417
7418
7419 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7420 PyObject *resultobj;
7421 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7422 wxMenu *arg2 = (wxMenu *) 0 ;
7423 PyObject * obj0 = 0 ;
7424 PyObject * obj1 = 0 ;
7425 char *kwnames[] = {
7426 (char *) "self",(char *) "menu", NULL
7427 };
7428
7429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7431 if (SWIG_arg_fail(1)) SWIG_fail;
7432 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7433 if (SWIG_arg_fail(2)) SWIG_fail;
7434 {
7435 PyThreadState* __tstate = wxPyBeginAllowThreads();
7436 (arg1)->AddFilesToMenu(arg2);
7437
7438 wxPyEndAllowThreads(__tstate);
7439 if (PyErr_Occurred()) SWIG_fail;
7440 }
7441 Py_INCREF(Py_None); resultobj = Py_None;
7442 return resultobj;
7443 fail:
7444 return NULL;
7445 }
7446
7447
7448 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7449 PyObject *resultobj;
7450 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7451 int arg2 ;
7452 wxString result;
7453 PyObject * obj0 = 0 ;
7454 PyObject * obj1 = 0 ;
7455 char *kwnames[] = {
7456 (char *) "self",(char *) "i", NULL
7457 };
7458
7459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7461 if (SWIG_arg_fail(1)) SWIG_fail;
7462 {
7463 arg2 = (int)(SWIG_As_int(obj1));
7464 if (SWIG_arg_fail(2)) SWIG_fail;
7465 }
7466 {
7467 PyThreadState* __tstate = wxPyBeginAllowThreads();
7468 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7469
7470 wxPyEndAllowThreads(__tstate);
7471 if (PyErr_Occurred()) SWIG_fail;
7472 }
7473 {
7474 #if wxUSE_UNICODE
7475 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7476 #else
7477 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7478 #endif
7479 }
7480 return resultobj;
7481 fail:
7482 return NULL;
7483 }
7484
7485
7486 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7487 PyObject *resultobj;
7488 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7489 int result;
7490 PyObject * obj0 = 0 ;
7491 char *kwnames[] = {
7492 (char *) "self", NULL
7493 };
7494
7495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7497 if (SWIG_arg_fail(1)) SWIG_fail;
7498 {
7499 PyThreadState* __tstate = wxPyBeginAllowThreads();
7500 result = (int)((wxFileHistory const *)arg1)->GetCount();
7501
7502 wxPyEndAllowThreads(__tstate);
7503 if (PyErr_Occurred()) SWIG_fail;
7504 }
7505 {
7506 resultobj = SWIG_From_int((int)(result));
7507 }
7508 return resultobj;
7509 fail:
7510 return NULL;
7511 }
7512
7513
7514 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7515 PyObject *obj;
7516 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7517 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7518 Py_INCREF(obj);
7519 return Py_BuildValue((char *)"");
7520 }
7521 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7522 PyObject *resultobj;
7523 wxString *arg1 = 0 ;
7524 wxString const &arg2_defvalue = wxPyEmptyString ;
7525 wxString *arg2 = (wxString *) &arg2_defvalue ;
7526 wxSingleInstanceChecker *result;
7527 bool temp1 = false ;
7528 bool temp2 = false ;
7529 PyObject * obj0 = 0 ;
7530 PyObject * obj1 = 0 ;
7531 char *kwnames[] = {
7532 (char *) "name",(char *) "path", NULL
7533 };
7534
7535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7536 {
7537 arg1 = wxString_in_helper(obj0);
7538 if (arg1 == NULL) SWIG_fail;
7539 temp1 = true;
7540 }
7541 if (obj1) {
7542 {
7543 arg2 = wxString_in_helper(obj1);
7544 if (arg2 == NULL) SWIG_fail;
7545 temp2 = true;
7546 }
7547 }
7548 {
7549 PyThreadState* __tstate = wxPyBeginAllowThreads();
7550 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7551
7552 wxPyEndAllowThreads(__tstate);
7553 if (PyErr_Occurred()) SWIG_fail;
7554 }
7555 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7556 {
7557 if (temp1)
7558 delete arg1;
7559 }
7560 {
7561 if (temp2)
7562 delete arg2;
7563 }
7564 return resultobj;
7565 fail:
7566 {
7567 if (temp1)
7568 delete arg1;
7569 }
7570 {
7571 if (temp2)
7572 delete arg2;
7573 }
7574 return NULL;
7575 }
7576
7577
7578 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7579 PyObject *resultobj;
7580 wxSingleInstanceChecker *result;
7581 char *kwnames[] = {
7582 NULL
7583 };
7584
7585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7586 {
7587 PyThreadState* __tstate = wxPyBeginAllowThreads();
7588 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7589
7590 wxPyEndAllowThreads(__tstate);
7591 if (PyErr_Occurred()) SWIG_fail;
7592 }
7593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7594 return resultobj;
7595 fail:
7596 return NULL;
7597 }
7598
7599
7600 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7601 PyObject *resultobj;
7602 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7603 PyObject * obj0 = 0 ;
7604 char *kwnames[] = {
7605 (char *) "self", NULL
7606 };
7607
7608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7610 if (SWIG_arg_fail(1)) SWIG_fail;
7611 {
7612 PyThreadState* __tstate = wxPyBeginAllowThreads();
7613 delete arg1;
7614
7615 wxPyEndAllowThreads(__tstate);
7616 if (PyErr_Occurred()) SWIG_fail;
7617 }
7618 Py_INCREF(Py_None); resultobj = Py_None;
7619 return resultobj;
7620 fail:
7621 return NULL;
7622 }
7623
7624
7625 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7626 PyObject *resultobj;
7627 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7628 wxString *arg2 = 0 ;
7629 wxString const &arg3_defvalue = wxPyEmptyString ;
7630 wxString *arg3 = (wxString *) &arg3_defvalue ;
7631 bool result;
7632 bool temp2 = false ;
7633 bool temp3 = false ;
7634 PyObject * obj0 = 0 ;
7635 PyObject * obj1 = 0 ;
7636 PyObject * obj2 = 0 ;
7637 char *kwnames[] = {
7638 (char *) "self",(char *) "name",(char *) "path", NULL
7639 };
7640
7641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7643 if (SWIG_arg_fail(1)) SWIG_fail;
7644 {
7645 arg2 = wxString_in_helper(obj1);
7646 if (arg2 == NULL) SWIG_fail;
7647 temp2 = true;
7648 }
7649 if (obj2) {
7650 {
7651 arg3 = wxString_in_helper(obj2);
7652 if (arg3 == NULL) SWIG_fail;
7653 temp3 = true;
7654 }
7655 }
7656 {
7657 PyThreadState* __tstate = wxPyBeginAllowThreads();
7658 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7659
7660 wxPyEndAllowThreads(__tstate);
7661 if (PyErr_Occurred()) SWIG_fail;
7662 }
7663 {
7664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7665 }
7666 {
7667 if (temp2)
7668 delete arg2;
7669 }
7670 {
7671 if (temp3)
7672 delete arg3;
7673 }
7674 return resultobj;
7675 fail:
7676 {
7677 if (temp2)
7678 delete arg2;
7679 }
7680 {
7681 if (temp3)
7682 delete arg3;
7683 }
7684 return NULL;
7685 }
7686
7687
7688 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7689 PyObject *resultobj;
7690 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7691 bool result;
7692 PyObject * obj0 = 0 ;
7693 char *kwnames[] = {
7694 (char *) "self", NULL
7695 };
7696
7697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7699 if (SWIG_arg_fail(1)) SWIG_fail;
7700 {
7701 PyThreadState* __tstate = wxPyBeginAllowThreads();
7702 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7703
7704 wxPyEndAllowThreads(__tstate);
7705 if (PyErr_Occurred()) SWIG_fail;
7706 }
7707 {
7708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7709 }
7710 return resultobj;
7711 fail:
7712 return NULL;
7713 }
7714
7715
7716 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7717 PyObject *obj;
7718 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7719 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7720 Py_INCREF(obj);
7721 return Py_BuildValue((char *)"");
7722 }
7723 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7724 PyObject *resultobj;
7725 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7726 PyObject * obj0 = 0 ;
7727 char *kwnames[] = {
7728 (char *) "self", NULL
7729 };
7730
7731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7733 if (SWIG_arg_fail(1)) SWIG_fail;
7734 {
7735 PyThreadState* __tstate = wxPyBeginAllowThreads();
7736 delete arg1;
7737
7738 wxPyEndAllowThreads(__tstate);
7739 if (PyErr_Occurred()) SWIG_fail;
7740 }
7741 Py_INCREF(Py_None); resultobj = Py_None;
7742 return resultobj;
7743 fail:
7744 return NULL;
7745 }
7746
7747
7748 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7749 PyObject *resultobj;
7750 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7751 wxString result;
7752 PyObject * obj0 = 0 ;
7753 char *kwnames[] = {
7754 (char *) "self", NULL
7755 };
7756
7757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7759 if (SWIG_arg_fail(1)) SWIG_fail;
7760 {
7761 PyThreadState* __tstate = wxPyBeginAllowThreads();
7762 result = (arg1)->GetTip();
7763
7764 wxPyEndAllowThreads(__tstate);
7765 if (PyErr_Occurred()) SWIG_fail;
7766 }
7767 {
7768 #if wxUSE_UNICODE
7769 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7770 #else
7771 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7772 #endif
7773 }
7774 return resultobj;
7775 fail:
7776 return NULL;
7777 }
7778
7779
7780 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7781 PyObject *resultobj;
7782 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7783 size_t result;
7784 PyObject * obj0 = 0 ;
7785 char *kwnames[] = {
7786 (char *) "self", NULL
7787 };
7788
7789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7791 if (SWIG_arg_fail(1)) SWIG_fail;
7792 {
7793 PyThreadState* __tstate = wxPyBeginAllowThreads();
7794 result = (size_t)(arg1)->GetCurrentTip();
7795
7796 wxPyEndAllowThreads(__tstate);
7797 if (PyErr_Occurred()) SWIG_fail;
7798 }
7799 {
7800 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7801 }
7802 return resultobj;
7803 fail:
7804 return NULL;
7805 }
7806
7807
7808 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7809 PyObject *resultobj;
7810 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7811 wxString *arg2 = 0 ;
7812 wxString result;
7813 bool temp2 = false ;
7814 PyObject * obj0 = 0 ;
7815 PyObject * obj1 = 0 ;
7816 char *kwnames[] = {
7817 (char *) "self",(char *) "tip", NULL
7818 };
7819
7820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7822 if (SWIG_arg_fail(1)) SWIG_fail;
7823 {
7824 arg2 = wxString_in_helper(obj1);
7825 if (arg2 == NULL) SWIG_fail;
7826 temp2 = true;
7827 }
7828 {
7829 PyThreadState* __tstate = wxPyBeginAllowThreads();
7830 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7831
7832 wxPyEndAllowThreads(__tstate);
7833 if (PyErr_Occurred()) SWIG_fail;
7834 }
7835 {
7836 #if wxUSE_UNICODE
7837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7838 #else
7839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7840 #endif
7841 }
7842 {
7843 if (temp2)
7844 delete arg2;
7845 }
7846 return resultobj;
7847 fail:
7848 {
7849 if (temp2)
7850 delete arg2;
7851 }
7852 return NULL;
7853 }
7854
7855
7856 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7857 PyObject *obj;
7858 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7859 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7860 Py_INCREF(obj);
7861 return Py_BuildValue((char *)"");
7862 }
7863 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7864 PyObject *resultobj;
7865 size_t arg1 ;
7866 wxPyTipProvider *result;
7867 PyObject * obj0 = 0 ;
7868 char *kwnames[] = {
7869 (char *) "currentTip", NULL
7870 };
7871
7872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
7873 {
7874 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
7875 if (SWIG_arg_fail(1)) SWIG_fail;
7876 }
7877 {
7878 PyThreadState* __tstate = wxPyBeginAllowThreads();
7879 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
7880
7881 wxPyEndAllowThreads(__tstate);
7882 if (PyErr_Occurred()) SWIG_fail;
7883 }
7884 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
7885 return resultobj;
7886 fail:
7887 return NULL;
7888 }
7889
7890
7891 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7892 PyObject *resultobj;
7893 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
7894 PyObject *arg2 = (PyObject *) 0 ;
7895 PyObject *arg3 = (PyObject *) 0 ;
7896 PyObject * obj0 = 0 ;
7897 PyObject * obj1 = 0 ;
7898 PyObject * obj2 = 0 ;
7899 char *kwnames[] = {
7900 (char *) "self",(char *) "self",(char *) "_class", NULL
7901 };
7902
7903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
7904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
7905 if (SWIG_arg_fail(1)) SWIG_fail;
7906 arg2 = obj1;
7907 arg3 = obj2;
7908 {
7909 PyThreadState* __tstate = wxPyBeginAllowThreads();
7910 (arg1)->_setCallbackInfo(arg2,arg3);
7911
7912 wxPyEndAllowThreads(__tstate);
7913 if (PyErr_Occurred()) SWIG_fail;
7914 }
7915 Py_INCREF(Py_None); resultobj = Py_None;
7916 return resultobj;
7917 fail:
7918 return NULL;
7919 }
7920
7921
7922 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
7923 PyObject *obj;
7924 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7925 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
7926 Py_INCREF(obj);
7927 return Py_BuildValue((char *)"");
7928 }
7929 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
7930 PyObject *resultobj;
7931 wxWindow *arg1 = (wxWindow *) 0 ;
7932 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
7933 bool arg3 = (bool) true ;
7934 bool result;
7935 PyObject * obj0 = 0 ;
7936 PyObject * obj1 = 0 ;
7937 PyObject * obj2 = 0 ;
7938 char *kwnames[] = {
7939 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
7940 };
7941
7942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
7943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7944 if (SWIG_arg_fail(1)) SWIG_fail;
7945 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7946 if (SWIG_arg_fail(2)) SWIG_fail;
7947 if (obj2) {
7948 {
7949 arg3 = (bool)(SWIG_As_bool(obj2));
7950 if (SWIG_arg_fail(3)) SWIG_fail;
7951 }
7952 }
7953 {
7954 if (!wxPyCheckForApp()) SWIG_fail;
7955 PyThreadState* __tstate = wxPyBeginAllowThreads();
7956 result = (bool)wxShowTip(arg1,arg2,arg3);
7957
7958 wxPyEndAllowThreads(__tstate);
7959 if (PyErr_Occurred()) SWIG_fail;
7960 }
7961 {
7962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7963 }
7964 return resultobj;
7965 fail:
7966 return NULL;
7967 }
7968
7969
7970 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7971 PyObject *resultobj;
7972 wxString *arg1 = 0 ;
7973 size_t arg2 ;
7974 wxTipProvider *result;
7975 bool temp1 = false ;
7976 PyObject * obj0 = 0 ;
7977 PyObject * obj1 = 0 ;
7978 char *kwnames[] = {
7979 (char *) "filename",(char *) "currentTip", NULL
7980 };
7981
7982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
7983 {
7984 arg1 = wxString_in_helper(obj0);
7985 if (arg1 == NULL) SWIG_fail;
7986 temp1 = true;
7987 }
7988 {
7989 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
7990 if (SWIG_arg_fail(2)) SWIG_fail;
7991 }
7992 {
7993 if (!wxPyCheckForApp()) SWIG_fail;
7994 PyThreadState* __tstate = wxPyBeginAllowThreads();
7995 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
7996
7997 wxPyEndAllowThreads(__tstate);
7998 if (PyErr_Occurred()) SWIG_fail;
7999 }
8000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8001 {
8002 if (temp1)
8003 delete arg1;
8004 }
8005 return resultobj;
8006 fail:
8007 {
8008 if (temp1)
8009 delete arg1;
8010 }
8011 return NULL;
8012 }
8013
8014
8015 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8016 PyObject *resultobj;
8017 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8018 int arg2 = (int) -1 ;
8019 wxPyTimer *result;
8020 PyObject * obj0 = 0 ;
8021 PyObject * obj1 = 0 ;
8022 char *kwnames[] = {
8023 (char *) "owner",(char *) "id", NULL
8024 };
8025
8026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8027 if (obj0) {
8028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8029 if (SWIG_arg_fail(1)) SWIG_fail;
8030 }
8031 if (obj1) {
8032 {
8033 arg2 = (int)(SWIG_As_int(obj1));
8034 if (SWIG_arg_fail(2)) SWIG_fail;
8035 }
8036 }
8037 {
8038 if (!wxPyCheckForApp()) SWIG_fail;
8039 PyThreadState* __tstate = wxPyBeginAllowThreads();
8040 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8041
8042 wxPyEndAllowThreads(__tstate);
8043 if (PyErr_Occurred()) SWIG_fail;
8044 }
8045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8046 return resultobj;
8047 fail:
8048 return NULL;
8049 }
8050
8051
8052 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8053 PyObject *resultobj;
8054 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8055 PyObject * obj0 = 0 ;
8056 char *kwnames[] = {
8057 (char *) "self", NULL
8058 };
8059
8060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8062 if (SWIG_arg_fail(1)) SWIG_fail;
8063 {
8064 PyThreadState* __tstate = wxPyBeginAllowThreads();
8065 delete arg1;
8066
8067 wxPyEndAllowThreads(__tstate);
8068 if (PyErr_Occurred()) SWIG_fail;
8069 }
8070 Py_INCREF(Py_None); resultobj = Py_None;
8071 return resultobj;
8072 fail:
8073 return NULL;
8074 }
8075
8076
8077 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8078 PyObject *resultobj;
8079 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8080 PyObject *arg2 = (PyObject *) 0 ;
8081 PyObject *arg3 = (PyObject *) 0 ;
8082 int arg4 = (int) 1 ;
8083 PyObject * obj0 = 0 ;
8084 PyObject * obj1 = 0 ;
8085 PyObject * obj2 = 0 ;
8086 PyObject * obj3 = 0 ;
8087 char *kwnames[] = {
8088 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8089 };
8090
8091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8093 if (SWIG_arg_fail(1)) SWIG_fail;
8094 arg2 = obj1;
8095 arg3 = obj2;
8096 if (obj3) {
8097 {
8098 arg4 = (int)(SWIG_As_int(obj3));
8099 if (SWIG_arg_fail(4)) SWIG_fail;
8100 }
8101 }
8102 {
8103 PyThreadState* __tstate = wxPyBeginAllowThreads();
8104 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8105
8106 wxPyEndAllowThreads(__tstate);
8107 if (PyErr_Occurred()) SWIG_fail;
8108 }
8109 Py_INCREF(Py_None); resultobj = Py_None;
8110 return resultobj;
8111 fail:
8112 return NULL;
8113 }
8114
8115
8116 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8117 PyObject *resultobj;
8118 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8119 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8120 int arg3 = (int) -1 ;
8121 PyObject * obj0 = 0 ;
8122 PyObject * obj1 = 0 ;
8123 PyObject * obj2 = 0 ;
8124 char *kwnames[] = {
8125 (char *) "self",(char *) "owner",(char *) "id", NULL
8126 };
8127
8128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8130 if (SWIG_arg_fail(1)) SWIG_fail;
8131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8132 if (SWIG_arg_fail(2)) SWIG_fail;
8133 if (obj2) {
8134 {
8135 arg3 = (int)(SWIG_As_int(obj2));
8136 if (SWIG_arg_fail(3)) SWIG_fail;
8137 }
8138 }
8139 {
8140 PyThreadState* __tstate = wxPyBeginAllowThreads();
8141 (arg1)->SetOwner(arg2,arg3);
8142
8143 wxPyEndAllowThreads(__tstate);
8144 if (PyErr_Occurred()) SWIG_fail;
8145 }
8146 Py_INCREF(Py_None); resultobj = Py_None;
8147 return resultobj;
8148 fail:
8149 return NULL;
8150 }
8151
8152
8153 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8154 PyObject *resultobj;
8155 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8156 wxEvtHandler *result;
8157 PyObject * obj0 = 0 ;
8158 char *kwnames[] = {
8159 (char *) "self", NULL
8160 };
8161
8162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8164 if (SWIG_arg_fail(1)) SWIG_fail;
8165 {
8166 PyThreadState* __tstate = wxPyBeginAllowThreads();
8167 result = (wxEvtHandler *)(arg1)->GetOwner();
8168
8169 wxPyEndAllowThreads(__tstate);
8170 if (PyErr_Occurred()) SWIG_fail;
8171 }
8172 {
8173 resultobj = wxPyMake_wxObject(result, 0);
8174 }
8175 return resultobj;
8176 fail:
8177 return NULL;
8178 }
8179
8180
8181 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8182 PyObject *resultobj;
8183 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8184 int arg2 = (int) -1 ;
8185 bool arg3 = (bool) false ;
8186 bool result;
8187 PyObject * obj0 = 0 ;
8188 PyObject * obj1 = 0 ;
8189 PyObject * obj2 = 0 ;
8190 char *kwnames[] = {
8191 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8192 };
8193
8194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8196 if (SWIG_arg_fail(1)) SWIG_fail;
8197 if (obj1) {
8198 {
8199 arg2 = (int)(SWIG_As_int(obj1));
8200 if (SWIG_arg_fail(2)) SWIG_fail;
8201 }
8202 }
8203 if (obj2) {
8204 {
8205 arg3 = (bool)(SWIG_As_bool(obj2));
8206 if (SWIG_arg_fail(3)) SWIG_fail;
8207 }
8208 }
8209 {
8210 PyThreadState* __tstate = wxPyBeginAllowThreads();
8211 result = (bool)(arg1)->Start(arg2,arg3);
8212
8213 wxPyEndAllowThreads(__tstate);
8214 if (PyErr_Occurred()) SWIG_fail;
8215 }
8216 {
8217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8218 }
8219 return resultobj;
8220 fail:
8221 return NULL;
8222 }
8223
8224
8225 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8226 PyObject *resultobj;
8227 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8228 PyObject * obj0 = 0 ;
8229 char *kwnames[] = {
8230 (char *) "self", NULL
8231 };
8232
8233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8235 if (SWIG_arg_fail(1)) SWIG_fail;
8236 {
8237 PyThreadState* __tstate = wxPyBeginAllowThreads();
8238 (arg1)->Stop();
8239
8240 wxPyEndAllowThreads(__tstate);
8241 if (PyErr_Occurred()) SWIG_fail;
8242 }
8243 Py_INCREF(Py_None); resultobj = Py_None;
8244 return resultobj;
8245 fail:
8246 return NULL;
8247 }
8248
8249
8250 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8251 PyObject *resultobj;
8252 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8253 bool result;
8254 PyObject * obj0 = 0 ;
8255 char *kwnames[] = {
8256 (char *) "self", NULL
8257 };
8258
8259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8261 if (SWIG_arg_fail(1)) SWIG_fail;
8262 {
8263 PyThreadState* __tstate = wxPyBeginAllowThreads();
8264 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8265
8266 wxPyEndAllowThreads(__tstate);
8267 if (PyErr_Occurred()) SWIG_fail;
8268 }
8269 {
8270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8271 }
8272 return resultobj;
8273 fail:
8274 return NULL;
8275 }
8276
8277
8278 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8279 PyObject *resultobj;
8280 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8281 int result;
8282 PyObject * obj0 = 0 ;
8283 char *kwnames[] = {
8284 (char *) "self", NULL
8285 };
8286
8287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8289 if (SWIG_arg_fail(1)) SWIG_fail;
8290 {
8291 PyThreadState* __tstate = wxPyBeginAllowThreads();
8292 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8293
8294 wxPyEndAllowThreads(__tstate);
8295 if (PyErr_Occurred()) SWIG_fail;
8296 }
8297 {
8298 resultobj = SWIG_From_int((int)(result));
8299 }
8300 return resultobj;
8301 fail:
8302 return NULL;
8303 }
8304
8305
8306 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8307 PyObject *resultobj;
8308 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8309 bool result;
8310 PyObject * obj0 = 0 ;
8311 char *kwnames[] = {
8312 (char *) "self", NULL
8313 };
8314
8315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8317 if (SWIG_arg_fail(1)) SWIG_fail;
8318 {
8319 PyThreadState* __tstate = wxPyBeginAllowThreads();
8320 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8321
8322 wxPyEndAllowThreads(__tstate);
8323 if (PyErr_Occurred()) SWIG_fail;
8324 }
8325 {
8326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8327 }
8328 return resultobj;
8329 fail:
8330 return NULL;
8331 }
8332
8333
8334 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8335 PyObject *resultobj;
8336 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8337 int result;
8338 PyObject * obj0 = 0 ;
8339 char *kwnames[] = {
8340 (char *) "self", NULL
8341 };
8342
8343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8345 if (SWIG_arg_fail(1)) SWIG_fail;
8346 {
8347 PyThreadState* __tstate = wxPyBeginAllowThreads();
8348 result = (int)((wxPyTimer const *)arg1)->GetId();
8349
8350 wxPyEndAllowThreads(__tstate);
8351 if (PyErr_Occurred()) SWIG_fail;
8352 }
8353 {
8354 resultobj = SWIG_From_int((int)(result));
8355 }
8356 return resultobj;
8357 fail:
8358 return NULL;
8359 }
8360
8361
8362 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8363 PyObject *obj;
8364 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8365 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8366 Py_INCREF(obj);
8367 return Py_BuildValue((char *)"");
8368 }
8369 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8370 PyObject *resultobj;
8371 int arg1 = (int) 0 ;
8372 int arg2 = (int) 0 ;
8373 wxTimerEvent *result;
8374 PyObject * obj0 = 0 ;
8375 PyObject * obj1 = 0 ;
8376 char *kwnames[] = {
8377 (char *) "timerid",(char *) "interval", NULL
8378 };
8379
8380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8381 if (obj0) {
8382 {
8383 arg1 = (int)(SWIG_As_int(obj0));
8384 if (SWIG_arg_fail(1)) SWIG_fail;
8385 }
8386 }
8387 if (obj1) {
8388 {
8389 arg2 = (int)(SWIG_As_int(obj1));
8390 if (SWIG_arg_fail(2)) SWIG_fail;
8391 }
8392 }
8393 {
8394 PyThreadState* __tstate = wxPyBeginAllowThreads();
8395 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8396
8397 wxPyEndAllowThreads(__tstate);
8398 if (PyErr_Occurred()) SWIG_fail;
8399 }
8400 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8401 return resultobj;
8402 fail:
8403 return NULL;
8404 }
8405
8406
8407 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8408 PyObject *resultobj;
8409 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8410 int result;
8411 PyObject * obj0 = 0 ;
8412 char *kwnames[] = {
8413 (char *) "self", NULL
8414 };
8415
8416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8418 if (SWIG_arg_fail(1)) SWIG_fail;
8419 {
8420 PyThreadState* __tstate = wxPyBeginAllowThreads();
8421 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8422
8423 wxPyEndAllowThreads(__tstate);
8424 if (PyErr_Occurred()) SWIG_fail;
8425 }
8426 {
8427 resultobj = SWIG_From_int((int)(result));
8428 }
8429 return resultobj;
8430 fail:
8431 return NULL;
8432 }
8433
8434
8435 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8436 PyObject *obj;
8437 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8438 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8439 Py_INCREF(obj);
8440 return Py_BuildValue((char *)"");
8441 }
8442 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8443 PyObject *resultobj;
8444 wxTimer *arg1 = 0 ;
8445 wxTimerRunner *result;
8446 PyObject * obj0 = 0 ;
8447
8448 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8449 {
8450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8451 if (SWIG_arg_fail(1)) SWIG_fail;
8452 if (arg1 == NULL) {
8453 SWIG_null_ref("wxTimer");
8454 }
8455 if (SWIG_arg_fail(1)) SWIG_fail;
8456 }
8457 {
8458 if (!wxPyCheckForApp()) SWIG_fail;
8459 PyThreadState* __tstate = wxPyBeginAllowThreads();
8460 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8461
8462 wxPyEndAllowThreads(__tstate);
8463 if (PyErr_Occurred()) SWIG_fail;
8464 }
8465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8466 return resultobj;
8467 fail:
8468 return NULL;
8469 }
8470
8471
8472 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8473 PyObject *resultobj;
8474 wxTimer *arg1 = 0 ;
8475 int arg2 ;
8476 bool arg3 = (bool) false ;
8477 wxTimerRunner *result;
8478 PyObject * obj0 = 0 ;
8479 PyObject * obj1 = 0 ;
8480 PyObject * obj2 = 0 ;
8481
8482 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8483 {
8484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8485 if (SWIG_arg_fail(1)) SWIG_fail;
8486 if (arg1 == NULL) {
8487 SWIG_null_ref("wxTimer");
8488 }
8489 if (SWIG_arg_fail(1)) SWIG_fail;
8490 }
8491 {
8492 arg2 = (int)(SWIG_As_int(obj1));
8493 if (SWIG_arg_fail(2)) SWIG_fail;
8494 }
8495 if (obj2) {
8496 {
8497 arg3 = (bool)(SWIG_As_bool(obj2));
8498 if (SWIG_arg_fail(3)) SWIG_fail;
8499 }
8500 }
8501 {
8502 if (!wxPyCheckForApp()) SWIG_fail;
8503 PyThreadState* __tstate = wxPyBeginAllowThreads();
8504 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8505
8506 wxPyEndAllowThreads(__tstate);
8507 if (PyErr_Occurred()) SWIG_fail;
8508 }
8509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8510 return resultobj;
8511 fail:
8512 return NULL;
8513 }
8514
8515
8516 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8517 int argc;
8518 PyObject *argv[4];
8519 int ii;
8520
8521 argc = PyObject_Length(args);
8522 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8523 argv[ii] = PyTuple_GetItem(args,ii);
8524 }
8525 if (argc == 1) {
8526 int _v;
8527 {
8528 void *ptr = 0;
8529 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8530 _v = 0;
8531 PyErr_Clear();
8532 } else {
8533 _v = (ptr != 0);
8534 }
8535 }
8536 if (_v) {
8537 return _wrap_new_TimerRunner__SWIG_0(self,args);
8538 }
8539 }
8540 if ((argc >= 2) && (argc <= 3)) {
8541 int _v;
8542 {
8543 void *ptr = 0;
8544 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8545 _v = 0;
8546 PyErr_Clear();
8547 } else {
8548 _v = (ptr != 0);
8549 }
8550 }
8551 if (_v) {
8552 _v = SWIG_Check_int(argv[1]);
8553 if (_v) {
8554 if (argc <= 2) {
8555 return _wrap_new_TimerRunner__SWIG_1(self,args);
8556 }
8557 _v = SWIG_Check_bool(argv[2]);
8558 if (_v) {
8559 return _wrap_new_TimerRunner__SWIG_1(self,args);
8560 }
8561 }
8562 }
8563 }
8564
8565 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8566 return NULL;
8567 }
8568
8569
8570 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8571 PyObject *resultobj;
8572 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8573 PyObject * obj0 = 0 ;
8574 char *kwnames[] = {
8575 (char *) "self", NULL
8576 };
8577
8578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8580 if (SWIG_arg_fail(1)) SWIG_fail;
8581 {
8582 PyThreadState* __tstate = wxPyBeginAllowThreads();
8583 delete arg1;
8584
8585 wxPyEndAllowThreads(__tstate);
8586 if (PyErr_Occurred()) SWIG_fail;
8587 }
8588 Py_INCREF(Py_None); resultobj = Py_None;
8589 return resultobj;
8590 fail:
8591 return NULL;
8592 }
8593
8594
8595 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8596 PyObject *resultobj;
8597 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8598 int arg2 ;
8599 bool arg3 = (bool) false ;
8600 PyObject * obj0 = 0 ;
8601 PyObject * obj1 = 0 ;
8602 PyObject * obj2 = 0 ;
8603 char *kwnames[] = {
8604 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8605 };
8606
8607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8609 if (SWIG_arg_fail(1)) SWIG_fail;
8610 {
8611 arg2 = (int)(SWIG_As_int(obj1));
8612 if (SWIG_arg_fail(2)) SWIG_fail;
8613 }
8614 if (obj2) {
8615 {
8616 arg3 = (bool)(SWIG_As_bool(obj2));
8617 if (SWIG_arg_fail(3)) SWIG_fail;
8618 }
8619 }
8620 {
8621 PyThreadState* __tstate = wxPyBeginAllowThreads();
8622 (arg1)->Start(arg2,arg3);
8623
8624 wxPyEndAllowThreads(__tstate);
8625 if (PyErr_Occurred()) SWIG_fail;
8626 }
8627 Py_INCREF(Py_None); resultobj = Py_None;
8628 return resultobj;
8629 fail:
8630 return NULL;
8631 }
8632
8633
8634 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8635 PyObject *obj;
8636 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8637 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8638 Py_INCREF(obj);
8639 return Py_BuildValue((char *)"");
8640 }
8641 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8642 PyObject *resultobj;
8643 wxLog *result;
8644 char *kwnames[] = {
8645 NULL
8646 };
8647
8648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8649 {
8650 PyThreadState* __tstate = wxPyBeginAllowThreads();
8651 result = (wxLog *)new wxLog();
8652
8653 wxPyEndAllowThreads(__tstate);
8654 if (PyErr_Occurred()) SWIG_fail;
8655 }
8656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8657 return resultobj;
8658 fail:
8659 return NULL;
8660 }
8661
8662
8663 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8664 PyObject *resultobj;
8665 bool result;
8666 char *kwnames[] = {
8667 NULL
8668 };
8669
8670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8671 {
8672 PyThreadState* __tstate = wxPyBeginAllowThreads();
8673 result = (bool)wxLog::IsEnabled();
8674
8675 wxPyEndAllowThreads(__tstate);
8676 if (PyErr_Occurred()) SWIG_fail;
8677 }
8678 {
8679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8680 }
8681 return resultobj;
8682 fail:
8683 return NULL;
8684 }
8685
8686
8687 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8688 PyObject *resultobj;
8689 bool arg1 = (bool) true ;
8690 bool result;
8691 PyObject * obj0 = 0 ;
8692 char *kwnames[] = {
8693 (char *) "doIt", NULL
8694 };
8695
8696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8697 if (obj0) {
8698 {
8699 arg1 = (bool)(SWIG_As_bool(obj0));
8700 if (SWIG_arg_fail(1)) SWIG_fail;
8701 }
8702 }
8703 {
8704 PyThreadState* __tstate = wxPyBeginAllowThreads();
8705 result = (bool)wxLog::EnableLogging(arg1);
8706
8707 wxPyEndAllowThreads(__tstate);
8708 if (PyErr_Occurred()) SWIG_fail;
8709 }
8710 {
8711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8712 }
8713 return resultobj;
8714 fail:
8715 return NULL;
8716 }
8717
8718
8719 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8720 PyObject *resultobj;
8721 wxLogLevel arg1 ;
8722 wxChar *arg2 = (wxChar *) 0 ;
8723 time_t arg3 ;
8724 PyObject * obj0 = 0 ;
8725 PyObject * obj1 = 0 ;
8726 PyObject * obj2 = 0 ;
8727 char *kwnames[] = {
8728 (char *) "level",(char *) "szString",(char *) "t", NULL
8729 };
8730
8731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8732 {
8733 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8734 if (SWIG_arg_fail(1)) SWIG_fail;
8735 }
8736 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8737 if (SWIG_arg_fail(2)) SWIG_fail;
8738 {
8739 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8740 if (SWIG_arg_fail(3)) SWIG_fail;
8741 }
8742 {
8743 PyThreadState* __tstate = wxPyBeginAllowThreads();
8744 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8745
8746 wxPyEndAllowThreads(__tstate);
8747 if (PyErr_Occurred()) SWIG_fail;
8748 }
8749 Py_INCREF(Py_None); resultobj = Py_None;
8750 return resultobj;
8751 fail:
8752 return NULL;
8753 }
8754
8755
8756 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8757 PyObject *resultobj;
8758 wxLog *arg1 = (wxLog *) 0 ;
8759 PyObject * obj0 = 0 ;
8760 char *kwnames[] = {
8761 (char *) "self", NULL
8762 };
8763
8764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8766 if (SWIG_arg_fail(1)) SWIG_fail;
8767 {
8768 PyThreadState* __tstate = wxPyBeginAllowThreads();
8769 (arg1)->Flush();
8770
8771 wxPyEndAllowThreads(__tstate);
8772 if (PyErr_Occurred()) SWIG_fail;
8773 }
8774 Py_INCREF(Py_None); resultobj = Py_None;
8775 return resultobj;
8776 fail:
8777 return NULL;
8778 }
8779
8780
8781 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8782 PyObject *resultobj;
8783 char *kwnames[] = {
8784 NULL
8785 };
8786
8787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8788 {
8789 PyThreadState* __tstate = wxPyBeginAllowThreads();
8790 wxLog::FlushActive();
8791
8792 wxPyEndAllowThreads(__tstate);
8793 if (PyErr_Occurred()) SWIG_fail;
8794 }
8795 Py_INCREF(Py_None); resultobj = Py_None;
8796 return resultobj;
8797 fail:
8798 return NULL;
8799 }
8800
8801
8802 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8803 PyObject *resultobj;
8804 wxLog *result;
8805 char *kwnames[] = {
8806 NULL
8807 };
8808
8809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8810 {
8811 PyThreadState* __tstate = wxPyBeginAllowThreads();
8812 result = (wxLog *)wxLog::GetActiveTarget();
8813
8814 wxPyEndAllowThreads(__tstate);
8815 if (PyErr_Occurred()) SWIG_fail;
8816 }
8817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8818 return resultobj;
8819 fail:
8820 return NULL;
8821 }
8822
8823
8824 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8825 PyObject *resultobj;
8826 wxLog *arg1 = (wxLog *) 0 ;
8827 wxLog *result;
8828 PyObject * obj0 = 0 ;
8829 char *kwnames[] = {
8830 (char *) "pLogger", NULL
8831 };
8832
8833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8835 if (SWIG_arg_fail(1)) SWIG_fail;
8836 {
8837 PyThreadState* __tstate = wxPyBeginAllowThreads();
8838 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8839
8840 wxPyEndAllowThreads(__tstate);
8841 if (PyErr_Occurred()) SWIG_fail;
8842 }
8843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8844 return resultobj;
8845 fail:
8846 return NULL;
8847 }
8848
8849
8850 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8851 PyObject *resultobj;
8852 char *kwnames[] = {
8853 NULL
8854 };
8855
8856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8857 {
8858 PyThreadState* __tstate = wxPyBeginAllowThreads();
8859 wxLog::Suspend();
8860
8861 wxPyEndAllowThreads(__tstate);
8862 if (PyErr_Occurred()) SWIG_fail;
8863 }
8864 Py_INCREF(Py_None); resultobj = Py_None;
8865 return resultobj;
8866 fail:
8867 return NULL;
8868 }
8869
8870
8871 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
8872 PyObject *resultobj;
8873 char *kwnames[] = {
8874 NULL
8875 };
8876
8877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
8878 {
8879 PyThreadState* __tstate = wxPyBeginAllowThreads();
8880 wxLog::Resume();
8881
8882 wxPyEndAllowThreads(__tstate);
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 Py_INCREF(Py_None); resultobj = Py_None;
8886 return resultobj;
8887 fail:
8888 return NULL;
8889 }
8890
8891
8892 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
8893 PyObject *resultobj;
8894 bool arg1 = (bool) true ;
8895 PyObject * obj0 = 0 ;
8896 char *kwnames[] = {
8897 (char *) "bVerbose", NULL
8898 };
8899
8900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
8901 if (obj0) {
8902 {
8903 arg1 = (bool)(SWIG_As_bool(obj0));
8904 if (SWIG_arg_fail(1)) SWIG_fail;
8905 }
8906 }
8907 {
8908 PyThreadState* __tstate = wxPyBeginAllowThreads();
8909 wxLog::SetVerbose(arg1);
8910
8911 wxPyEndAllowThreads(__tstate);
8912 if (PyErr_Occurred()) SWIG_fail;
8913 }
8914 Py_INCREF(Py_None); resultobj = Py_None;
8915 return resultobj;
8916 fail:
8917 return NULL;
8918 }
8919
8920
8921 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
8922 PyObject *resultobj;
8923 wxLogLevel arg1 ;
8924 PyObject * obj0 = 0 ;
8925 char *kwnames[] = {
8926 (char *) "logLevel", NULL
8927 };
8928
8929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
8930 {
8931 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8932 if (SWIG_arg_fail(1)) SWIG_fail;
8933 }
8934 {
8935 PyThreadState* __tstate = wxPyBeginAllowThreads();
8936 wxLog::SetLogLevel(arg1);
8937
8938 wxPyEndAllowThreads(__tstate);
8939 if (PyErr_Occurred()) SWIG_fail;
8940 }
8941 Py_INCREF(Py_None); resultobj = Py_None;
8942 return resultobj;
8943 fail:
8944 return NULL;
8945 }
8946
8947
8948 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
8949 PyObject *resultobj;
8950 char *kwnames[] = {
8951 NULL
8952 };
8953
8954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
8955 {
8956 PyThreadState* __tstate = wxPyBeginAllowThreads();
8957 wxLog::DontCreateOnDemand();
8958
8959 wxPyEndAllowThreads(__tstate);
8960 if (PyErr_Occurred()) SWIG_fail;
8961 }
8962 Py_INCREF(Py_None); resultobj = Py_None;
8963 return resultobj;
8964 fail:
8965 return NULL;
8966 }
8967
8968
8969 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8970 PyObject *resultobj;
8971 wxTraceMask arg1 ;
8972 PyObject * obj0 = 0 ;
8973 char *kwnames[] = {
8974 (char *) "ulMask", NULL
8975 };
8976
8977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
8978 {
8979 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
8980 if (SWIG_arg_fail(1)) SWIG_fail;
8981 }
8982 {
8983 PyThreadState* __tstate = wxPyBeginAllowThreads();
8984 wxLog::SetTraceMask(arg1);
8985
8986 wxPyEndAllowThreads(__tstate);
8987 if (PyErr_Occurred()) SWIG_fail;
8988 }
8989 Py_INCREF(Py_None); resultobj = Py_None;
8990 return resultobj;
8991 fail:
8992 return NULL;
8993 }
8994
8995
8996 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
8997 PyObject *resultobj;
8998 wxString *arg1 = 0 ;
8999 bool temp1 = false ;
9000 PyObject * obj0 = 0 ;
9001 char *kwnames[] = {
9002 (char *) "str", NULL
9003 };
9004
9005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9006 {
9007 arg1 = wxString_in_helper(obj0);
9008 if (arg1 == NULL) SWIG_fail;
9009 temp1 = true;
9010 }
9011 {
9012 PyThreadState* __tstate = wxPyBeginAllowThreads();
9013 wxLog::AddTraceMask((wxString const &)*arg1);
9014
9015 wxPyEndAllowThreads(__tstate);
9016 if (PyErr_Occurred()) SWIG_fail;
9017 }
9018 Py_INCREF(Py_None); resultobj = Py_None;
9019 {
9020 if (temp1)
9021 delete arg1;
9022 }
9023 return resultobj;
9024 fail:
9025 {
9026 if (temp1)
9027 delete arg1;
9028 }
9029 return NULL;
9030 }
9031
9032
9033 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9034 PyObject *resultobj;
9035 wxString *arg1 = 0 ;
9036 bool temp1 = false ;
9037 PyObject * obj0 = 0 ;
9038 char *kwnames[] = {
9039 (char *) "str", NULL
9040 };
9041
9042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9043 {
9044 arg1 = wxString_in_helper(obj0);
9045 if (arg1 == NULL) SWIG_fail;
9046 temp1 = true;
9047 }
9048 {
9049 PyThreadState* __tstate = wxPyBeginAllowThreads();
9050 wxLog::RemoveTraceMask((wxString const &)*arg1);
9051
9052 wxPyEndAllowThreads(__tstate);
9053 if (PyErr_Occurred()) SWIG_fail;
9054 }
9055 Py_INCREF(Py_None); resultobj = Py_None;
9056 {
9057 if (temp1)
9058 delete arg1;
9059 }
9060 return resultobj;
9061 fail:
9062 {
9063 if (temp1)
9064 delete arg1;
9065 }
9066 return NULL;
9067 }
9068
9069
9070 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9071 PyObject *resultobj;
9072 char *kwnames[] = {
9073 NULL
9074 };
9075
9076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9077 {
9078 PyThreadState* __tstate = wxPyBeginAllowThreads();
9079 wxLog::ClearTraceMasks();
9080
9081 wxPyEndAllowThreads(__tstate);
9082 if (PyErr_Occurred()) SWIG_fail;
9083 }
9084 Py_INCREF(Py_None); resultobj = Py_None;
9085 return resultobj;
9086 fail:
9087 return NULL;
9088 }
9089
9090
9091 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9092 PyObject *resultobj;
9093 wxArrayString *result;
9094 char *kwnames[] = {
9095 NULL
9096 };
9097
9098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9099 {
9100 PyThreadState* __tstate = wxPyBeginAllowThreads();
9101 {
9102 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9103 result = (wxArrayString *) &_result_ref;
9104 }
9105
9106 wxPyEndAllowThreads(__tstate);
9107 if (PyErr_Occurred()) SWIG_fail;
9108 }
9109 {
9110 resultobj = wxArrayString2PyList_helper(*result);
9111 }
9112 return resultobj;
9113 fail:
9114 return NULL;
9115 }
9116
9117
9118 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9119 PyObject *resultobj;
9120 wxChar *arg1 = (wxChar *) 0 ;
9121 PyObject * obj0 = 0 ;
9122 char *kwnames[] = {
9123 (char *) "ts", NULL
9124 };
9125
9126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9128 if (SWIG_arg_fail(1)) SWIG_fail;
9129 {
9130 PyThreadState* __tstate = wxPyBeginAllowThreads();
9131 wxLog::SetTimestamp((wxChar const *)arg1);
9132
9133 wxPyEndAllowThreads(__tstate);
9134 if (PyErr_Occurred()) SWIG_fail;
9135 }
9136 Py_INCREF(Py_None); resultobj = Py_None;
9137 return resultobj;
9138 fail:
9139 return NULL;
9140 }
9141
9142
9143 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9144 PyObject *resultobj;
9145 bool result;
9146 char *kwnames[] = {
9147 NULL
9148 };
9149
9150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9151 {
9152 PyThreadState* __tstate = wxPyBeginAllowThreads();
9153 result = (bool)wxLog::GetVerbose();
9154
9155 wxPyEndAllowThreads(__tstate);
9156 if (PyErr_Occurred()) SWIG_fail;
9157 }
9158 {
9159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9160 }
9161 return resultobj;
9162 fail:
9163 return NULL;
9164 }
9165
9166
9167 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9168 PyObject *resultobj;
9169 wxTraceMask result;
9170 char *kwnames[] = {
9171 NULL
9172 };
9173
9174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9175 {
9176 PyThreadState* __tstate = wxPyBeginAllowThreads();
9177 result = (wxTraceMask)wxLog::GetTraceMask();
9178
9179 wxPyEndAllowThreads(__tstate);
9180 if (PyErr_Occurred()) SWIG_fail;
9181 }
9182 {
9183 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9184 }
9185 return resultobj;
9186 fail:
9187 return NULL;
9188 }
9189
9190
9191 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9192 PyObject *resultobj;
9193 wxChar *arg1 = (wxChar *) 0 ;
9194 bool result;
9195 PyObject * obj0 = 0 ;
9196 char *kwnames[] = {
9197 (char *) "mask", NULL
9198 };
9199
9200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9202 if (SWIG_arg_fail(1)) SWIG_fail;
9203 {
9204 PyThreadState* __tstate = wxPyBeginAllowThreads();
9205 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9206
9207 wxPyEndAllowThreads(__tstate);
9208 if (PyErr_Occurred()) SWIG_fail;
9209 }
9210 {
9211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9212 }
9213 return resultobj;
9214 fail:
9215 return NULL;
9216 }
9217
9218
9219 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9220 PyObject *resultobj;
9221 wxLogLevel result;
9222 char *kwnames[] = {
9223 NULL
9224 };
9225
9226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9227 {
9228 PyThreadState* __tstate = wxPyBeginAllowThreads();
9229 result = (wxLogLevel)wxLog::GetLogLevel();
9230
9231 wxPyEndAllowThreads(__tstate);
9232 if (PyErr_Occurred()) SWIG_fail;
9233 }
9234 {
9235 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9236 }
9237 return resultobj;
9238 fail:
9239 return NULL;
9240 }
9241
9242
9243 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9244 PyObject *resultobj;
9245 wxChar *result;
9246 char *kwnames[] = {
9247 NULL
9248 };
9249
9250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9251 {
9252 PyThreadState* __tstate = wxPyBeginAllowThreads();
9253 result = (wxChar *)wxLog::GetTimestamp();
9254
9255 wxPyEndAllowThreads(__tstate);
9256 if (PyErr_Occurred()) SWIG_fail;
9257 }
9258 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9259 return resultobj;
9260 fail:
9261 return NULL;
9262 }
9263
9264
9265 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9266 PyObject *resultobj;
9267 wxString result;
9268 char *kwnames[] = {
9269 NULL
9270 };
9271
9272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9273 {
9274 PyThreadState* __tstate = wxPyBeginAllowThreads();
9275 result = Log_TimeStamp();
9276
9277 wxPyEndAllowThreads(__tstate);
9278 if (PyErr_Occurred()) SWIG_fail;
9279 }
9280 {
9281 #if wxUSE_UNICODE
9282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9283 #else
9284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9285 #endif
9286 }
9287 return resultobj;
9288 fail:
9289 return NULL;
9290 }
9291
9292
9293 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9294 PyObject *resultobj;
9295 wxLog *arg1 = (wxLog *) 0 ;
9296 PyObject * obj0 = 0 ;
9297 char *kwnames[] = {
9298 (char *) "self", NULL
9299 };
9300
9301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9303 if (SWIG_arg_fail(1)) SWIG_fail;
9304 {
9305 PyThreadState* __tstate = wxPyBeginAllowThreads();
9306 wxLog_Destroy(arg1);
9307
9308 wxPyEndAllowThreads(__tstate);
9309 if (PyErr_Occurred()) SWIG_fail;
9310 }
9311 Py_INCREF(Py_None); resultobj = Py_None;
9312 return resultobj;
9313 fail:
9314 return NULL;
9315 }
9316
9317
9318 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9319 PyObject *obj;
9320 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9321 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9322 Py_INCREF(obj);
9323 return Py_BuildValue((char *)"");
9324 }
9325 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9326 PyObject *resultobj;
9327 wxLogStderr *result;
9328 char *kwnames[] = {
9329 NULL
9330 };
9331
9332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9333 {
9334 PyThreadState* __tstate = wxPyBeginAllowThreads();
9335 result = (wxLogStderr *)new wxLogStderr();
9336
9337 wxPyEndAllowThreads(__tstate);
9338 if (PyErr_Occurred()) SWIG_fail;
9339 }
9340 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9341 return resultobj;
9342 fail:
9343 return NULL;
9344 }
9345
9346
9347 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9348 PyObject *obj;
9349 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9350 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9351 Py_INCREF(obj);
9352 return Py_BuildValue((char *)"");
9353 }
9354 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9355 PyObject *resultobj;
9356 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9357 wxLogTextCtrl *result;
9358 PyObject * obj0 = 0 ;
9359 char *kwnames[] = {
9360 (char *) "pTextCtrl", NULL
9361 };
9362
9363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9365 if (SWIG_arg_fail(1)) SWIG_fail;
9366 {
9367 PyThreadState* __tstate = wxPyBeginAllowThreads();
9368 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9369
9370 wxPyEndAllowThreads(__tstate);
9371 if (PyErr_Occurred()) SWIG_fail;
9372 }
9373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9374 return resultobj;
9375 fail:
9376 return NULL;
9377 }
9378
9379
9380 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9381 PyObject *obj;
9382 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9383 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9384 Py_INCREF(obj);
9385 return Py_BuildValue((char *)"");
9386 }
9387 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9388 PyObject *resultobj;
9389 wxLogGui *result;
9390 char *kwnames[] = {
9391 NULL
9392 };
9393
9394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9395 {
9396 PyThreadState* __tstate = wxPyBeginAllowThreads();
9397 result = (wxLogGui *)new wxLogGui();
9398
9399 wxPyEndAllowThreads(__tstate);
9400 if (PyErr_Occurred()) SWIG_fail;
9401 }
9402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9403 return resultobj;
9404 fail:
9405 return NULL;
9406 }
9407
9408
9409 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9410 PyObject *obj;
9411 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9412 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9413 Py_INCREF(obj);
9414 return Py_BuildValue((char *)"");
9415 }
9416 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9417 PyObject *resultobj;
9418 wxFrame *arg1 = (wxFrame *) 0 ;
9419 wxString *arg2 = 0 ;
9420 bool arg3 = (bool) true ;
9421 bool arg4 = (bool) true ;
9422 wxLogWindow *result;
9423 bool temp2 = false ;
9424 PyObject * obj0 = 0 ;
9425 PyObject * obj1 = 0 ;
9426 PyObject * obj2 = 0 ;
9427 PyObject * obj3 = 0 ;
9428 char *kwnames[] = {
9429 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9430 };
9431
9432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9434 if (SWIG_arg_fail(1)) SWIG_fail;
9435 {
9436 arg2 = wxString_in_helper(obj1);
9437 if (arg2 == NULL) SWIG_fail;
9438 temp2 = true;
9439 }
9440 if (obj2) {
9441 {
9442 arg3 = (bool)(SWIG_As_bool(obj2));
9443 if (SWIG_arg_fail(3)) SWIG_fail;
9444 }
9445 }
9446 if (obj3) {
9447 {
9448 arg4 = (bool)(SWIG_As_bool(obj3));
9449 if (SWIG_arg_fail(4)) SWIG_fail;
9450 }
9451 }
9452 {
9453 PyThreadState* __tstate = wxPyBeginAllowThreads();
9454 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9455
9456 wxPyEndAllowThreads(__tstate);
9457 if (PyErr_Occurred()) SWIG_fail;
9458 }
9459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9460 {
9461 if (temp2)
9462 delete arg2;
9463 }
9464 return resultobj;
9465 fail:
9466 {
9467 if (temp2)
9468 delete arg2;
9469 }
9470 return NULL;
9471 }
9472
9473
9474 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9475 PyObject *resultobj;
9476 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9477 bool arg2 = (bool) true ;
9478 PyObject * obj0 = 0 ;
9479 PyObject * obj1 = 0 ;
9480 char *kwnames[] = {
9481 (char *) "self",(char *) "bShow", NULL
9482 };
9483
9484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9486 if (SWIG_arg_fail(1)) SWIG_fail;
9487 if (obj1) {
9488 {
9489 arg2 = (bool)(SWIG_As_bool(obj1));
9490 if (SWIG_arg_fail(2)) SWIG_fail;
9491 }
9492 }
9493 {
9494 PyThreadState* __tstate = wxPyBeginAllowThreads();
9495 (arg1)->Show(arg2);
9496
9497 wxPyEndAllowThreads(__tstate);
9498 if (PyErr_Occurred()) SWIG_fail;
9499 }
9500 Py_INCREF(Py_None); resultobj = Py_None;
9501 return resultobj;
9502 fail:
9503 return NULL;
9504 }
9505
9506
9507 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9508 PyObject *resultobj;
9509 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9510 wxFrame *result;
9511 PyObject * obj0 = 0 ;
9512 char *kwnames[] = {
9513 (char *) "self", NULL
9514 };
9515
9516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9518 if (SWIG_arg_fail(1)) SWIG_fail;
9519 {
9520 PyThreadState* __tstate = wxPyBeginAllowThreads();
9521 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9522
9523 wxPyEndAllowThreads(__tstate);
9524 if (PyErr_Occurred()) SWIG_fail;
9525 }
9526 {
9527 resultobj = wxPyMake_wxObject(result, 0);
9528 }
9529 return resultobj;
9530 fail:
9531 return NULL;
9532 }
9533
9534
9535 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9536 PyObject *resultobj;
9537 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9538 wxLog *result;
9539 PyObject * obj0 = 0 ;
9540 char *kwnames[] = {
9541 (char *) "self", NULL
9542 };
9543
9544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9546 if (SWIG_arg_fail(1)) SWIG_fail;
9547 {
9548 PyThreadState* __tstate = wxPyBeginAllowThreads();
9549 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9550
9551 wxPyEndAllowThreads(__tstate);
9552 if (PyErr_Occurred()) SWIG_fail;
9553 }
9554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9555 return resultobj;
9556 fail:
9557 return NULL;
9558 }
9559
9560
9561 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9562 PyObject *resultobj;
9563 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9564 bool result;
9565 PyObject * obj0 = 0 ;
9566 char *kwnames[] = {
9567 (char *) "self", NULL
9568 };
9569
9570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9572 if (SWIG_arg_fail(1)) SWIG_fail;
9573 {
9574 PyThreadState* __tstate = wxPyBeginAllowThreads();
9575 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9576
9577 wxPyEndAllowThreads(__tstate);
9578 if (PyErr_Occurred()) SWIG_fail;
9579 }
9580 {
9581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9582 }
9583 return resultobj;
9584 fail:
9585 return NULL;
9586 }
9587
9588
9589 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9590 PyObject *resultobj;
9591 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9592 bool arg2 ;
9593 PyObject * obj0 = 0 ;
9594 PyObject * obj1 = 0 ;
9595 char *kwnames[] = {
9596 (char *) "self",(char *) "bDoPass", NULL
9597 };
9598
9599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9601 if (SWIG_arg_fail(1)) SWIG_fail;
9602 {
9603 arg2 = (bool)(SWIG_As_bool(obj1));
9604 if (SWIG_arg_fail(2)) SWIG_fail;
9605 }
9606 {
9607 PyThreadState* __tstate = wxPyBeginAllowThreads();
9608 (arg1)->PassMessages(arg2);
9609
9610 wxPyEndAllowThreads(__tstate);
9611 if (PyErr_Occurred()) SWIG_fail;
9612 }
9613 Py_INCREF(Py_None); resultobj = Py_None;
9614 return resultobj;
9615 fail:
9616 return NULL;
9617 }
9618
9619
9620 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9621 PyObject *obj;
9622 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9623 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9624 Py_INCREF(obj);
9625 return Py_BuildValue((char *)"");
9626 }
9627 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9628 PyObject *resultobj;
9629 wxLog *arg1 = (wxLog *) 0 ;
9630 wxLogChain *result;
9631 PyObject * obj0 = 0 ;
9632 char *kwnames[] = {
9633 (char *) "logger", NULL
9634 };
9635
9636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9638 if (SWIG_arg_fail(1)) SWIG_fail;
9639 {
9640 PyThreadState* __tstate = wxPyBeginAllowThreads();
9641 result = (wxLogChain *)new wxLogChain(arg1);
9642
9643 wxPyEndAllowThreads(__tstate);
9644 if (PyErr_Occurred()) SWIG_fail;
9645 }
9646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9647 return resultobj;
9648 fail:
9649 return NULL;
9650 }
9651
9652
9653 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9654 PyObject *resultobj;
9655 wxLogChain *arg1 = (wxLogChain *) 0 ;
9656 wxLog *arg2 = (wxLog *) 0 ;
9657 PyObject * obj0 = 0 ;
9658 PyObject * obj1 = 0 ;
9659 char *kwnames[] = {
9660 (char *) "self",(char *) "logger", NULL
9661 };
9662
9663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9665 if (SWIG_arg_fail(1)) SWIG_fail;
9666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9667 if (SWIG_arg_fail(2)) SWIG_fail;
9668 {
9669 PyThreadState* __tstate = wxPyBeginAllowThreads();
9670 (arg1)->SetLog(arg2);
9671
9672 wxPyEndAllowThreads(__tstate);
9673 if (PyErr_Occurred()) SWIG_fail;
9674 }
9675 Py_INCREF(Py_None); resultobj = Py_None;
9676 return resultobj;
9677 fail:
9678 return NULL;
9679 }
9680
9681
9682 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9683 PyObject *resultobj;
9684 wxLogChain *arg1 = (wxLogChain *) 0 ;
9685 bool arg2 ;
9686 PyObject * obj0 = 0 ;
9687 PyObject * obj1 = 0 ;
9688 char *kwnames[] = {
9689 (char *) "self",(char *) "bDoPass", NULL
9690 };
9691
9692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9694 if (SWIG_arg_fail(1)) SWIG_fail;
9695 {
9696 arg2 = (bool)(SWIG_As_bool(obj1));
9697 if (SWIG_arg_fail(2)) SWIG_fail;
9698 }
9699 {
9700 PyThreadState* __tstate = wxPyBeginAllowThreads();
9701 (arg1)->PassMessages(arg2);
9702
9703 wxPyEndAllowThreads(__tstate);
9704 if (PyErr_Occurred()) SWIG_fail;
9705 }
9706 Py_INCREF(Py_None); resultobj = Py_None;
9707 return resultobj;
9708 fail:
9709 return NULL;
9710 }
9711
9712
9713 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9714 PyObject *resultobj;
9715 wxLogChain *arg1 = (wxLogChain *) 0 ;
9716 bool result;
9717 PyObject * obj0 = 0 ;
9718 char *kwnames[] = {
9719 (char *) "self", NULL
9720 };
9721
9722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9724 if (SWIG_arg_fail(1)) SWIG_fail;
9725 {
9726 PyThreadState* __tstate = wxPyBeginAllowThreads();
9727 result = (bool)(arg1)->IsPassingMessages();
9728
9729 wxPyEndAllowThreads(__tstate);
9730 if (PyErr_Occurred()) SWIG_fail;
9731 }
9732 {
9733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9734 }
9735 return resultobj;
9736 fail:
9737 return NULL;
9738 }
9739
9740
9741 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9742 PyObject *resultobj;
9743 wxLogChain *arg1 = (wxLogChain *) 0 ;
9744 wxLog *result;
9745 PyObject * obj0 = 0 ;
9746 char *kwnames[] = {
9747 (char *) "self", NULL
9748 };
9749
9750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9752 if (SWIG_arg_fail(1)) SWIG_fail;
9753 {
9754 PyThreadState* __tstate = wxPyBeginAllowThreads();
9755 result = (wxLog *)(arg1)->GetOldLog();
9756
9757 wxPyEndAllowThreads(__tstate);
9758 if (PyErr_Occurred()) SWIG_fail;
9759 }
9760 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9761 return resultobj;
9762 fail:
9763 return NULL;
9764 }
9765
9766
9767 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9768 PyObject *obj;
9769 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9770 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9771 Py_INCREF(obj);
9772 return Py_BuildValue((char *)"");
9773 }
9774 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9775 PyObject *resultobj;
9776 unsigned long result;
9777 char *kwnames[] = {
9778 NULL
9779 };
9780
9781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9782 {
9783 PyThreadState* __tstate = wxPyBeginAllowThreads();
9784 result = (unsigned long)wxSysErrorCode();
9785
9786 wxPyEndAllowThreads(__tstate);
9787 if (PyErr_Occurred()) SWIG_fail;
9788 }
9789 {
9790 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9791 }
9792 return resultobj;
9793 fail:
9794 return NULL;
9795 }
9796
9797
9798 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9799 PyObject *resultobj;
9800 unsigned long arg1 = (unsigned long) 0 ;
9801 wxString result;
9802 PyObject * obj0 = 0 ;
9803 char *kwnames[] = {
9804 (char *) "nErrCode", NULL
9805 };
9806
9807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9808 if (obj0) {
9809 {
9810 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9811 if (SWIG_arg_fail(1)) SWIG_fail;
9812 }
9813 }
9814 {
9815 PyThreadState* __tstate = wxPyBeginAllowThreads();
9816 result = wxSysErrorMsg(arg1);
9817
9818 wxPyEndAllowThreads(__tstate);
9819 if (PyErr_Occurred()) SWIG_fail;
9820 }
9821 {
9822 #if wxUSE_UNICODE
9823 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9824 #else
9825 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9826 #endif
9827 }
9828 return resultobj;
9829 fail:
9830 return NULL;
9831 }
9832
9833
9834 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9835 PyObject *resultobj;
9836 wxString *arg1 = 0 ;
9837 bool temp1 = false ;
9838 PyObject * obj0 = 0 ;
9839 char *kwnames[] = {
9840 (char *) "msg", NULL
9841 };
9842
9843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9844 {
9845 arg1 = wxString_in_helper(obj0);
9846 if (arg1 == NULL) SWIG_fail;
9847 temp1 = true;
9848 }
9849 {
9850 PyThreadState* __tstate = wxPyBeginAllowThreads();
9851 wxPyLogFatalError((wxString const &)*arg1);
9852
9853 wxPyEndAllowThreads(__tstate);
9854 if (PyErr_Occurred()) SWIG_fail;
9855 }
9856 Py_INCREF(Py_None); resultobj = Py_None;
9857 {
9858 if (temp1)
9859 delete arg1;
9860 }
9861 return resultobj;
9862 fail:
9863 {
9864 if (temp1)
9865 delete arg1;
9866 }
9867 return NULL;
9868 }
9869
9870
9871 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
9872 PyObject *resultobj;
9873 wxString *arg1 = 0 ;
9874 bool temp1 = false ;
9875 PyObject * obj0 = 0 ;
9876 char *kwnames[] = {
9877 (char *) "msg", NULL
9878 };
9879
9880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
9881 {
9882 arg1 = wxString_in_helper(obj0);
9883 if (arg1 == NULL) SWIG_fail;
9884 temp1 = true;
9885 }
9886 {
9887 PyThreadState* __tstate = wxPyBeginAllowThreads();
9888 wxPyLogError((wxString const &)*arg1);
9889
9890 wxPyEndAllowThreads(__tstate);
9891 if (PyErr_Occurred()) SWIG_fail;
9892 }
9893 Py_INCREF(Py_None); resultobj = Py_None;
9894 {
9895 if (temp1)
9896 delete arg1;
9897 }
9898 return resultobj;
9899 fail:
9900 {
9901 if (temp1)
9902 delete arg1;
9903 }
9904 return NULL;
9905 }
9906
9907
9908 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
9909 PyObject *resultobj;
9910 wxString *arg1 = 0 ;
9911 bool temp1 = false ;
9912 PyObject * obj0 = 0 ;
9913 char *kwnames[] = {
9914 (char *) "msg", NULL
9915 };
9916
9917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
9918 {
9919 arg1 = wxString_in_helper(obj0);
9920 if (arg1 == NULL) SWIG_fail;
9921 temp1 = true;
9922 }
9923 {
9924 PyThreadState* __tstate = wxPyBeginAllowThreads();
9925 wxPyLogWarning((wxString const &)*arg1);
9926
9927 wxPyEndAllowThreads(__tstate);
9928 if (PyErr_Occurred()) SWIG_fail;
9929 }
9930 Py_INCREF(Py_None); resultobj = Py_None;
9931 {
9932 if (temp1)
9933 delete arg1;
9934 }
9935 return resultobj;
9936 fail:
9937 {
9938 if (temp1)
9939 delete arg1;
9940 }
9941 return NULL;
9942 }
9943
9944
9945 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
9946 PyObject *resultobj;
9947 wxString *arg1 = 0 ;
9948 bool temp1 = false ;
9949 PyObject * obj0 = 0 ;
9950 char *kwnames[] = {
9951 (char *) "msg", NULL
9952 };
9953
9954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
9955 {
9956 arg1 = wxString_in_helper(obj0);
9957 if (arg1 == NULL) SWIG_fail;
9958 temp1 = true;
9959 }
9960 {
9961 PyThreadState* __tstate = wxPyBeginAllowThreads();
9962 wxPyLogMessage((wxString const &)*arg1);
9963
9964 wxPyEndAllowThreads(__tstate);
9965 if (PyErr_Occurred()) SWIG_fail;
9966 }
9967 Py_INCREF(Py_None); resultobj = Py_None;
9968 {
9969 if (temp1)
9970 delete arg1;
9971 }
9972 return resultobj;
9973 fail:
9974 {
9975 if (temp1)
9976 delete arg1;
9977 }
9978 return NULL;
9979 }
9980
9981
9982 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
9983 PyObject *resultobj;
9984 wxString *arg1 = 0 ;
9985 bool temp1 = false ;
9986 PyObject * obj0 = 0 ;
9987 char *kwnames[] = {
9988 (char *) "msg", NULL
9989 };
9990
9991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
9992 {
9993 arg1 = wxString_in_helper(obj0);
9994 if (arg1 == NULL) SWIG_fail;
9995 temp1 = true;
9996 }
9997 {
9998 PyThreadState* __tstate = wxPyBeginAllowThreads();
9999 wxPyLogInfo((wxString const &)*arg1);
10000
10001 wxPyEndAllowThreads(__tstate);
10002 if (PyErr_Occurred()) SWIG_fail;
10003 }
10004 Py_INCREF(Py_None); resultobj = Py_None;
10005 {
10006 if (temp1)
10007 delete arg1;
10008 }
10009 return resultobj;
10010 fail:
10011 {
10012 if (temp1)
10013 delete arg1;
10014 }
10015 return NULL;
10016 }
10017
10018
10019 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10020 PyObject *resultobj;
10021 wxString *arg1 = 0 ;
10022 bool temp1 = false ;
10023 PyObject * obj0 = 0 ;
10024 char *kwnames[] = {
10025 (char *) "msg", NULL
10026 };
10027
10028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10029 {
10030 arg1 = wxString_in_helper(obj0);
10031 if (arg1 == NULL) SWIG_fail;
10032 temp1 = true;
10033 }
10034 {
10035 PyThreadState* __tstate = wxPyBeginAllowThreads();
10036 wxPyLogDebug((wxString const &)*arg1);
10037
10038 wxPyEndAllowThreads(__tstate);
10039 if (PyErr_Occurred()) SWIG_fail;
10040 }
10041 Py_INCREF(Py_None); resultobj = Py_None;
10042 {
10043 if (temp1)
10044 delete arg1;
10045 }
10046 return resultobj;
10047 fail:
10048 {
10049 if (temp1)
10050 delete arg1;
10051 }
10052 return NULL;
10053 }
10054
10055
10056 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10057 PyObject *resultobj;
10058 wxString *arg1 = 0 ;
10059 bool temp1 = false ;
10060 PyObject * obj0 = 0 ;
10061 char *kwnames[] = {
10062 (char *) "msg", NULL
10063 };
10064
10065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10066 {
10067 arg1 = wxString_in_helper(obj0);
10068 if (arg1 == NULL) SWIG_fail;
10069 temp1 = true;
10070 }
10071 {
10072 PyThreadState* __tstate = wxPyBeginAllowThreads();
10073 wxPyLogVerbose((wxString const &)*arg1);
10074
10075 wxPyEndAllowThreads(__tstate);
10076 if (PyErr_Occurred()) SWIG_fail;
10077 }
10078 Py_INCREF(Py_None); resultobj = Py_None;
10079 {
10080 if (temp1)
10081 delete arg1;
10082 }
10083 return resultobj;
10084 fail:
10085 {
10086 if (temp1)
10087 delete arg1;
10088 }
10089 return NULL;
10090 }
10091
10092
10093 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10094 PyObject *resultobj;
10095 wxString *arg1 = 0 ;
10096 bool temp1 = false ;
10097 PyObject * obj0 = 0 ;
10098 char *kwnames[] = {
10099 (char *) "msg", NULL
10100 };
10101
10102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10103 {
10104 arg1 = wxString_in_helper(obj0);
10105 if (arg1 == NULL) SWIG_fail;
10106 temp1 = true;
10107 }
10108 {
10109 PyThreadState* __tstate = wxPyBeginAllowThreads();
10110 wxPyLogStatus((wxString const &)*arg1);
10111
10112 wxPyEndAllowThreads(__tstate);
10113 if (PyErr_Occurred()) SWIG_fail;
10114 }
10115 Py_INCREF(Py_None); resultobj = Py_None;
10116 {
10117 if (temp1)
10118 delete arg1;
10119 }
10120 return resultobj;
10121 fail:
10122 {
10123 if (temp1)
10124 delete arg1;
10125 }
10126 return NULL;
10127 }
10128
10129
10130 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10131 PyObject *resultobj;
10132 wxFrame *arg1 = (wxFrame *) 0 ;
10133 wxString *arg2 = 0 ;
10134 bool temp2 = false ;
10135 PyObject * obj0 = 0 ;
10136 PyObject * obj1 = 0 ;
10137 char *kwnames[] = {
10138 (char *) "pFrame",(char *) "msg", NULL
10139 };
10140
10141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10143 if (SWIG_arg_fail(1)) SWIG_fail;
10144 {
10145 arg2 = wxString_in_helper(obj1);
10146 if (arg2 == NULL) SWIG_fail;
10147 temp2 = true;
10148 }
10149 {
10150 PyThreadState* __tstate = wxPyBeginAllowThreads();
10151 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10152
10153 wxPyEndAllowThreads(__tstate);
10154 if (PyErr_Occurred()) SWIG_fail;
10155 }
10156 Py_INCREF(Py_None); resultobj = Py_None;
10157 {
10158 if (temp2)
10159 delete arg2;
10160 }
10161 return resultobj;
10162 fail:
10163 {
10164 if (temp2)
10165 delete arg2;
10166 }
10167 return NULL;
10168 }
10169
10170
10171 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10172 PyObject *resultobj;
10173 wxString *arg1 = 0 ;
10174 bool temp1 = false ;
10175 PyObject * obj0 = 0 ;
10176 char *kwnames[] = {
10177 (char *) "msg", NULL
10178 };
10179
10180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10181 {
10182 arg1 = wxString_in_helper(obj0);
10183 if (arg1 == NULL) SWIG_fail;
10184 temp1 = true;
10185 }
10186 {
10187 PyThreadState* __tstate = wxPyBeginAllowThreads();
10188 wxPyLogSysError((wxString const &)*arg1);
10189
10190 wxPyEndAllowThreads(__tstate);
10191 if (PyErr_Occurred()) SWIG_fail;
10192 }
10193 Py_INCREF(Py_None); resultobj = Py_None;
10194 {
10195 if (temp1)
10196 delete arg1;
10197 }
10198 return resultobj;
10199 fail:
10200 {
10201 if (temp1)
10202 delete arg1;
10203 }
10204 return NULL;
10205 }
10206
10207
10208 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10209 PyObject *resultobj;
10210 unsigned long arg1 ;
10211 wxString *arg2 = 0 ;
10212 bool temp2 = false ;
10213 PyObject * obj0 = 0 ;
10214 PyObject * obj1 = 0 ;
10215 char *kwnames[] = {
10216 (char *) "level",(char *) "msg", NULL
10217 };
10218
10219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10220 {
10221 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10222 if (SWIG_arg_fail(1)) SWIG_fail;
10223 }
10224 {
10225 arg2 = wxString_in_helper(obj1);
10226 if (arg2 == NULL) SWIG_fail;
10227 temp2 = true;
10228 }
10229 {
10230 PyThreadState* __tstate = wxPyBeginAllowThreads();
10231 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10232
10233 wxPyEndAllowThreads(__tstate);
10234 if (PyErr_Occurred()) SWIG_fail;
10235 }
10236 Py_INCREF(Py_None); resultobj = Py_None;
10237 {
10238 if (temp2)
10239 delete arg2;
10240 }
10241 return resultobj;
10242 fail:
10243 {
10244 if (temp2)
10245 delete arg2;
10246 }
10247 return NULL;
10248 }
10249
10250
10251 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10252 PyObject *resultobj;
10253 unsigned long arg1 ;
10254 wxString *arg2 = 0 ;
10255 bool temp2 = false ;
10256 PyObject * obj0 = 0 ;
10257 PyObject * obj1 = 0 ;
10258
10259 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10260 {
10261 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10262 if (SWIG_arg_fail(1)) SWIG_fail;
10263 }
10264 {
10265 arg2 = wxString_in_helper(obj1);
10266 if (arg2 == NULL) SWIG_fail;
10267 temp2 = true;
10268 }
10269 {
10270 PyThreadState* __tstate = wxPyBeginAllowThreads();
10271 wxPyLogTrace(arg1,(wxString const &)*arg2);
10272
10273 wxPyEndAllowThreads(__tstate);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 Py_INCREF(Py_None); resultobj = Py_None;
10277 {
10278 if (temp2)
10279 delete arg2;
10280 }
10281 return resultobj;
10282 fail:
10283 {
10284 if (temp2)
10285 delete arg2;
10286 }
10287 return NULL;
10288 }
10289
10290
10291 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10292 PyObject *resultobj;
10293 wxString *arg1 = 0 ;
10294 wxString *arg2 = 0 ;
10295 bool temp1 = false ;
10296 bool temp2 = false ;
10297 PyObject * obj0 = 0 ;
10298 PyObject * obj1 = 0 ;
10299
10300 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10301 {
10302 arg1 = wxString_in_helper(obj0);
10303 if (arg1 == NULL) SWIG_fail;
10304 temp1 = true;
10305 }
10306 {
10307 arg2 = wxString_in_helper(obj1);
10308 if (arg2 == NULL) SWIG_fail;
10309 temp2 = true;
10310 }
10311 {
10312 PyThreadState* __tstate = wxPyBeginAllowThreads();
10313 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10314
10315 wxPyEndAllowThreads(__tstate);
10316 if (PyErr_Occurred()) SWIG_fail;
10317 }
10318 Py_INCREF(Py_None); resultobj = Py_None;
10319 {
10320 if (temp1)
10321 delete arg1;
10322 }
10323 {
10324 if (temp2)
10325 delete arg2;
10326 }
10327 return resultobj;
10328 fail:
10329 {
10330 if (temp1)
10331 delete arg1;
10332 }
10333 {
10334 if (temp2)
10335 delete arg2;
10336 }
10337 return NULL;
10338 }
10339
10340
10341 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10342 int argc;
10343 PyObject *argv[3];
10344 int ii;
10345
10346 argc = PyObject_Length(args);
10347 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10348 argv[ii] = PyTuple_GetItem(args,ii);
10349 }
10350 if (argc == 2) {
10351 int _v;
10352 {
10353 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10354 }
10355 if (_v) {
10356 {
10357 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10358 }
10359 if (_v) {
10360 return _wrap_LogTrace__SWIG_1(self,args);
10361 }
10362 }
10363 }
10364 if (argc == 2) {
10365 int _v;
10366 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10367 if (_v) {
10368 {
10369 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10370 }
10371 if (_v) {
10372 return _wrap_LogTrace__SWIG_0(self,args);
10373 }
10374 }
10375 }
10376
10377 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10378 return NULL;
10379 }
10380
10381
10382 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10383 PyObject *resultobj;
10384 wxString *arg1 = 0 ;
10385 wxString *arg2 = 0 ;
10386 bool temp1 = false ;
10387 bool temp2 = false ;
10388 PyObject * obj0 = 0 ;
10389 PyObject * obj1 = 0 ;
10390 char *kwnames[] = {
10391 (char *) "title",(char *) "text", NULL
10392 };
10393
10394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10395 {
10396 arg1 = wxString_in_helper(obj0);
10397 if (arg1 == NULL) SWIG_fail;
10398 temp1 = true;
10399 }
10400 {
10401 arg2 = wxString_in_helper(obj1);
10402 if (arg2 == NULL) SWIG_fail;
10403 temp2 = true;
10404 }
10405 {
10406 PyThreadState* __tstate = wxPyBeginAllowThreads();
10407 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10408
10409 wxPyEndAllowThreads(__tstate);
10410 if (PyErr_Occurred()) SWIG_fail;
10411 }
10412 Py_INCREF(Py_None); resultobj = Py_None;
10413 {
10414 if (temp1)
10415 delete arg1;
10416 }
10417 {
10418 if (temp2)
10419 delete arg2;
10420 }
10421 return resultobj;
10422 fail:
10423 {
10424 if (temp1)
10425 delete arg1;
10426 }
10427 {
10428 if (temp2)
10429 delete arg2;
10430 }
10431 return NULL;
10432 }
10433
10434
10435 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10436 PyObject *resultobj;
10437 wxLogNull *result;
10438 char *kwnames[] = {
10439 NULL
10440 };
10441
10442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10443 {
10444 PyThreadState* __tstate = wxPyBeginAllowThreads();
10445 result = (wxLogNull *)new wxLogNull();
10446
10447 wxPyEndAllowThreads(__tstate);
10448 if (PyErr_Occurred()) SWIG_fail;
10449 }
10450 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10451 return resultobj;
10452 fail:
10453 return NULL;
10454 }
10455
10456
10457 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10458 PyObject *resultobj;
10459 wxLogNull *arg1 = (wxLogNull *) 0 ;
10460 PyObject * obj0 = 0 ;
10461 char *kwnames[] = {
10462 (char *) "self", NULL
10463 };
10464
10465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10467 if (SWIG_arg_fail(1)) SWIG_fail;
10468 {
10469 PyThreadState* __tstate = wxPyBeginAllowThreads();
10470 delete arg1;
10471
10472 wxPyEndAllowThreads(__tstate);
10473 if (PyErr_Occurred()) SWIG_fail;
10474 }
10475 Py_INCREF(Py_None); resultobj = Py_None;
10476 return resultobj;
10477 fail:
10478 return NULL;
10479 }
10480
10481
10482 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10483 PyObject *obj;
10484 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10485 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10486 Py_INCREF(obj);
10487 return Py_BuildValue((char *)"");
10488 }
10489 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10490 PyObject *resultobj;
10491 wxPyLog *result;
10492 char *kwnames[] = {
10493 NULL
10494 };
10495
10496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10497 {
10498 PyThreadState* __tstate = wxPyBeginAllowThreads();
10499 result = (wxPyLog *)new wxPyLog();
10500
10501 wxPyEndAllowThreads(__tstate);
10502 if (PyErr_Occurred()) SWIG_fail;
10503 }
10504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10505 return resultobj;
10506 fail:
10507 return NULL;
10508 }
10509
10510
10511 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10512 PyObject *resultobj;
10513 wxPyLog *arg1 = (wxPyLog *) 0 ;
10514 PyObject *arg2 = (PyObject *) 0 ;
10515 PyObject *arg3 = (PyObject *) 0 ;
10516 PyObject * obj0 = 0 ;
10517 PyObject * obj1 = 0 ;
10518 PyObject * obj2 = 0 ;
10519 char *kwnames[] = {
10520 (char *) "self",(char *) "self",(char *) "_class", NULL
10521 };
10522
10523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10525 if (SWIG_arg_fail(1)) SWIG_fail;
10526 arg2 = obj1;
10527 arg3 = obj2;
10528 {
10529 PyThreadState* __tstate = wxPyBeginAllowThreads();
10530 (arg1)->_setCallbackInfo(arg2,arg3);
10531
10532 wxPyEndAllowThreads(__tstate);
10533 if (PyErr_Occurred()) SWIG_fail;
10534 }
10535 Py_INCREF(Py_None); resultobj = Py_None;
10536 return resultobj;
10537 fail:
10538 return NULL;
10539 }
10540
10541
10542 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10543 PyObject *obj;
10544 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10545 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10546 Py_INCREF(obj);
10547 return Py_BuildValue((char *)"");
10548 }
10549 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10550 PyObject *resultobj;
10551 int arg1 ;
10552 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10553 int arg3 = (int) wxKILL_NOCHILDREN ;
10554 wxKillError result;
10555 PyObject * obj0 = 0 ;
10556 PyObject * obj1 = 0 ;
10557 PyObject * obj2 = 0 ;
10558 char *kwnames[] = {
10559 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10560 };
10561
10562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10563 {
10564 arg1 = (int)(SWIG_As_int(obj0));
10565 if (SWIG_arg_fail(1)) SWIG_fail;
10566 }
10567 if (obj1) {
10568 {
10569 arg2 = (wxSignal)(SWIG_As_int(obj1));
10570 if (SWIG_arg_fail(2)) SWIG_fail;
10571 }
10572 }
10573 if (obj2) {
10574 {
10575 arg3 = (int)(SWIG_As_int(obj2));
10576 if (SWIG_arg_fail(3)) SWIG_fail;
10577 }
10578 }
10579 {
10580 PyThreadState* __tstate = wxPyBeginAllowThreads();
10581 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10582
10583 wxPyEndAllowThreads(__tstate);
10584 if (PyErr_Occurred()) SWIG_fail;
10585 }
10586 resultobj = SWIG_From_int((result));
10587 return resultobj;
10588 fail:
10589 return NULL;
10590 }
10591
10592
10593 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10594 PyObject *resultobj;
10595 int arg1 ;
10596 bool result;
10597 PyObject * obj0 = 0 ;
10598 char *kwnames[] = {
10599 (char *) "pid", NULL
10600 };
10601
10602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10603 {
10604 arg1 = (int)(SWIG_As_int(obj0));
10605 if (SWIG_arg_fail(1)) SWIG_fail;
10606 }
10607 {
10608 PyThreadState* __tstate = wxPyBeginAllowThreads();
10609 result = (bool)wxPyProcess::Exists(arg1);
10610
10611 wxPyEndAllowThreads(__tstate);
10612 if (PyErr_Occurred()) SWIG_fail;
10613 }
10614 {
10615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10616 }
10617 return resultobj;
10618 fail:
10619 return NULL;
10620 }
10621
10622
10623 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10624 PyObject *resultobj;
10625 wxString *arg1 = 0 ;
10626 int arg2 = (int) wxEXEC_ASYNC ;
10627 wxPyProcess *result;
10628 bool temp1 = false ;
10629 PyObject * obj0 = 0 ;
10630 PyObject * obj1 = 0 ;
10631 char *kwnames[] = {
10632 (char *) "cmd",(char *) "flags", NULL
10633 };
10634
10635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10636 {
10637 arg1 = wxString_in_helper(obj0);
10638 if (arg1 == NULL) SWIG_fail;
10639 temp1 = true;
10640 }
10641 if (obj1) {
10642 {
10643 arg2 = (int)(SWIG_As_int(obj1));
10644 if (SWIG_arg_fail(2)) SWIG_fail;
10645 }
10646 }
10647 {
10648 PyThreadState* __tstate = wxPyBeginAllowThreads();
10649 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10650
10651 wxPyEndAllowThreads(__tstate);
10652 if (PyErr_Occurred()) SWIG_fail;
10653 }
10654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10655 {
10656 if (temp1)
10657 delete arg1;
10658 }
10659 return resultobj;
10660 fail:
10661 {
10662 if (temp1)
10663 delete arg1;
10664 }
10665 return NULL;
10666 }
10667
10668
10669 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10670 PyObject *resultobj;
10671 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10672 int arg2 = (int) -1 ;
10673 wxPyProcess *result;
10674 PyObject * obj0 = 0 ;
10675 PyObject * obj1 = 0 ;
10676 char *kwnames[] = {
10677 (char *) "parent",(char *) "id", NULL
10678 };
10679
10680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10681 if (obj0) {
10682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10683 if (SWIG_arg_fail(1)) SWIG_fail;
10684 }
10685 if (obj1) {
10686 {
10687 arg2 = (int)(SWIG_As_int(obj1));
10688 if (SWIG_arg_fail(2)) SWIG_fail;
10689 }
10690 }
10691 {
10692 PyThreadState* __tstate = wxPyBeginAllowThreads();
10693 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10694
10695 wxPyEndAllowThreads(__tstate);
10696 if (PyErr_Occurred()) SWIG_fail;
10697 }
10698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10699 return resultobj;
10700 fail:
10701 return NULL;
10702 }
10703
10704
10705 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10706 PyObject *resultobj;
10707 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10708 PyObject *arg2 = (PyObject *) 0 ;
10709 PyObject *arg3 = (PyObject *) 0 ;
10710 PyObject * obj0 = 0 ;
10711 PyObject * obj1 = 0 ;
10712 PyObject * obj2 = 0 ;
10713 char *kwnames[] = {
10714 (char *) "self",(char *) "self",(char *) "_class", NULL
10715 };
10716
10717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10719 if (SWIG_arg_fail(1)) SWIG_fail;
10720 arg2 = obj1;
10721 arg3 = obj2;
10722 {
10723 PyThreadState* __tstate = wxPyBeginAllowThreads();
10724 (arg1)->_setCallbackInfo(arg2,arg3);
10725
10726 wxPyEndAllowThreads(__tstate);
10727 if (PyErr_Occurred()) SWIG_fail;
10728 }
10729 Py_INCREF(Py_None); resultobj = Py_None;
10730 return resultobj;
10731 fail:
10732 return NULL;
10733 }
10734
10735
10736 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10737 PyObject *resultobj;
10738 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10739 int arg2 ;
10740 int arg3 ;
10741 PyObject * obj0 = 0 ;
10742 PyObject * obj1 = 0 ;
10743 PyObject * obj2 = 0 ;
10744 char *kwnames[] = {
10745 (char *) "self",(char *) "pid",(char *) "status", NULL
10746 };
10747
10748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10750 if (SWIG_arg_fail(1)) SWIG_fail;
10751 {
10752 arg2 = (int)(SWIG_As_int(obj1));
10753 if (SWIG_arg_fail(2)) SWIG_fail;
10754 }
10755 {
10756 arg3 = (int)(SWIG_As_int(obj2));
10757 if (SWIG_arg_fail(3)) SWIG_fail;
10758 }
10759 {
10760 PyThreadState* __tstate = wxPyBeginAllowThreads();
10761 (arg1)->base_OnTerminate(arg2,arg3);
10762
10763 wxPyEndAllowThreads(__tstate);
10764 if (PyErr_Occurred()) SWIG_fail;
10765 }
10766 Py_INCREF(Py_None); resultobj = Py_None;
10767 return resultobj;
10768 fail:
10769 return NULL;
10770 }
10771
10772
10773 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10774 PyObject *resultobj;
10775 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10776 PyObject * obj0 = 0 ;
10777 char *kwnames[] = {
10778 (char *) "self", NULL
10779 };
10780
10781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10783 if (SWIG_arg_fail(1)) SWIG_fail;
10784 {
10785 PyThreadState* __tstate = wxPyBeginAllowThreads();
10786 (arg1)->Redirect();
10787
10788 wxPyEndAllowThreads(__tstate);
10789 if (PyErr_Occurred()) SWIG_fail;
10790 }
10791 Py_INCREF(Py_None); resultobj = Py_None;
10792 return resultobj;
10793 fail:
10794 return NULL;
10795 }
10796
10797
10798 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10799 PyObject *resultobj;
10800 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10801 bool result;
10802 PyObject * obj0 = 0 ;
10803 char *kwnames[] = {
10804 (char *) "self", NULL
10805 };
10806
10807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10809 if (SWIG_arg_fail(1)) SWIG_fail;
10810 {
10811 PyThreadState* __tstate = wxPyBeginAllowThreads();
10812 result = (bool)(arg1)->IsRedirected();
10813
10814 wxPyEndAllowThreads(__tstate);
10815 if (PyErr_Occurred()) SWIG_fail;
10816 }
10817 {
10818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10819 }
10820 return resultobj;
10821 fail:
10822 return NULL;
10823 }
10824
10825
10826 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10827 PyObject *resultobj;
10828 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10829 PyObject * obj0 = 0 ;
10830 char *kwnames[] = {
10831 (char *) "self", NULL
10832 };
10833
10834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10836 if (SWIG_arg_fail(1)) SWIG_fail;
10837 {
10838 PyThreadState* __tstate = wxPyBeginAllowThreads();
10839 (arg1)->Detach();
10840
10841 wxPyEndAllowThreads(__tstate);
10842 if (PyErr_Occurred()) SWIG_fail;
10843 }
10844 Py_INCREF(Py_None); resultobj = Py_None;
10845 return resultobj;
10846 fail:
10847 return NULL;
10848 }
10849
10850
10851 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10852 PyObject *resultobj;
10853 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10854 wxInputStream *result;
10855 PyObject * obj0 = 0 ;
10856 char *kwnames[] = {
10857 (char *) "self", NULL
10858 };
10859
10860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
10861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10862 if (SWIG_arg_fail(1)) SWIG_fail;
10863 {
10864 PyThreadState* __tstate = wxPyBeginAllowThreads();
10865 result = (wxInputStream *)(arg1)->GetInputStream();
10866
10867 wxPyEndAllowThreads(__tstate);
10868 if (PyErr_Occurred()) SWIG_fail;
10869 }
10870 {
10871 wxPyInputStream * _ptr = NULL;
10872
10873 if (result) {
10874 _ptr = new wxPyInputStream(result);
10875 }
10876 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10877 }
10878 return resultobj;
10879 fail:
10880 return NULL;
10881 }
10882
10883
10884 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
10885 PyObject *resultobj;
10886 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10887 wxInputStream *result;
10888 PyObject * obj0 = 0 ;
10889 char *kwnames[] = {
10890 (char *) "self", NULL
10891 };
10892
10893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
10894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10895 if (SWIG_arg_fail(1)) SWIG_fail;
10896 {
10897 PyThreadState* __tstate = wxPyBeginAllowThreads();
10898 result = (wxInputStream *)(arg1)->GetErrorStream();
10899
10900 wxPyEndAllowThreads(__tstate);
10901 if (PyErr_Occurred()) SWIG_fail;
10902 }
10903 {
10904 wxPyInputStream * _ptr = NULL;
10905
10906 if (result) {
10907 _ptr = new wxPyInputStream(result);
10908 }
10909 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10910 }
10911 return resultobj;
10912 fail:
10913 return NULL;
10914 }
10915
10916
10917 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10918 PyObject *resultobj;
10919 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10920 wxOutputStream *result;
10921 PyObject * obj0 = 0 ;
10922 char *kwnames[] = {
10923 (char *) "self", NULL
10924 };
10925
10926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
10927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10928 if (SWIG_arg_fail(1)) SWIG_fail;
10929 {
10930 PyThreadState* __tstate = wxPyBeginAllowThreads();
10931 result = (wxOutputStream *)(arg1)->GetOutputStream();
10932
10933 wxPyEndAllowThreads(__tstate);
10934 if (PyErr_Occurred()) SWIG_fail;
10935 }
10936 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
10937 return resultobj;
10938 fail:
10939 return NULL;
10940 }
10941
10942
10943 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
10944 PyObject *resultobj;
10945 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10946 PyObject * obj0 = 0 ;
10947 char *kwnames[] = {
10948 (char *) "self", NULL
10949 };
10950
10951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
10952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10953 if (SWIG_arg_fail(1)) SWIG_fail;
10954 {
10955 PyThreadState* __tstate = wxPyBeginAllowThreads();
10956 (arg1)->CloseOutput();
10957
10958 wxPyEndAllowThreads(__tstate);
10959 if (PyErr_Occurred()) SWIG_fail;
10960 }
10961 Py_INCREF(Py_None); resultobj = Py_None;
10962 return resultobj;
10963 fail:
10964 return NULL;
10965 }
10966
10967
10968 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
10969 PyObject *resultobj;
10970 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10971 bool result;
10972 PyObject * obj0 = 0 ;
10973 char *kwnames[] = {
10974 (char *) "self", NULL
10975 };
10976
10977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
10978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10979 if (SWIG_arg_fail(1)) SWIG_fail;
10980 {
10981 PyThreadState* __tstate = wxPyBeginAllowThreads();
10982 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
10983
10984 wxPyEndAllowThreads(__tstate);
10985 if (PyErr_Occurred()) SWIG_fail;
10986 }
10987 {
10988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10989 }
10990 return resultobj;
10991 fail:
10992 return NULL;
10993 }
10994
10995
10996 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
10997 PyObject *resultobj;
10998 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10999 bool result;
11000 PyObject * obj0 = 0 ;
11001 char *kwnames[] = {
11002 (char *) "self", NULL
11003 };
11004
11005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11007 if (SWIG_arg_fail(1)) SWIG_fail;
11008 {
11009 PyThreadState* __tstate = wxPyBeginAllowThreads();
11010 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11011
11012 wxPyEndAllowThreads(__tstate);
11013 if (PyErr_Occurred()) SWIG_fail;
11014 }
11015 {
11016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11017 }
11018 return resultobj;
11019 fail:
11020 return NULL;
11021 }
11022
11023
11024 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11025 PyObject *resultobj;
11026 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11027 bool result;
11028 PyObject * obj0 = 0 ;
11029 char *kwnames[] = {
11030 (char *) "self", NULL
11031 };
11032
11033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11035 if (SWIG_arg_fail(1)) SWIG_fail;
11036 {
11037 PyThreadState* __tstate = wxPyBeginAllowThreads();
11038 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11039
11040 wxPyEndAllowThreads(__tstate);
11041 if (PyErr_Occurred()) SWIG_fail;
11042 }
11043 {
11044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11045 }
11046 return resultobj;
11047 fail:
11048 return NULL;
11049 }
11050
11051
11052 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11053 PyObject *obj;
11054 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11055 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11056 Py_INCREF(obj);
11057 return Py_BuildValue((char *)"");
11058 }
11059 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11060 PyObject *resultobj;
11061 int arg1 = (int) 0 ;
11062 int arg2 = (int) 0 ;
11063 int arg3 = (int) 0 ;
11064 wxProcessEvent *result;
11065 PyObject * obj0 = 0 ;
11066 PyObject * obj1 = 0 ;
11067 PyObject * obj2 = 0 ;
11068 char *kwnames[] = {
11069 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11070 };
11071
11072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11073 if (obj0) {
11074 {
11075 arg1 = (int)(SWIG_As_int(obj0));
11076 if (SWIG_arg_fail(1)) SWIG_fail;
11077 }
11078 }
11079 if (obj1) {
11080 {
11081 arg2 = (int)(SWIG_As_int(obj1));
11082 if (SWIG_arg_fail(2)) SWIG_fail;
11083 }
11084 }
11085 if (obj2) {
11086 {
11087 arg3 = (int)(SWIG_As_int(obj2));
11088 if (SWIG_arg_fail(3)) SWIG_fail;
11089 }
11090 }
11091 {
11092 PyThreadState* __tstate = wxPyBeginAllowThreads();
11093 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11094
11095 wxPyEndAllowThreads(__tstate);
11096 if (PyErr_Occurred()) SWIG_fail;
11097 }
11098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11099 return resultobj;
11100 fail:
11101 return NULL;
11102 }
11103
11104
11105 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11106 PyObject *resultobj;
11107 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11108 int result;
11109 PyObject * obj0 = 0 ;
11110 char *kwnames[] = {
11111 (char *) "self", NULL
11112 };
11113
11114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11116 if (SWIG_arg_fail(1)) SWIG_fail;
11117 {
11118 PyThreadState* __tstate = wxPyBeginAllowThreads();
11119 result = (int)(arg1)->GetPid();
11120
11121 wxPyEndAllowThreads(__tstate);
11122 if (PyErr_Occurred()) SWIG_fail;
11123 }
11124 {
11125 resultobj = SWIG_From_int((int)(result));
11126 }
11127 return resultobj;
11128 fail:
11129 return NULL;
11130 }
11131
11132
11133 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11134 PyObject *resultobj;
11135 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11136 int result;
11137 PyObject * obj0 = 0 ;
11138 char *kwnames[] = {
11139 (char *) "self", NULL
11140 };
11141
11142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11144 if (SWIG_arg_fail(1)) SWIG_fail;
11145 {
11146 PyThreadState* __tstate = wxPyBeginAllowThreads();
11147 result = (int)(arg1)->GetExitCode();
11148
11149 wxPyEndAllowThreads(__tstate);
11150 if (PyErr_Occurred()) SWIG_fail;
11151 }
11152 {
11153 resultobj = SWIG_From_int((int)(result));
11154 }
11155 return resultobj;
11156 fail:
11157 return NULL;
11158 }
11159
11160
11161 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11162 PyObject *resultobj;
11163 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11164 int arg2 ;
11165 PyObject * obj0 = 0 ;
11166 PyObject * obj1 = 0 ;
11167 char *kwnames[] = {
11168 (char *) "self",(char *) "m_pid", NULL
11169 };
11170
11171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11173 if (SWIG_arg_fail(1)) SWIG_fail;
11174 {
11175 arg2 = (int)(SWIG_As_int(obj1));
11176 if (SWIG_arg_fail(2)) SWIG_fail;
11177 }
11178 if (arg1) (arg1)->m_pid = arg2;
11179
11180 Py_INCREF(Py_None); resultobj = Py_None;
11181 return resultobj;
11182 fail:
11183 return NULL;
11184 }
11185
11186
11187 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11188 PyObject *resultobj;
11189 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11190 int result;
11191 PyObject * obj0 = 0 ;
11192 char *kwnames[] = {
11193 (char *) "self", NULL
11194 };
11195
11196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11198 if (SWIG_arg_fail(1)) SWIG_fail;
11199 result = (int) ((arg1)->m_pid);
11200
11201 {
11202 resultobj = SWIG_From_int((int)(result));
11203 }
11204 return resultobj;
11205 fail:
11206 return NULL;
11207 }
11208
11209
11210 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11211 PyObject *resultobj;
11212 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11213 int arg2 ;
11214 PyObject * obj0 = 0 ;
11215 PyObject * obj1 = 0 ;
11216 char *kwnames[] = {
11217 (char *) "self",(char *) "m_exitcode", NULL
11218 };
11219
11220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11222 if (SWIG_arg_fail(1)) SWIG_fail;
11223 {
11224 arg2 = (int)(SWIG_As_int(obj1));
11225 if (SWIG_arg_fail(2)) SWIG_fail;
11226 }
11227 if (arg1) (arg1)->m_exitcode = arg2;
11228
11229 Py_INCREF(Py_None); resultobj = Py_None;
11230 return resultobj;
11231 fail:
11232 return NULL;
11233 }
11234
11235
11236 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11237 PyObject *resultobj;
11238 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11239 int result;
11240 PyObject * obj0 = 0 ;
11241 char *kwnames[] = {
11242 (char *) "self", NULL
11243 };
11244
11245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11247 if (SWIG_arg_fail(1)) SWIG_fail;
11248 result = (int) ((arg1)->m_exitcode);
11249
11250 {
11251 resultobj = SWIG_From_int((int)(result));
11252 }
11253 return resultobj;
11254 fail:
11255 return NULL;
11256 }
11257
11258
11259 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11260 PyObject *obj;
11261 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11262 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11263 Py_INCREF(obj);
11264 return Py_BuildValue((char *)"");
11265 }
11266 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11267 PyObject *resultobj;
11268 wxString *arg1 = 0 ;
11269 int arg2 = (int) wxEXEC_ASYNC ;
11270 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11271 long result;
11272 bool temp1 = false ;
11273 PyObject * obj0 = 0 ;
11274 PyObject * obj1 = 0 ;
11275 PyObject * obj2 = 0 ;
11276 char *kwnames[] = {
11277 (char *) "command",(char *) "flags",(char *) "process", NULL
11278 };
11279
11280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11281 {
11282 arg1 = wxString_in_helper(obj0);
11283 if (arg1 == NULL) SWIG_fail;
11284 temp1 = true;
11285 }
11286 if (obj1) {
11287 {
11288 arg2 = (int)(SWIG_As_int(obj1));
11289 if (SWIG_arg_fail(2)) SWIG_fail;
11290 }
11291 }
11292 if (obj2) {
11293 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11294 if (SWIG_arg_fail(3)) SWIG_fail;
11295 }
11296 {
11297 if (!wxPyCheckForApp()) SWIG_fail;
11298 PyThreadState* __tstate = wxPyBeginAllowThreads();
11299 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11300
11301 wxPyEndAllowThreads(__tstate);
11302 if (PyErr_Occurred()) SWIG_fail;
11303 }
11304 {
11305 resultobj = SWIG_From_long((long)(result));
11306 }
11307 {
11308 if (temp1)
11309 delete arg1;
11310 }
11311 return resultobj;
11312 fail:
11313 {
11314 if (temp1)
11315 delete arg1;
11316 }
11317 return NULL;
11318 }
11319
11320
11321 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11322 PyObject *resultobj;
11323 long arg1 ;
11324 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11325 wxKillError *arg3 = (wxKillError *) 0 ;
11326 int arg4 = (int) wxKILL_NOCHILDREN ;
11327 int result;
11328 wxKillError temp3 ;
11329 PyObject * obj0 = 0 ;
11330 PyObject * obj1 = 0 ;
11331 PyObject * obj2 = 0 ;
11332 char *kwnames[] = {
11333 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11334 };
11335
11336 {
11337 arg3 = &temp3;
11338 }
11339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11340 {
11341 arg1 = (long)(SWIG_As_long(obj0));
11342 if (SWIG_arg_fail(1)) SWIG_fail;
11343 }
11344 if (obj1) {
11345 {
11346 arg2 = (wxSignal)(SWIG_As_int(obj1));
11347 if (SWIG_arg_fail(2)) SWIG_fail;
11348 }
11349 }
11350 if (obj2) {
11351 {
11352 arg4 = (int)(SWIG_As_int(obj2));
11353 if (SWIG_arg_fail(4)) SWIG_fail;
11354 }
11355 }
11356 {
11357 PyThreadState* __tstate = wxPyBeginAllowThreads();
11358 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11359
11360 wxPyEndAllowThreads(__tstate);
11361 if (PyErr_Occurred()) SWIG_fail;
11362 }
11363 {
11364 resultobj = SWIG_From_int((int)(result));
11365 }
11366 {
11367 PyObject* o;
11368 o = PyInt_FromLong((long) (*arg3));
11369 resultobj = t_output_helper(resultobj, o);
11370 }
11371 return resultobj;
11372 fail:
11373 return NULL;
11374 }
11375
11376
11377 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11378 PyObject *resultobj;
11379 int arg1 = (int) wxJOYSTICK1 ;
11380 wxJoystick *result;
11381 PyObject * obj0 = 0 ;
11382 char *kwnames[] = {
11383 (char *) "joystick", NULL
11384 };
11385
11386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11387 if (obj0) {
11388 {
11389 arg1 = (int)(SWIG_As_int(obj0));
11390 if (SWIG_arg_fail(1)) SWIG_fail;
11391 }
11392 }
11393 {
11394 if (!wxPyCheckForApp()) SWIG_fail;
11395 PyThreadState* __tstate = wxPyBeginAllowThreads();
11396 result = (wxJoystick *)new wxJoystick(arg1);
11397
11398 wxPyEndAllowThreads(__tstate);
11399 if (PyErr_Occurred()) SWIG_fail;
11400 }
11401 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11402 return resultobj;
11403 fail:
11404 return NULL;
11405 }
11406
11407
11408 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11409 PyObject *resultobj;
11410 wxJoystick *arg1 = (wxJoystick *) 0 ;
11411 PyObject * obj0 = 0 ;
11412 char *kwnames[] = {
11413 (char *) "self", NULL
11414 };
11415
11416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11418 if (SWIG_arg_fail(1)) SWIG_fail;
11419 {
11420 PyThreadState* __tstate = wxPyBeginAllowThreads();
11421 delete arg1;
11422
11423 wxPyEndAllowThreads(__tstate);
11424 if (PyErr_Occurred()) SWIG_fail;
11425 }
11426 Py_INCREF(Py_None); resultobj = Py_None;
11427 return resultobj;
11428 fail:
11429 return NULL;
11430 }
11431
11432
11433 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11434 PyObject *resultobj;
11435 wxJoystick *arg1 = (wxJoystick *) 0 ;
11436 wxPoint result;
11437 PyObject * obj0 = 0 ;
11438 char *kwnames[] = {
11439 (char *) "self", NULL
11440 };
11441
11442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11444 if (SWIG_arg_fail(1)) SWIG_fail;
11445 {
11446 PyThreadState* __tstate = wxPyBeginAllowThreads();
11447 result = (arg1)->GetPosition();
11448
11449 wxPyEndAllowThreads(__tstate);
11450 if (PyErr_Occurred()) SWIG_fail;
11451 }
11452 {
11453 wxPoint * resultptr;
11454 resultptr = new wxPoint((wxPoint &)(result));
11455 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11456 }
11457 return resultobj;
11458 fail:
11459 return NULL;
11460 }
11461
11462
11463 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11464 PyObject *resultobj;
11465 wxJoystick *arg1 = (wxJoystick *) 0 ;
11466 int result;
11467 PyObject * obj0 = 0 ;
11468 char *kwnames[] = {
11469 (char *) "self", NULL
11470 };
11471
11472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11474 if (SWIG_arg_fail(1)) SWIG_fail;
11475 {
11476 PyThreadState* __tstate = wxPyBeginAllowThreads();
11477 result = (int)(arg1)->GetZPosition();
11478
11479 wxPyEndAllowThreads(__tstate);
11480 if (PyErr_Occurred()) SWIG_fail;
11481 }
11482 {
11483 resultobj = SWIG_From_int((int)(result));
11484 }
11485 return resultobj;
11486 fail:
11487 return NULL;
11488 }
11489
11490
11491 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11492 PyObject *resultobj;
11493 wxJoystick *arg1 = (wxJoystick *) 0 ;
11494 int result;
11495 PyObject * obj0 = 0 ;
11496 char *kwnames[] = {
11497 (char *) "self", NULL
11498 };
11499
11500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11502 if (SWIG_arg_fail(1)) SWIG_fail;
11503 {
11504 PyThreadState* __tstate = wxPyBeginAllowThreads();
11505 result = (int)(arg1)->GetButtonState();
11506
11507 wxPyEndAllowThreads(__tstate);
11508 if (PyErr_Occurred()) SWIG_fail;
11509 }
11510 {
11511 resultobj = SWIG_From_int((int)(result));
11512 }
11513 return resultobj;
11514 fail:
11515 return NULL;
11516 }
11517
11518
11519 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11520 PyObject *resultobj;
11521 wxJoystick *arg1 = (wxJoystick *) 0 ;
11522 int result;
11523 PyObject * obj0 = 0 ;
11524 char *kwnames[] = {
11525 (char *) "self", NULL
11526 };
11527
11528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11530 if (SWIG_arg_fail(1)) SWIG_fail;
11531 {
11532 PyThreadState* __tstate = wxPyBeginAllowThreads();
11533 result = (int)(arg1)->GetPOVPosition();
11534
11535 wxPyEndAllowThreads(__tstate);
11536 if (PyErr_Occurred()) SWIG_fail;
11537 }
11538 {
11539 resultobj = SWIG_From_int((int)(result));
11540 }
11541 return resultobj;
11542 fail:
11543 return NULL;
11544 }
11545
11546
11547 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11548 PyObject *resultobj;
11549 wxJoystick *arg1 = (wxJoystick *) 0 ;
11550 int result;
11551 PyObject * obj0 = 0 ;
11552 char *kwnames[] = {
11553 (char *) "self", NULL
11554 };
11555
11556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11558 if (SWIG_arg_fail(1)) SWIG_fail;
11559 {
11560 PyThreadState* __tstate = wxPyBeginAllowThreads();
11561 result = (int)(arg1)->GetPOVCTSPosition();
11562
11563 wxPyEndAllowThreads(__tstate);
11564 if (PyErr_Occurred()) SWIG_fail;
11565 }
11566 {
11567 resultobj = SWIG_From_int((int)(result));
11568 }
11569 return resultobj;
11570 fail:
11571 return NULL;
11572 }
11573
11574
11575 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11576 PyObject *resultobj;
11577 wxJoystick *arg1 = (wxJoystick *) 0 ;
11578 int result;
11579 PyObject * obj0 = 0 ;
11580 char *kwnames[] = {
11581 (char *) "self", NULL
11582 };
11583
11584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11586 if (SWIG_arg_fail(1)) SWIG_fail;
11587 {
11588 PyThreadState* __tstate = wxPyBeginAllowThreads();
11589 result = (int)(arg1)->GetRudderPosition();
11590
11591 wxPyEndAllowThreads(__tstate);
11592 if (PyErr_Occurred()) SWIG_fail;
11593 }
11594 {
11595 resultobj = SWIG_From_int((int)(result));
11596 }
11597 return resultobj;
11598 fail:
11599 return NULL;
11600 }
11601
11602
11603 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11604 PyObject *resultobj;
11605 wxJoystick *arg1 = (wxJoystick *) 0 ;
11606 int result;
11607 PyObject * obj0 = 0 ;
11608 char *kwnames[] = {
11609 (char *) "self", NULL
11610 };
11611
11612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11614 if (SWIG_arg_fail(1)) SWIG_fail;
11615 {
11616 PyThreadState* __tstate = wxPyBeginAllowThreads();
11617 result = (int)(arg1)->GetUPosition();
11618
11619 wxPyEndAllowThreads(__tstate);
11620 if (PyErr_Occurred()) SWIG_fail;
11621 }
11622 {
11623 resultobj = SWIG_From_int((int)(result));
11624 }
11625 return resultobj;
11626 fail:
11627 return NULL;
11628 }
11629
11630
11631 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11632 PyObject *resultobj;
11633 wxJoystick *arg1 = (wxJoystick *) 0 ;
11634 int result;
11635 PyObject * obj0 = 0 ;
11636 char *kwnames[] = {
11637 (char *) "self", NULL
11638 };
11639
11640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11642 if (SWIG_arg_fail(1)) SWIG_fail;
11643 {
11644 PyThreadState* __tstate = wxPyBeginAllowThreads();
11645 result = (int)(arg1)->GetVPosition();
11646
11647 wxPyEndAllowThreads(__tstate);
11648 if (PyErr_Occurred()) SWIG_fail;
11649 }
11650 {
11651 resultobj = SWIG_From_int((int)(result));
11652 }
11653 return resultobj;
11654 fail:
11655 return NULL;
11656 }
11657
11658
11659 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11660 PyObject *resultobj;
11661 wxJoystick *arg1 = (wxJoystick *) 0 ;
11662 int result;
11663 PyObject * obj0 = 0 ;
11664 char *kwnames[] = {
11665 (char *) "self", NULL
11666 };
11667
11668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11670 if (SWIG_arg_fail(1)) SWIG_fail;
11671 {
11672 PyThreadState* __tstate = wxPyBeginAllowThreads();
11673 result = (int)(arg1)->GetMovementThreshold();
11674
11675 wxPyEndAllowThreads(__tstate);
11676 if (PyErr_Occurred()) SWIG_fail;
11677 }
11678 {
11679 resultobj = SWIG_From_int((int)(result));
11680 }
11681 return resultobj;
11682 fail:
11683 return NULL;
11684 }
11685
11686
11687 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11688 PyObject *resultobj;
11689 wxJoystick *arg1 = (wxJoystick *) 0 ;
11690 int arg2 ;
11691 PyObject * obj0 = 0 ;
11692 PyObject * obj1 = 0 ;
11693 char *kwnames[] = {
11694 (char *) "self",(char *) "threshold", NULL
11695 };
11696
11697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11699 if (SWIG_arg_fail(1)) SWIG_fail;
11700 {
11701 arg2 = (int)(SWIG_As_int(obj1));
11702 if (SWIG_arg_fail(2)) SWIG_fail;
11703 }
11704 {
11705 PyThreadState* __tstate = wxPyBeginAllowThreads();
11706 (arg1)->SetMovementThreshold(arg2);
11707
11708 wxPyEndAllowThreads(__tstate);
11709 if (PyErr_Occurred()) SWIG_fail;
11710 }
11711 Py_INCREF(Py_None); resultobj = Py_None;
11712 return resultobj;
11713 fail:
11714 return NULL;
11715 }
11716
11717
11718 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11719 PyObject *resultobj;
11720 wxJoystick *arg1 = (wxJoystick *) 0 ;
11721 bool result;
11722 PyObject * obj0 = 0 ;
11723 char *kwnames[] = {
11724 (char *) "self", NULL
11725 };
11726
11727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11729 if (SWIG_arg_fail(1)) SWIG_fail;
11730 {
11731 PyThreadState* __tstate = wxPyBeginAllowThreads();
11732 result = (bool)(arg1)->IsOk();
11733
11734 wxPyEndAllowThreads(__tstate);
11735 if (PyErr_Occurred()) SWIG_fail;
11736 }
11737 {
11738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11739 }
11740 return resultobj;
11741 fail:
11742 return NULL;
11743 }
11744
11745
11746 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11747 PyObject *resultobj;
11748 wxJoystick *arg1 = (wxJoystick *) 0 ;
11749 int result;
11750 PyObject * obj0 = 0 ;
11751 char *kwnames[] = {
11752 (char *) "self", NULL
11753 };
11754
11755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11757 if (SWIG_arg_fail(1)) SWIG_fail;
11758 {
11759 PyThreadState* __tstate = wxPyBeginAllowThreads();
11760 result = (int)(arg1)->GetNumberJoysticks();
11761
11762 wxPyEndAllowThreads(__tstate);
11763 if (PyErr_Occurred()) SWIG_fail;
11764 }
11765 {
11766 resultobj = SWIG_From_int((int)(result));
11767 }
11768 return resultobj;
11769 fail:
11770 return NULL;
11771 }
11772
11773
11774 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11775 PyObject *resultobj;
11776 wxJoystick *arg1 = (wxJoystick *) 0 ;
11777 int result;
11778 PyObject * obj0 = 0 ;
11779 char *kwnames[] = {
11780 (char *) "self", NULL
11781 };
11782
11783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11785 if (SWIG_arg_fail(1)) SWIG_fail;
11786 {
11787 PyThreadState* __tstate = wxPyBeginAllowThreads();
11788 result = (int)(arg1)->GetManufacturerId();
11789
11790 wxPyEndAllowThreads(__tstate);
11791 if (PyErr_Occurred()) SWIG_fail;
11792 }
11793 {
11794 resultobj = SWIG_From_int((int)(result));
11795 }
11796 return resultobj;
11797 fail:
11798 return NULL;
11799 }
11800
11801
11802 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11803 PyObject *resultobj;
11804 wxJoystick *arg1 = (wxJoystick *) 0 ;
11805 int result;
11806 PyObject * obj0 = 0 ;
11807 char *kwnames[] = {
11808 (char *) "self", NULL
11809 };
11810
11811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11813 if (SWIG_arg_fail(1)) SWIG_fail;
11814 {
11815 PyThreadState* __tstate = wxPyBeginAllowThreads();
11816 result = (int)(arg1)->GetProductId();
11817
11818 wxPyEndAllowThreads(__tstate);
11819 if (PyErr_Occurred()) SWIG_fail;
11820 }
11821 {
11822 resultobj = SWIG_From_int((int)(result));
11823 }
11824 return resultobj;
11825 fail:
11826 return NULL;
11827 }
11828
11829
11830 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11831 PyObject *resultobj;
11832 wxJoystick *arg1 = (wxJoystick *) 0 ;
11833 wxString result;
11834 PyObject * obj0 = 0 ;
11835 char *kwnames[] = {
11836 (char *) "self", NULL
11837 };
11838
11839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11841 if (SWIG_arg_fail(1)) SWIG_fail;
11842 {
11843 PyThreadState* __tstate = wxPyBeginAllowThreads();
11844 result = (arg1)->GetProductName();
11845
11846 wxPyEndAllowThreads(__tstate);
11847 if (PyErr_Occurred()) SWIG_fail;
11848 }
11849 {
11850 #if wxUSE_UNICODE
11851 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11852 #else
11853 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11854 #endif
11855 }
11856 return resultobj;
11857 fail:
11858 return NULL;
11859 }
11860
11861
11862 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
11863 PyObject *resultobj;
11864 wxJoystick *arg1 = (wxJoystick *) 0 ;
11865 int result;
11866 PyObject * obj0 = 0 ;
11867 char *kwnames[] = {
11868 (char *) "self", NULL
11869 };
11870
11871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
11872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11873 if (SWIG_arg_fail(1)) SWIG_fail;
11874 {
11875 PyThreadState* __tstate = wxPyBeginAllowThreads();
11876 result = (int)(arg1)->GetXMin();
11877
11878 wxPyEndAllowThreads(__tstate);
11879 if (PyErr_Occurred()) SWIG_fail;
11880 }
11881 {
11882 resultobj = SWIG_From_int((int)(result));
11883 }
11884 return resultobj;
11885 fail:
11886 return NULL;
11887 }
11888
11889
11890 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
11891 PyObject *resultobj;
11892 wxJoystick *arg1 = (wxJoystick *) 0 ;
11893 int result;
11894 PyObject * obj0 = 0 ;
11895 char *kwnames[] = {
11896 (char *) "self", NULL
11897 };
11898
11899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
11900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11901 if (SWIG_arg_fail(1)) SWIG_fail;
11902 {
11903 PyThreadState* __tstate = wxPyBeginAllowThreads();
11904 result = (int)(arg1)->GetYMin();
11905
11906 wxPyEndAllowThreads(__tstate);
11907 if (PyErr_Occurred()) SWIG_fail;
11908 }
11909 {
11910 resultobj = SWIG_From_int((int)(result));
11911 }
11912 return resultobj;
11913 fail:
11914 return NULL;
11915 }
11916
11917
11918 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
11919 PyObject *resultobj;
11920 wxJoystick *arg1 = (wxJoystick *) 0 ;
11921 int result;
11922 PyObject * obj0 = 0 ;
11923 char *kwnames[] = {
11924 (char *) "self", NULL
11925 };
11926
11927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
11928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11929 if (SWIG_arg_fail(1)) SWIG_fail;
11930 {
11931 PyThreadState* __tstate = wxPyBeginAllowThreads();
11932 result = (int)(arg1)->GetZMin();
11933
11934 wxPyEndAllowThreads(__tstate);
11935 if (PyErr_Occurred()) SWIG_fail;
11936 }
11937 {
11938 resultobj = SWIG_From_int((int)(result));
11939 }
11940 return resultobj;
11941 fail:
11942 return NULL;
11943 }
11944
11945
11946 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
11947 PyObject *resultobj;
11948 wxJoystick *arg1 = (wxJoystick *) 0 ;
11949 int result;
11950 PyObject * obj0 = 0 ;
11951 char *kwnames[] = {
11952 (char *) "self", NULL
11953 };
11954
11955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
11956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11957 if (SWIG_arg_fail(1)) SWIG_fail;
11958 {
11959 PyThreadState* __tstate = wxPyBeginAllowThreads();
11960 result = (int)(arg1)->GetXMax();
11961
11962 wxPyEndAllowThreads(__tstate);
11963 if (PyErr_Occurred()) SWIG_fail;
11964 }
11965 {
11966 resultobj = SWIG_From_int((int)(result));
11967 }
11968 return resultobj;
11969 fail:
11970 return NULL;
11971 }
11972
11973
11974 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
11975 PyObject *resultobj;
11976 wxJoystick *arg1 = (wxJoystick *) 0 ;
11977 int result;
11978 PyObject * obj0 = 0 ;
11979 char *kwnames[] = {
11980 (char *) "self", NULL
11981 };
11982
11983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
11984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11985 if (SWIG_arg_fail(1)) SWIG_fail;
11986 {
11987 PyThreadState* __tstate = wxPyBeginAllowThreads();
11988 result = (int)(arg1)->GetYMax();
11989
11990 wxPyEndAllowThreads(__tstate);
11991 if (PyErr_Occurred()) SWIG_fail;
11992 }
11993 {
11994 resultobj = SWIG_From_int((int)(result));
11995 }
11996 return resultobj;
11997 fail:
11998 return NULL;
11999 }
12000
12001
12002 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12003 PyObject *resultobj;
12004 wxJoystick *arg1 = (wxJoystick *) 0 ;
12005 int result;
12006 PyObject * obj0 = 0 ;
12007 char *kwnames[] = {
12008 (char *) "self", NULL
12009 };
12010
12011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12013 if (SWIG_arg_fail(1)) SWIG_fail;
12014 {
12015 PyThreadState* __tstate = wxPyBeginAllowThreads();
12016 result = (int)(arg1)->GetZMax();
12017
12018 wxPyEndAllowThreads(__tstate);
12019 if (PyErr_Occurred()) SWIG_fail;
12020 }
12021 {
12022 resultobj = SWIG_From_int((int)(result));
12023 }
12024 return resultobj;
12025 fail:
12026 return NULL;
12027 }
12028
12029
12030 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12031 PyObject *resultobj;
12032 wxJoystick *arg1 = (wxJoystick *) 0 ;
12033 int result;
12034 PyObject * obj0 = 0 ;
12035 char *kwnames[] = {
12036 (char *) "self", NULL
12037 };
12038
12039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12041 if (SWIG_arg_fail(1)) SWIG_fail;
12042 {
12043 PyThreadState* __tstate = wxPyBeginAllowThreads();
12044 result = (int)(arg1)->GetNumberButtons();
12045
12046 wxPyEndAllowThreads(__tstate);
12047 if (PyErr_Occurred()) SWIG_fail;
12048 }
12049 {
12050 resultobj = SWIG_From_int((int)(result));
12051 }
12052 return resultobj;
12053 fail:
12054 return NULL;
12055 }
12056
12057
12058 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12059 PyObject *resultobj;
12060 wxJoystick *arg1 = (wxJoystick *) 0 ;
12061 int result;
12062 PyObject * obj0 = 0 ;
12063 char *kwnames[] = {
12064 (char *) "self", NULL
12065 };
12066
12067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12069 if (SWIG_arg_fail(1)) SWIG_fail;
12070 {
12071 PyThreadState* __tstate = wxPyBeginAllowThreads();
12072 result = (int)(arg1)->GetNumberAxes();
12073
12074 wxPyEndAllowThreads(__tstate);
12075 if (PyErr_Occurred()) SWIG_fail;
12076 }
12077 {
12078 resultobj = SWIG_From_int((int)(result));
12079 }
12080 return resultobj;
12081 fail:
12082 return NULL;
12083 }
12084
12085
12086 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12087 PyObject *resultobj;
12088 wxJoystick *arg1 = (wxJoystick *) 0 ;
12089 int result;
12090 PyObject * obj0 = 0 ;
12091 char *kwnames[] = {
12092 (char *) "self", NULL
12093 };
12094
12095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12097 if (SWIG_arg_fail(1)) SWIG_fail;
12098 {
12099 PyThreadState* __tstate = wxPyBeginAllowThreads();
12100 result = (int)(arg1)->GetMaxButtons();
12101
12102 wxPyEndAllowThreads(__tstate);
12103 if (PyErr_Occurred()) SWIG_fail;
12104 }
12105 {
12106 resultobj = SWIG_From_int((int)(result));
12107 }
12108 return resultobj;
12109 fail:
12110 return NULL;
12111 }
12112
12113
12114 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12115 PyObject *resultobj;
12116 wxJoystick *arg1 = (wxJoystick *) 0 ;
12117 int result;
12118 PyObject * obj0 = 0 ;
12119 char *kwnames[] = {
12120 (char *) "self", NULL
12121 };
12122
12123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12125 if (SWIG_arg_fail(1)) SWIG_fail;
12126 {
12127 PyThreadState* __tstate = wxPyBeginAllowThreads();
12128 result = (int)(arg1)->GetMaxAxes();
12129
12130 wxPyEndAllowThreads(__tstate);
12131 if (PyErr_Occurred()) SWIG_fail;
12132 }
12133 {
12134 resultobj = SWIG_From_int((int)(result));
12135 }
12136 return resultobj;
12137 fail:
12138 return NULL;
12139 }
12140
12141
12142 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12143 PyObject *resultobj;
12144 wxJoystick *arg1 = (wxJoystick *) 0 ;
12145 int result;
12146 PyObject * obj0 = 0 ;
12147 char *kwnames[] = {
12148 (char *) "self", NULL
12149 };
12150
12151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12153 if (SWIG_arg_fail(1)) SWIG_fail;
12154 {
12155 PyThreadState* __tstate = wxPyBeginAllowThreads();
12156 result = (int)(arg1)->GetPollingMin();
12157
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 {
12162 resultobj = SWIG_From_int((int)(result));
12163 }
12164 return resultobj;
12165 fail:
12166 return NULL;
12167 }
12168
12169
12170 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12171 PyObject *resultobj;
12172 wxJoystick *arg1 = (wxJoystick *) 0 ;
12173 int result;
12174 PyObject * obj0 = 0 ;
12175 char *kwnames[] = {
12176 (char *) "self", NULL
12177 };
12178
12179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12181 if (SWIG_arg_fail(1)) SWIG_fail;
12182 {
12183 PyThreadState* __tstate = wxPyBeginAllowThreads();
12184 result = (int)(arg1)->GetPollingMax();
12185
12186 wxPyEndAllowThreads(__tstate);
12187 if (PyErr_Occurred()) SWIG_fail;
12188 }
12189 {
12190 resultobj = SWIG_From_int((int)(result));
12191 }
12192 return resultobj;
12193 fail:
12194 return NULL;
12195 }
12196
12197
12198 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12199 PyObject *resultobj;
12200 wxJoystick *arg1 = (wxJoystick *) 0 ;
12201 int result;
12202 PyObject * obj0 = 0 ;
12203 char *kwnames[] = {
12204 (char *) "self", NULL
12205 };
12206
12207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12209 if (SWIG_arg_fail(1)) SWIG_fail;
12210 {
12211 PyThreadState* __tstate = wxPyBeginAllowThreads();
12212 result = (int)(arg1)->GetRudderMin();
12213
12214 wxPyEndAllowThreads(__tstate);
12215 if (PyErr_Occurred()) SWIG_fail;
12216 }
12217 {
12218 resultobj = SWIG_From_int((int)(result));
12219 }
12220 return resultobj;
12221 fail:
12222 return NULL;
12223 }
12224
12225
12226 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12227 PyObject *resultobj;
12228 wxJoystick *arg1 = (wxJoystick *) 0 ;
12229 int result;
12230 PyObject * obj0 = 0 ;
12231 char *kwnames[] = {
12232 (char *) "self", NULL
12233 };
12234
12235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12237 if (SWIG_arg_fail(1)) SWIG_fail;
12238 {
12239 PyThreadState* __tstate = wxPyBeginAllowThreads();
12240 result = (int)(arg1)->GetRudderMax();
12241
12242 wxPyEndAllowThreads(__tstate);
12243 if (PyErr_Occurred()) SWIG_fail;
12244 }
12245 {
12246 resultobj = SWIG_From_int((int)(result));
12247 }
12248 return resultobj;
12249 fail:
12250 return NULL;
12251 }
12252
12253
12254 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12255 PyObject *resultobj;
12256 wxJoystick *arg1 = (wxJoystick *) 0 ;
12257 int result;
12258 PyObject * obj0 = 0 ;
12259 char *kwnames[] = {
12260 (char *) "self", NULL
12261 };
12262
12263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12265 if (SWIG_arg_fail(1)) SWIG_fail;
12266 {
12267 PyThreadState* __tstate = wxPyBeginAllowThreads();
12268 result = (int)(arg1)->GetUMin();
12269
12270 wxPyEndAllowThreads(__tstate);
12271 if (PyErr_Occurred()) SWIG_fail;
12272 }
12273 {
12274 resultobj = SWIG_From_int((int)(result));
12275 }
12276 return resultobj;
12277 fail:
12278 return NULL;
12279 }
12280
12281
12282 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12283 PyObject *resultobj;
12284 wxJoystick *arg1 = (wxJoystick *) 0 ;
12285 int result;
12286 PyObject * obj0 = 0 ;
12287 char *kwnames[] = {
12288 (char *) "self", NULL
12289 };
12290
12291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12293 if (SWIG_arg_fail(1)) SWIG_fail;
12294 {
12295 PyThreadState* __tstate = wxPyBeginAllowThreads();
12296 result = (int)(arg1)->GetUMax();
12297
12298 wxPyEndAllowThreads(__tstate);
12299 if (PyErr_Occurred()) SWIG_fail;
12300 }
12301 {
12302 resultobj = SWIG_From_int((int)(result));
12303 }
12304 return resultobj;
12305 fail:
12306 return NULL;
12307 }
12308
12309
12310 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12311 PyObject *resultobj;
12312 wxJoystick *arg1 = (wxJoystick *) 0 ;
12313 int result;
12314 PyObject * obj0 = 0 ;
12315 char *kwnames[] = {
12316 (char *) "self", NULL
12317 };
12318
12319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12321 if (SWIG_arg_fail(1)) SWIG_fail;
12322 {
12323 PyThreadState* __tstate = wxPyBeginAllowThreads();
12324 result = (int)(arg1)->GetVMin();
12325
12326 wxPyEndAllowThreads(__tstate);
12327 if (PyErr_Occurred()) SWIG_fail;
12328 }
12329 {
12330 resultobj = SWIG_From_int((int)(result));
12331 }
12332 return resultobj;
12333 fail:
12334 return NULL;
12335 }
12336
12337
12338 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12339 PyObject *resultobj;
12340 wxJoystick *arg1 = (wxJoystick *) 0 ;
12341 int result;
12342 PyObject * obj0 = 0 ;
12343 char *kwnames[] = {
12344 (char *) "self", NULL
12345 };
12346
12347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12349 if (SWIG_arg_fail(1)) SWIG_fail;
12350 {
12351 PyThreadState* __tstate = wxPyBeginAllowThreads();
12352 result = (int)(arg1)->GetVMax();
12353
12354 wxPyEndAllowThreads(__tstate);
12355 if (PyErr_Occurred()) SWIG_fail;
12356 }
12357 {
12358 resultobj = SWIG_From_int((int)(result));
12359 }
12360 return resultobj;
12361 fail:
12362 return NULL;
12363 }
12364
12365
12366 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12367 PyObject *resultobj;
12368 wxJoystick *arg1 = (wxJoystick *) 0 ;
12369 bool result;
12370 PyObject * obj0 = 0 ;
12371 char *kwnames[] = {
12372 (char *) "self", NULL
12373 };
12374
12375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12377 if (SWIG_arg_fail(1)) SWIG_fail;
12378 {
12379 PyThreadState* __tstate = wxPyBeginAllowThreads();
12380 result = (bool)(arg1)->HasRudder();
12381
12382 wxPyEndAllowThreads(__tstate);
12383 if (PyErr_Occurred()) SWIG_fail;
12384 }
12385 {
12386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12387 }
12388 return resultobj;
12389 fail:
12390 return NULL;
12391 }
12392
12393
12394 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12395 PyObject *resultobj;
12396 wxJoystick *arg1 = (wxJoystick *) 0 ;
12397 bool result;
12398 PyObject * obj0 = 0 ;
12399 char *kwnames[] = {
12400 (char *) "self", NULL
12401 };
12402
12403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12405 if (SWIG_arg_fail(1)) SWIG_fail;
12406 {
12407 PyThreadState* __tstate = wxPyBeginAllowThreads();
12408 result = (bool)(arg1)->HasZ();
12409
12410 wxPyEndAllowThreads(__tstate);
12411 if (PyErr_Occurred()) SWIG_fail;
12412 }
12413 {
12414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12415 }
12416 return resultobj;
12417 fail:
12418 return NULL;
12419 }
12420
12421
12422 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12423 PyObject *resultobj;
12424 wxJoystick *arg1 = (wxJoystick *) 0 ;
12425 bool result;
12426 PyObject * obj0 = 0 ;
12427 char *kwnames[] = {
12428 (char *) "self", NULL
12429 };
12430
12431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12433 if (SWIG_arg_fail(1)) SWIG_fail;
12434 {
12435 PyThreadState* __tstate = wxPyBeginAllowThreads();
12436 result = (bool)(arg1)->HasU();
12437
12438 wxPyEndAllowThreads(__tstate);
12439 if (PyErr_Occurred()) SWIG_fail;
12440 }
12441 {
12442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12443 }
12444 return resultobj;
12445 fail:
12446 return NULL;
12447 }
12448
12449
12450 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12451 PyObject *resultobj;
12452 wxJoystick *arg1 = (wxJoystick *) 0 ;
12453 bool result;
12454 PyObject * obj0 = 0 ;
12455 char *kwnames[] = {
12456 (char *) "self", NULL
12457 };
12458
12459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12461 if (SWIG_arg_fail(1)) SWIG_fail;
12462 {
12463 PyThreadState* __tstate = wxPyBeginAllowThreads();
12464 result = (bool)(arg1)->HasV();
12465
12466 wxPyEndAllowThreads(__tstate);
12467 if (PyErr_Occurred()) SWIG_fail;
12468 }
12469 {
12470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12471 }
12472 return resultobj;
12473 fail:
12474 return NULL;
12475 }
12476
12477
12478 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12479 PyObject *resultobj;
12480 wxJoystick *arg1 = (wxJoystick *) 0 ;
12481 bool result;
12482 PyObject * obj0 = 0 ;
12483 char *kwnames[] = {
12484 (char *) "self", NULL
12485 };
12486
12487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12489 if (SWIG_arg_fail(1)) SWIG_fail;
12490 {
12491 PyThreadState* __tstate = wxPyBeginAllowThreads();
12492 result = (bool)(arg1)->HasPOV();
12493
12494 wxPyEndAllowThreads(__tstate);
12495 if (PyErr_Occurred()) SWIG_fail;
12496 }
12497 {
12498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12499 }
12500 return resultobj;
12501 fail:
12502 return NULL;
12503 }
12504
12505
12506 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12507 PyObject *resultobj;
12508 wxJoystick *arg1 = (wxJoystick *) 0 ;
12509 bool result;
12510 PyObject * obj0 = 0 ;
12511 char *kwnames[] = {
12512 (char *) "self", NULL
12513 };
12514
12515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12517 if (SWIG_arg_fail(1)) SWIG_fail;
12518 {
12519 PyThreadState* __tstate = wxPyBeginAllowThreads();
12520 result = (bool)(arg1)->HasPOV4Dir();
12521
12522 wxPyEndAllowThreads(__tstate);
12523 if (PyErr_Occurred()) SWIG_fail;
12524 }
12525 {
12526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12527 }
12528 return resultobj;
12529 fail:
12530 return NULL;
12531 }
12532
12533
12534 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12535 PyObject *resultobj;
12536 wxJoystick *arg1 = (wxJoystick *) 0 ;
12537 bool result;
12538 PyObject * obj0 = 0 ;
12539 char *kwnames[] = {
12540 (char *) "self", NULL
12541 };
12542
12543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12545 if (SWIG_arg_fail(1)) SWIG_fail;
12546 {
12547 PyThreadState* __tstate = wxPyBeginAllowThreads();
12548 result = (bool)(arg1)->HasPOVCTS();
12549
12550 wxPyEndAllowThreads(__tstate);
12551 if (PyErr_Occurred()) SWIG_fail;
12552 }
12553 {
12554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12555 }
12556 return resultobj;
12557 fail:
12558 return NULL;
12559 }
12560
12561
12562 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12563 PyObject *resultobj;
12564 wxJoystick *arg1 = (wxJoystick *) 0 ;
12565 wxWindow *arg2 = (wxWindow *) 0 ;
12566 int arg3 = (int) 0 ;
12567 bool result;
12568 PyObject * obj0 = 0 ;
12569 PyObject * obj1 = 0 ;
12570 PyObject * obj2 = 0 ;
12571 char *kwnames[] = {
12572 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12573 };
12574
12575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12577 if (SWIG_arg_fail(1)) SWIG_fail;
12578 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12579 if (SWIG_arg_fail(2)) SWIG_fail;
12580 if (obj2) {
12581 {
12582 arg3 = (int)(SWIG_As_int(obj2));
12583 if (SWIG_arg_fail(3)) SWIG_fail;
12584 }
12585 }
12586 {
12587 PyThreadState* __tstate = wxPyBeginAllowThreads();
12588 result = (bool)(arg1)->SetCapture(arg2,arg3);
12589
12590 wxPyEndAllowThreads(__tstate);
12591 if (PyErr_Occurred()) SWIG_fail;
12592 }
12593 {
12594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12595 }
12596 return resultobj;
12597 fail:
12598 return NULL;
12599 }
12600
12601
12602 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12603 PyObject *resultobj;
12604 wxJoystick *arg1 = (wxJoystick *) 0 ;
12605 bool result;
12606 PyObject * obj0 = 0 ;
12607 char *kwnames[] = {
12608 (char *) "self", NULL
12609 };
12610
12611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12613 if (SWIG_arg_fail(1)) SWIG_fail;
12614 {
12615 PyThreadState* __tstate = wxPyBeginAllowThreads();
12616 result = (bool)(arg1)->ReleaseCapture();
12617
12618 wxPyEndAllowThreads(__tstate);
12619 if (PyErr_Occurred()) SWIG_fail;
12620 }
12621 {
12622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12623 }
12624 return resultobj;
12625 fail:
12626 return NULL;
12627 }
12628
12629
12630 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12631 PyObject *obj;
12632 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12633 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12634 Py_INCREF(obj);
12635 return Py_BuildValue((char *)"");
12636 }
12637 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12638 PyObject *resultobj;
12639 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12640 int arg2 = (int) 0 ;
12641 int arg3 = (int) wxJOYSTICK1 ;
12642 int arg4 = (int) 0 ;
12643 wxJoystickEvent *result;
12644 PyObject * obj0 = 0 ;
12645 PyObject * obj1 = 0 ;
12646 PyObject * obj2 = 0 ;
12647 PyObject * obj3 = 0 ;
12648 char *kwnames[] = {
12649 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12650 };
12651
12652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12653 if (obj0) {
12654 {
12655 arg1 = (wxEventType)(SWIG_As_int(obj0));
12656 if (SWIG_arg_fail(1)) SWIG_fail;
12657 }
12658 }
12659 if (obj1) {
12660 {
12661 arg2 = (int)(SWIG_As_int(obj1));
12662 if (SWIG_arg_fail(2)) SWIG_fail;
12663 }
12664 }
12665 if (obj2) {
12666 {
12667 arg3 = (int)(SWIG_As_int(obj2));
12668 if (SWIG_arg_fail(3)) SWIG_fail;
12669 }
12670 }
12671 if (obj3) {
12672 {
12673 arg4 = (int)(SWIG_As_int(obj3));
12674 if (SWIG_arg_fail(4)) SWIG_fail;
12675 }
12676 }
12677 {
12678 PyThreadState* __tstate = wxPyBeginAllowThreads();
12679 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12680
12681 wxPyEndAllowThreads(__tstate);
12682 if (PyErr_Occurred()) SWIG_fail;
12683 }
12684 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12685 return resultobj;
12686 fail:
12687 return NULL;
12688 }
12689
12690
12691 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12692 PyObject *resultobj;
12693 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12694 wxPoint result;
12695 PyObject * obj0 = 0 ;
12696 char *kwnames[] = {
12697 (char *) "self", NULL
12698 };
12699
12700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12702 if (SWIG_arg_fail(1)) SWIG_fail;
12703 {
12704 PyThreadState* __tstate = wxPyBeginAllowThreads();
12705 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12706
12707 wxPyEndAllowThreads(__tstate);
12708 if (PyErr_Occurred()) SWIG_fail;
12709 }
12710 {
12711 wxPoint * resultptr;
12712 resultptr = new wxPoint((wxPoint &)(result));
12713 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12714 }
12715 return resultobj;
12716 fail:
12717 return NULL;
12718 }
12719
12720
12721 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12722 PyObject *resultobj;
12723 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12724 int result;
12725 PyObject * obj0 = 0 ;
12726 char *kwnames[] = {
12727 (char *) "self", NULL
12728 };
12729
12730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12732 if (SWIG_arg_fail(1)) SWIG_fail;
12733 {
12734 PyThreadState* __tstate = wxPyBeginAllowThreads();
12735 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12736
12737 wxPyEndAllowThreads(__tstate);
12738 if (PyErr_Occurred()) SWIG_fail;
12739 }
12740 {
12741 resultobj = SWIG_From_int((int)(result));
12742 }
12743 return resultobj;
12744 fail:
12745 return NULL;
12746 }
12747
12748
12749 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12750 PyObject *resultobj;
12751 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12752 int result;
12753 PyObject * obj0 = 0 ;
12754 char *kwnames[] = {
12755 (char *) "self", NULL
12756 };
12757
12758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12760 if (SWIG_arg_fail(1)) SWIG_fail;
12761 {
12762 PyThreadState* __tstate = wxPyBeginAllowThreads();
12763 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12764
12765 wxPyEndAllowThreads(__tstate);
12766 if (PyErr_Occurred()) SWIG_fail;
12767 }
12768 {
12769 resultobj = SWIG_From_int((int)(result));
12770 }
12771 return resultobj;
12772 fail:
12773 return NULL;
12774 }
12775
12776
12777 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12778 PyObject *resultobj;
12779 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12780 int result;
12781 PyObject * obj0 = 0 ;
12782 char *kwnames[] = {
12783 (char *) "self", NULL
12784 };
12785
12786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12788 if (SWIG_arg_fail(1)) SWIG_fail;
12789 {
12790 PyThreadState* __tstate = wxPyBeginAllowThreads();
12791 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12792
12793 wxPyEndAllowThreads(__tstate);
12794 if (PyErr_Occurred()) SWIG_fail;
12795 }
12796 {
12797 resultobj = SWIG_From_int((int)(result));
12798 }
12799 return resultobj;
12800 fail:
12801 return NULL;
12802 }
12803
12804
12805 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12806 PyObject *resultobj;
12807 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12808 int result;
12809 PyObject * obj0 = 0 ;
12810 char *kwnames[] = {
12811 (char *) "self", NULL
12812 };
12813
12814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12816 if (SWIG_arg_fail(1)) SWIG_fail;
12817 {
12818 PyThreadState* __tstate = wxPyBeginAllowThreads();
12819 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12820
12821 wxPyEndAllowThreads(__tstate);
12822 if (PyErr_Occurred()) SWIG_fail;
12823 }
12824 {
12825 resultobj = SWIG_From_int((int)(result));
12826 }
12827 return resultobj;
12828 fail:
12829 return NULL;
12830 }
12831
12832
12833 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12834 PyObject *resultobj;
12835 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12836 int arg2 ;
12837 PyObject * obj0 = 0 ;
12838 PyObject * obj1 = 0 ;
12839 char *kwnames[] = {
12840 (char *) "self",(char *) "stick", NULL
12841 };
12842
12843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12845 if (SWIG_arg_fail(1)) SWIG_fail;
12846 {
12847 arg2 = (int)(SWIG_As_int(obj1));
12848 if (SWIG_arg_fail(2)) SWIG_fail;
12849 }
12850 {
12851 PyThreadState* __tstate = wxPyBeginAllowThreads();
12852 (arg1)->SetJoystick(arg2);
12853
12854 wxPyEndAllowThreads(__tstate);
12855 if (PyErr_Occurred()) SWIG_fail;
12856 }
12857 Py_INCREF(Py_None); resultobj = Py_None;
12858 return resultobj;
12859 fail:
12860 return NULL;
12861 }
12862
12863
12864 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12865 PyObject *resultobj;
12866 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12867 int arg2 ;
12868 PyObject * obj0 = 0 ;
12869 PyObject * obj1 = 0 ;
12870 char *kwnames[] = {
12871 (char *) "self",(char *) "state", NULL
12872 };
12873
12874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
12875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12876 if (SWIG_arg_fail(1)) SWIG_fail;
12877 {
12878 arg2 = (int)(SWIG_As_int(obj1));
12879 if (SWIG_arg_fail(2)) SWIG_fail;
12880 }
12881 {
12882 PyThreadState* __tstate = wxPyBeginAllowThreads();
12883 (arg1)->SetButtonState(arg2);
12884
12885 wxPyEndAllowThreads(__tstate);
12886 if (PyErr_Occurred()) SWIG_fail;
12887 }
12888 Py_INCREF(Py_None); resultobj = Py_None;
12889 return resultobj;
12890 fail:
12891 return NULL;
12892 }
12893
12894
12895 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12896 PyObject *resultobj;
12897 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12898 int arg2 ;
12899 PyObject * obj0 = 0 ;
12900 PyObject * obj1 = 0 ;
12901 char *kwnames[] = {
12902 (char *) "self",(char *) "change", NULL
12903 };
12904
12905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
12906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12907 if (SWIG_arg_fail(1)) SWIG_fail;
12908 {
12909 arg2 = (int)(SWIG_As_int(obj1));
12910 if (SWIG_arg_fail(2)) SWIG_fail;
12911 }
12912 {
12913 PyThreadState* __tstate = wxPyBeginAllowThreads();
12914 (arg1)->SetButtonChange(arg2);
12915
12916 wxPyEndAllowThreads(__tstate);
12917 if (PyErr_Occurred()) SWIG_fail;
12918 }
12919 Py_INCREF(Py_None); resultobj = Py_None;
12920 return resultobj;
12921 fail:
12922 return NULL;
12923 }
12924
12925
12926 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12927 PyObject *resultobj;
12928 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12929 wxPoint *arg2 = 0 ;
12930 wxPoint temp2 ;
12931 PyObject * obj0 = 0 ;
12932 PyObject * obj1 = 0 ;
12933 char *kwnames[] = {
12934 (char *) "self",(char *) "pos", NULL
12935 };
12936
12937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
12938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12939 if (SWIG_arg_fail(1)) SWIG_fail;
12940 {
12941 arg2 = &temp2;
12942 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
12943 }
12944 {
12945 PyThreadState* __tstate = wxPyBeginAllowThreads();
12946 (arg1)->SetPosition((wxPoint const &)*arg2);
12947
12948 wxPyEndAllowThreads(__tstate);
12949 if (PyErr_Occurred()) SWIG_fail;
12950 }
12951 Py_INCREF(Py_None); resultobj = Py_None;
12952 return resultobj;
12953 fail:
12954 return NULL;
12955 }
12956
12957
12958 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12959 PyObject *resultobj;
12960 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12961 int arg2 ;
12962 PyObject * obj0 = 0 ;
12963 PyObject * obj1 = 0 ;
12964 char *kwnames[] = {
12965 (char *) "self",(char *) "zPos", NULL
12966 };
12967
12968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
12969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12970 if (SWIG_arg_fail(1)) SWIG_fail;
12971 {
12972 arg2 = (int)(SWIG_As_int(obj1));
12973 if (SWIG_arg_fail(2)) SWIG_fail;
12974 }
12975 {
12976 PyThreadState* __tstate = wxPyBeginAllowThreads();
12977 (arg1)->SetZPosition(arg2);
12978
12979 wxPyEndAllowThreads(__tstate);
12980 if (PyErr_Occurred()) SWIG_fail;
12981 }
12982 Py_INCREF(Py_None); resultobj = Py_None;
12983 return resultobj;
12984 fail:
12985 return NULL;
12986 }
12987
12988
12989 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
12990 PyObject *resultobj;
12991 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12992 bool result;
12993 PyObject * obj0 = 0 ;
12994 char *kwnames[] = {
12995 (char *) "self", NULL
12996 };
12997
12998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
12999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13000 if (SWIG_arg_fail(1)) SWIG_fail;
13001 {
13002 PyThreadState* __tstate = wxPyBeginAllowThreads();
13003 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13004
13005 wxPyEndAllowThreads(__tstate);
13006 if (PyErr_Occurred()) SWIG_fail;
13007 }
13008 {
13009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13010 }
13011 return resultobj;
13012 fail:
13013 return NULL;
13014 }
13015
13016
13017 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13018 PyObject *resultobj;
13019 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13020 bool result;
13021 PyObject * obj0 = 0 ;
13022 char *kwnames[] = {
13023 (char *) "self", NULL
13024 };
13025
13026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13028 if (SWIG_arg_fail(1)) SWIG_fail;
13029 {
13030 PyThreadState* __tstate = wxPyBeginAllowThreads();
13031 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13032
13033 wxPyEndAllowThreads(__tstate);
13034 if (PyErr_Occurred()) SWIG_fail;
13035 }
13036 {
13037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13038 }
13039 return resultobj;
13040 fail:
13041 return NULL;
13042 }
13043
13044
13045 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13046 PyObject *resultobj;
13047 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13048 bool result;
13049 PyObject * obj0 = 0 ;
13050 char *kwnames[] = {
13051 (char *) "self", NULL
13052 };
13053
13054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13056 if (SWIG_arg_fail(1)) SWIG_fail;
13057 {
13058 PyThreadState* __tstate = wxPyBeginAllowThreads();
13059 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13060
13061 wxPyEndAllowThreads(__tstate);
13062 if (PyErr_Occurred()) SWIG_fail;
13063 }
13064 {
13065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13066 }
13067 return resultobj;
13068 fail:
13069 return NULL;
13070 }
13071
13072
13073 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13074 PyObject *resultobj;
13075 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13076 int arg2 = (int) wxJOY_BUTTON_ANY ;
13077 bool result;
13078 PyObject * obj0 = 0 ;
13079 PyObject * obj1 = 0 ;
13080 char *kwnames[] = {
13081 (char *) "self",(char *) "but", NULL
13082 };
13083
13084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13086 if (SWIG_arg_fail(1)) SWIG_fail;
13087 if (obj1) {
13088 {
13089 arg2 = (int)(SWIG_As_int(obj1));
13090 if (SWIG_arg_fail(2)) SWIG_fail;
13091 }
13092 }
13093 {
13094 PyThreadState* __tstate = wxPyBeginAllowThreads();
13095 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13096
13097 wxPyEndAllowThreads(__tstate);
13098 if (PyErr_Occurred()) SWIG_fail;
13099 }
13100 {
13101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13102 }
13103 return resultobj;
13104 fail:
13105 return NULL;
13106 }
13107
13108
13109 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13110 PyObject *resultobj;
13111 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13112 int arg2 = (int) wxJOY_BUTTON_ANY ;
13113 bool result;
13114 PyObject * obj0 = 0 ;
13115 PyObject * obj1 = 0 ;
13116 char *kwnames[] = {
13117 (char *) "self",(char *) "but", NULL
13118 };
13119
13120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13122 if (SWIG_arg_fail(1)) SWIG_fail;
13123 if (obj1) {
13124 {
13125 arg2 = (int)(SWIG_As_int(obj1));
13126 if (SWIG_arg_fail(2)) SWIG_fail;
13127 }
13128 }
13129 {
13130 PyThreadState* __tstate = wxPyBeginAllowThreads();
13131 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13132
13133 wxPyEndAllowThreads(__tstate);
13134 if (PyErr_Occurred()) SWIG_fail;
13135 }
13136 {
13137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13138 }
13139 return resultobj;
13140 fail:
13141 return NULL;
13142 }
13143
13144
13145 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13146 PyObject *resultobj;
13147 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13148 int arg2 = (int) wxJOY_BUTTON_ANY ;
13149 bool result;
13150 PyObject * obj0 = 0 ;
13151 PyObject * obj1 = 0 ;
13152 char *kwnames[] = {
13153 (char *) "self",(char *) "but", NULL
13154 };
13155
13156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13158 if (SWIG_arg_fail(1)) SWIG_fail;
13159 if (obj1) {
13160 {
13161 arg2 = (int)(SWIG_As_int(obj1));
13162 if (SWIG_arg_fail(2)) SWIG_fail;
13163 }
13164 }
13165 {
13166 PyThreadState* __tstate = wxPyBeginAllowThreads();
13167 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13168
13169 wxPyEndAllowThreads(__tstate);
13170 if (PyErr_Occurred()) SWIG_fail;
13171 }
13172 {
13173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13174 }
13175 return resultobj;
13176 fail:
13177 return NULL;
13178 }
13179
13180
13181 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13182 PyObject *obj;
13183 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13184 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13185 Py_INCREF(obj);
13186 return Py_BuildValue((char *)"");
13187 }
13188 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13189 PyObject *resultobj;
13190 wxString const &arg1_defvalue = wxPyEmptyString ;
13191 wxString *arg1 = (wxString *) &arg1_defvalue ;
13192 wxSound *result;
13193 bool temp1 = false ;
13194 PyObject * obj0 = 0 ;
13195 char *kwnames[] = {
13196 (char *) "fileName", NULL
13197 };
13198
13199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13200 if (obj0) {
13201 {
13202 arg1 = wxString_in_helper(obj0);
13203 if (arg1 == NULL) SWIG_fail;
13204 temp1 = true;
13205 }
13206 }
13207 {
13208 if (!wxPyCheckForApp()) SWIG_fail;
13209 PyThreadState* __tstate = wxPyBeginAllowThreads();
13210 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13211
13212 wxPyEndAllowThreads(__tstate);
13213 if (PyErr_Occurred()) SWIG_fail;
13214 }
13215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13216 {
13217 if (temp1)
13218 delete arg1;
13219 }
13220 return resultobj;
13221 fail:
13222 {
13223 if (temp1)
13224 delete arg1;
13225 }
13226 return NULL;
13227 }
13228
13229
13230 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13231 PyObject *resultobj;
13232 PyObject *arg1 = (PyObject *) 0 ;
13233 wxSound *result;
13234 PyObject * obj0 = 0 ;
13235 char *kwnames[] = {
13236 (char *) "data", NULL
13237 };
13238
13239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13240 arg1 = obj0;
13241 {
13242 if (!wxPyCheckForApp()) SWIG_fail;
13243 PyThreadState* __tstate = wxPyBeginAllowThreads();
13244 result = (wxSound *)new_wxSound(arg1);
13245
13246 wxPyEndAllowThreads(__tstate);
13247 if (PyErr_Occurred()) SWIG_fail;
13248 }
13249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13250 return resultobj;
13251 fail:
13252 return NULL;
13253 }
13254
13255
13256 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13257 PyObject *resultobj;
13258 wxSound *arg1 = (wxSound *) 0 ;
13259 PyObject * obj0 = 0 ;
13260 char *kwnames[] = {
13261 (char *) "self", NULL
13262 };
13263
13264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13266 if (SWIG_arg_fail(1)) SWIG_fail;
13267 {
13268 PyThreadState* __tstate = wxPyBeginAllowThreads();
13269 delete arg1;
13270
13271 wxPyEndAllowThreads(__tstate);
13272 if (PyErr_Occurred()) SWIG_fail;
13273 }
13274 Py_INCREF(Py_None); resultobj = Py_None;
13275 return resultobj;
13276 fail:
13277 return NULL;
13278 }
13279
13280
13281 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13282 PyObject *resultobj;
13283 wxSound *arg1 = (wxSound *) 0 ;
13284 wxString *arg2 = 0 ;
13285 bool result;
13286 bool temp2 = false ;
13287 PyObject * obj0 = 0 ;
13288 PyObject * obj1 = 0 ;
13289 char *kwnames[] = {
13290 (char *) "self",(char *) "fileName", NULL
13291 };
13292
13293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13295 if (SWIG_arg_fail(1)) SWIG_fail;
13296 {
13297 arg2 = wxString_in_helper(obj1);
13298 if (arg2 == NULL) SWIG_fail;
13299 temp2 = true;
13300 }
13301 {
13302 PyThreadState* __tstate = wxPyBeginAllowThreads();
13303 result = (bool)(arg1)->Create((wxString const &)*arg2);
13304
13305 wxPyEndAllowThreads(__tstate);
13306 if (PyErr_Occurred()) SWIG_fail;
13307 }
13308 {
13309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13310 }
13311 {
13312 if (temp2)
13313 delete arg2;
13314 }
13315 return resultobj;
13316 fail:
13317 {
13318 if (temp2)
13319 delete arg2;
13320 }
13321 return NULL;
13322 }
13323
13324
13325 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13326 PyObject *resultobj;
13327 wxSound *arg1 = (wxSound *) 0 ;
13328 PyObject *arg2 = (PyObject *) 0 ;
13329 bool result;
13330 PyObject * obj0 = 0 ;
13331 PyObject * obj1 = 0 ;
13332 char *kwnames[] = {
13333 (char *) "self",(char *) "data", NULL
13334 };
13335
13336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13338 if (SWIG_arg_fail(1)) SWIG_fail;
13339 arg2 = obj1;
13340 {
13341 PyThreadState* __tstate = wxPyBeginAllowThreads();
13342 result = (bool)wxSound_CreateFromData(arg1,arg2);
13343
13344 wxPyEndAllowThreads(__tstate);
13345 if (PyErr_Occurred()) SWIG_fail;
13346 }
13347 {
13348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13349 }
13350 return resultobj;
13351 fail:
13352 return NULL;
13353 }
13354
13355
13356 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13357 PyObject *resultobj;
13358 wxSound *arg1 = (wxSound *) 0 ;
13359 bool result;
13360 PyObject * obj0 = 0 ;
13361 char *kwnames[] = {
13362 (char *) "self", NULL
13363 };
13364
13365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13367 if (SWIG_arg_fail(1)) SWIG_fail;
13368 {
13369 PyThreadState* __tstate = wxPyBeginAllowThreads();
13370 result = (bool)(arg1)->IsOk();
13371
13372 wxPyEndAllowThreads(__tstate);
13373 if (PyErr_Occurred()) SWIG_fail;
13374 }
13375 {
13376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13377 }
13378 return resultobj;
13379 fail:
13380 return NULL;
13381 }
13382
13383
13384 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13385 PyObject *resultobj;
13386 wxSound *arg1 = (wxSound *) 0 ;
13387 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13388 bool result;
13389 PyObject * obj0 = 0 ;
13390 PyObject * obj1 = 0 ;
13391 char *kwnames[] = {
13392 (char *) "self",(char *) "flags", NULL
13393 };
13394
13395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13397 if (SWIG_arg_fail(1)) SWIG_fail;
13398 if (obj1) {
13399 {
13400 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13401 if (SWIG_arg_fail(2)) SWIG_fail;
13402 }
13403 }
13404 {
13405 if (!wxPyCheckForApp()) SWIG_fail;
13406 PyThreadState* __tstate = wxPyBeginAllowThreads();
13407 result = (bool)((wxSound const *)arg1)->Play(arg2);
13408
13409 wxPyEndAllowThreads(__tstate);
13410 if (PyErr_Occurred()) SWIG_fail;
13411 }
13412 {
13413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13414 }
13415 return resultobj;
13416 fail:
13417 return NULL;
13418 }
13419
13420
13421 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13422 PyObject *resultobj;
13423 wxString *arg1 = 0 ;
13424 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13425 bool result;
13426 bool temp1 = false ;
13427 PyObject * obj0 = 0 ;
13428 PyObject * obj1 = 0 ;
13429 char *kwnames[] = {
13430 (char *) "filename",(char *) "flags", NULL
13431 };
13432
13433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13434 {
13435 arg1 = wxString_in_helper(obj0);
13436 if (arg1 == NULL) SWIG_fail;
13437 temp1 = true;
13438 }
13439 if (obj1) {
13440 {
13441 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13442 if (SWIG_arg_fail(2)) SWIG_fail;
13443 }
13444 }
13445 {
13446 if (!wxPyCheckForApp()) SWIG_fail;
13447 PyThreadState* __tstate = wxPyBeginAllowThreads();
13448 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13449
13450 wxPyEndAllowThreads(__tstate);
13451 if (PyErr_Occurred()) SWIG_fail;
13452 }
13453 {
13454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13455 }
13456 {
13457 if (temp1)
13458 delete arg1;
13459 }
13460 return resultobj;
13461 fail:
13462 {
13463 if (temp1)
13464 delete arg1;
13465 }
13466 return NULL;
13467 }
13468
13469
13470 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13471 PyObject *resultobj;
13472 char *kwnames[] = {
13473 NULL
13474 };
13475
13476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13477 {
13478 if (!wxPyCheckForApp()) SWIG_fail;
13479 PyThreadState* __tstate = wxPyBeginAllowThreads();
13480 wxSound::Stop();
13481
13482 wxPyEndAllowThreads(__tstate);
13483 if (PyErr_Occurred()) SWIG_fail;
13484 }
13485 Py_INCREF(Py_None); resultobj = Py_None;
13486 return resultobj;
13487 fail:
13488 return NULL;
13489 }
13490
13491
13492 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13493 PyObject *obj;
13494 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13495 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13496 Py_INCREF(obj);
13497 return Py_BuildValue((char *)"");
13498 }
13499 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13500 PyObject *resultobj;
13501 wxString *arg1 = 0 ;
13502 wxString *arg2 = 0 ;
13503 wxString *arg3 = 0 ;
13504 wxString *arg4 = 0 ;
13505 wxFileTypeInfo *result;
13506 bool temp1 = false ;
13507 bool temp2 = false ;
13508 bool temp3 = false ;
13509 bool temp4 = false ;
13510 PyObject * obj0 = 0 ;
13511 PyObject * obj1 = 0 ;
13512 PyObject * obj2 = 0 ;
13513 PyObject * obj3 = 0 ;
13514 char *kwnames[] = {
13515 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13516 };
13517
13518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13519 {
13520 arg1 = wxString_in_helper(obj0);
13521 if (arg1 == NULL) SWIG_fail;
13522 temp1 = true;
13523 }
13524 {
13525 arg2 = wxString_in_helper(obj1);
13526 if (arg2 == NULL) SWIG_fail;
13527 temp2 = true;
13528 }
13529 {
13530 arg3 = wxString_in_helper(obj2);
13531 if (arg3 == NULL) SWIG_fail;
13532 temp3 = true;
13533 }
13534 {
13535 arg4 = wxString_in_helper(obj3);
13536 if (arg4 == NULL) SWIG_fail;
13537 temp4 = true;
13538 }
13539 {
13540 PyThreadState* __tstate = wxPyBeginAllowThreads();
13541 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13542
13543 wxPyEndAllowThreads(__tstate);
13544 if (PyErr_Occurred()) SWIG_fail;
13545 }
13546 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13547 {
13548 if (temp1)
13549 delete arg1;
13550 }
13551 {
13552 if (temp2)
13553 delete arg2;
13554 }
13555 {
13556 if (temp3)
13557 delete arg3;
13558 }
13559 {
13560 if (temp4)
13561 delete arg4;
13562 }
13563 return resultobj;
13564 fail:
13565 {
13566 if (temp1)
13567 delete arg1;
13568 }
13569 {
13570 if (temp2)
13571 delete arg2;
13572 }
13573 {
13574 if (temp3)
13575 delete arg3;
13576 }
13577 {
13578 if (temp4)
13579 delete arg4;
13580 }
13581 return NULL;
13582 }
13583
13584
13585 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13586 PyObject *resultobj;
13587 wxArrayString *arg1 = 0 ;
13588 wxFileTypeInfo *result;
13589 bool temp1 = false ;
13590 PyObject * obj0 = 0 ;
13591 char *kwnames[] = {
13592 (char *) "sArray", NULL
13593 };
13594
13595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13596 {
13597 if (! PySequence_Check(obj0)) {
13598 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13599 SWIG_fail;
13600 }
13601 arg1 = new wxArrayString;
13602 temp1 = true;
13603 int i, len=PySequence_Length(obj0);
13604 for (i=0; i<len; i++) {
13605 PyObject* item = PySequence_GetItem(obj0, i);
13606 #if wxUSE_UNICODE
13607 PyObject* str = PyObject_Unicode(item);
13608 #else
13609 PyObject* str = PyObject_Str(item);
13610 #endif
13611 if (PyErr_Occurred()) SWIG_fail;
13612 arg1->Add(Py2wxString(str));
13613 Py_DECREF(item);
13614 Py_DECREF(str);
13615 }
13616 }
13617 {
13618 PyThreadState* __tstate = wxPyBeginAllowThreads();
13619 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13620
13621 wxPyEndAllowThreads(__tstate);
13622 if (PyErr_Occurred()) SWIG_fail;
13623 }
13624 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13625 {
13626 if (temp1) delete arg1;
13627 }
13628 return resultobj;
13629 fail:
13630 {
13631 if (temp1) delete arg1;
13632 }
13633 return NULL;
13634 }
13635
13636
13637 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13638 PyObject *resultobj;
13639 wxFileTypeInfo *result;
13640 char *kwnames[] = {
13641 NULL
13642 };
13643
13644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13645 {
13646 PyThreadState* __tstate = wxPyBeginAllowThreads();
13647 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13648
13649 wxPyEndAllowThreads(__tstate);
13650 if (PyErr_Occurred()) SWIG_fail;
13651 }
13652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13653 return resultobj;
13654 fail:
13655 return NULL;
13656 }
13657
13658
13659 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13660 PyObject *resultobj;
13661 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13662 bool result;
13663 PyObject * obj0 = 0 ;
13664 char *kwnames[] = {
13665 (char *) "self", NULL
13666 };
13667
13668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13670 if (SWIG_arg_fail(1)) SWIG_fail;
13671 {
13672 PyThreadState* __tstate = wxPyBeginAllowThreads();
13673 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13674
13675 wxPyEndAllowThreads(__tstate);
13676 if (PyErr_Occurred()) SWIG_fail;
13677 }
13678 {
13679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13680 }
13681 return resultobj;
13682 fail:
13683 return NULL;
13684 }
13685
13686
13687 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13688 PyObject *resultobj;
13689 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13690 wxString *arg2 = 0 ;
13691 int arg3 = (int) 0 ;
13692 bool temp2 = false ;
13693 PyObject * obj0 = 0 ;
13694 PyObject * obj1 = 0 ;
13695 PyObject * obj2 = 0 ;
13696 char *kwnames[] = {
13697 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13698 };
13699
13700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13702 if (SWIG_arg_fail(1)) SWIG_fail;
13703 {
13704 arg2 = wxString_in_helper(obj1);
13705 if (arg2 == NULL) SWIG_fail;
13706 temp2 = true;
13707 }
13708 if (obj2) {
13709 {
13710 arg3 = (int)(SWIG_As_int(obj2));
13711 if (SWIG_arg_fail(3)) SWIG_fail;
13712 }
13713 }
13714 {
13715 PyThreadState* __tstate = wxPyBeginAllowThreads();
13716 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13717
13718 wxPyEndAllowThreads(__tstate);
13719 if (PyErr_Occurred()) SWIG_fail;
13720 }
13721 Py_INCREF(Py_None); resultobj = Py_None;
13722 {
13723 if (temp2)
13724 delete arg2;
13725 }
13726 return resultobj;
13727 fail:
13728 {
13729 if (temp2)
13730 delete arg2;
13731 }
13732 return NULL;
13733 }
13734
13735
13736 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13737 PyObject *resultobj;
13738 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13739 wxString *arg2 = 0 ;
13740 bool temp2 = false ;
13741 PyObject * obj0 = 0 ;
13742 PyObject * obj1 = 0 ;
13743 char *kwnames[] = {
13744 (char *) "self",(char *) "shortDesc", NULL
13745 };
13746
13747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13749 if (SWIG_arg_fail(1)) SWIG_fail;
13750 {
13751 arg2 = wxString_in_helper(obj1);
13752 if (arg2 == NULL) SWIG_fail;
13753 temp2 = true;
13754 }
13755 {
13756 PyThreadState* __tstate = wxPyBeginAllowThreads();
13757 (arg1)->SetShortDesc((wxString const &)*arg2);
13758
13759 wxPyEndAllowThreads(__tstate);
13760 if (PyErr_Occurred()) SWIG_fail;
13761 }
13762 Py_INCREF(Py_None); resultobj = Py_None;
13763 {
13764 if (temp2)
13765 delete arg2;
13766 }
13767 return resultobj;
13768 fail:
13769 {
13770 if (temp2)
13771 delete arg2;
13772 }
13773 return NULL;
13774 }
13775
13776
13777 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13778 PyObject *resultobj;
13779 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13780 wxString *result;
13781 PyObject * obj0 = 0 ;
13782 char *kwnames[] = {
13783 (char *) "self", NULL
13784 };
13785
13786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13788 if (SWIG_arg_fail(1)) SWIG_fail;
13789 {
13790 PyThreadState* __tstate = wxPyBeginAllowThreads();
13791 {
13792 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13793 result = (wxString *) &_result_ref;
13794 }
13795
13796 wxPyEndAllowThreads(__tstate);
13797 if (PyErr_Occurred()) SWIG_fail;
13798 }
13799 {
13800 #if wxUSE_UNICODE
13801 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13802 #else
13803 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13804 #endif
13805 }
13806 return resultobj;
13807 fail:
13808 return NULL;
13809 }
13810
13811
13812 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13813 PyObject *resultobj;
13814 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13815 wxString *result;
13816 PyObject * obj0 = 0 ;
13817 char *kwnames[] = {
13818 (char *) "self", NULL
13819 };
13820
13821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13823 if (SWIG_arg_fail(1)) SWIG_fail;
13824 {
13825 PyThreadState* __tstate = wxPyBeginAllowThreads();
13826 {
13827 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13828 result = (wxString *) &_result_ref;
13829 }
13830
13831 wxPyEndAllowThreads(__tstate);
13832 if (PyErr_Occurred()) SWIG_fail;
13833 }
13834 {
13835 #if wxUSE_UNICODE
13836 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13837 #else
13838 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13839 #endif
13840 }
13841 return resultobj;
13842 fail:
13843 return NULL;
13844 }
13845
13846
13847 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13848 PyObject *resultobj;
13849 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13850 wxString *result;
13851 PyObject * obj0 = 0 ;
13852 char *kwnames[] = {
13853 (char *) "self", NULL
13854 };
13855
13856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
13857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13858 if (SWIG_arg_fail(1)) SWIG_fail;
13859 {
13860 PyThreadState* __tstate = wxPyBeginAllowThreads();
13861 {
13862 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
13863 result = (wxString *) &_result_ref;
13864 }
13865
13866 wxPyEndAllowThreads(__tstate);
13867 if (PyErr_Occurred()) SWIG_fail;
13868 }
13869 {
13870 #if wxUSE_UNICODE
13871 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13872 #else
13873 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13874 #endif
13875 }
13876 return resultobj;
13877 fail:
13878 return NULL;
13879 }
13880
13881
13882 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13883 PyObject *resultobj;
13884 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13885 wxString *result;
13886 PyObject * obj0 = 0 ;
13887 char *kwnames[] = {
13888 (char *) "self", NULL
13889 };
13890
13891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
13892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13893 if (SWIG_arg_fail(1)) SWIG_fail;
13894 {
13895 PyThreadState* __tstate = wxPyBeginAllowThreads();
13896 {
13897 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
13898 result = (wxString *) &_result_ref;
13899 }
13900
13901 wxPyEndAllowThreads(__tstate);
13902 if (PyErr_Occurred()) SWIG_fail;
13903 }
13904 {
13905 #if wxUSE_UNICODE
13906 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13907 #else
13908 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13909 #endif
13910 }
13911 return resultobj;
13912 fail:
13913 return NULL;
13914 }
13915
13916
13917 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
13918 PyObject *resultobj;
13919 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13920 wxString *result;
13921 PyObject * obj0 = 0 ;
13922 char *kwnames[] = {
13923 (char *) "self", NULL
13924 };
13925
13926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
13927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13928 if (SWIG_arg_fail(1)) SWIG_fail;
13929 {
13930 PyThreadState* __tstate = wxPyBeginAllowThreads();
13931 {
13932 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
13933 result = (wxString *) &_result_ref;
13934 }
13935
13936 wxPyEndAllowThreads(__tstate);
13937 if (PyErr_Occurred()) SWIG_fail;
13938 }
13939 {
13940 #if wxUSE_UNICODE
13941 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13942 #else
13943 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13944 #endif
13945 }
13946 return resultobj;
13947 fail:
13948 return NULL;
13949 }
13950
13951
13952 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
13953 PyObject *resultobj;
13954 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13955 wxArrayString *result;
13956 PyObject * obj0 = 0 ;
13957 char *kwnames[] = {
13958 (char *) "self", NULL
13959 };
13960
13961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
13962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13963 if (SWIG_arg_fail(1)) SWIG_fail;
13964 {
13965 PyThreadState* __tstate = wxPyBeginAllowThreads();
13966 {
13967 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
13968 result = (wxArrayString *) &_result_ref;
13969 }
13970
13971 wxPyEndAllowThreads(__tstate);
13972 if (PyErr_Occurred()) SWIG_fail;
13973 }
13974 {
13975 resultobj = wxArrayString2PyList_helper(*result);
13976 }
13977 return resultobj;
13978 fail:
13979 return NULL;
13980 }
13981
13982
13983 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
13984 PyObject *resultobj;
13985 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13986 int result;
13987 PyObject * obj0 = 0 ;
13988 char *kwnames[] = {
13989 (char *) "self", NULL
13990 };
13991
13992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
13993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13994 if (SWIG_arg_fail(1)) SWIG_fail;
13995 {
13996 PyThreadState* __tstate = wxPyBeginAllowThreads();
13997 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
13998
13999 wxPyEndAllowThreads(__tstate);
14000 if (PyErr_Occurred()) SWIG_fail;
14001 }
14002 {
14003 resultobj = SWIG_From_int((int)(result));
14004 }
14005 return resultobj;
14006 fail:
14007 return NULL;
14008 }
14009
14010
14011 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14012 PyObject *resultobj;
14013 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14014 wxString *result;
14015 PyObject * obj0 = 0 ;
14016 char *kwnames[] = {
14017 (char *) "self", NULL
14018 };
14019
14020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14022 if (SWIG_arg_fail(1)) SWIG_fail;
14023 {
14024 PyThreadState* __tstate = wxPyBeginAllowThreads();
14025 {
14026 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14027 result = (wxString *) &_result_ref;
14028 }
14029
14030 wxPyEndAllowThreads(__tstate);
14031 if (PyErr_Occurred()) SWIG_fail;
14032 }
14033 {
14034 #if wxUSE_UNICODE
14035 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14036 #else
14037 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14038 #endif
14039 }
14040 return resultobj;
14041 fail:
14042 return NULL;
14043 }
14044
14045
14046 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14047 PyObject *resultobj;
14048 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14049 int result;
14050 PyObject * obj0 = 0 ;
14051 char *kwnames[] = {
14052 (char *) "self", NULL
14053 };
14054
14055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14057 if (SWIG_arg_fail(1)) SWIG_fail;
14058 {
14059 PyThreadState* __tstate = wxPyBeginAllowThreads();
14060 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14061
14062 wxPyEndAllowThreads(__tstate);
14063 if (PyErr_Occurred()) SWIG_fail;
14064 }
14065 {
14066 resultobj = SWIG_From_int((int)(result));
14067 }
14068 return resultobj;
14069 fail:
14070 return NULL;
14071 }
14072
14073
14074 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14075 PyObject *obj;
14076 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14077 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14078 Py_INCREF(obj);
14079 return Py_BuildValue((char *)"");
14080 }
14081 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14082 PyObject *resultobj;
14083 wxFileTypeInfo *arg1 = 0 ;
14084 wxFileType *result;
14085 PyObject * obj0 = 0 ;
14086 char *kwnames[] = {
14087 (char *) "ftInfo", NULL
14088 };
14089
14090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14091 {
14092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14093 if (SWIG_arg_fail(1)) SWIG_fail;
14094 if (arg1 == NULL) {
14095 SWIG_null_ref("wxFileTypeInfo");
14096 }
14097 if (SWIG_arg_fail(1)) SWIG_fail;
14098 }
14099 {
14100 PyThreadState* __tstate = wxPyBeginAllowThreads();
14101 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14102
14103 wxPyEndAllowThreads(__tstate);
14104 if (PyErr_Occurred()) SWIG_fail;
14105 }
14106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14107 return resultobj;
14108 fail:
14109 return NULL;
14110 }
14111
14112
14113 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14114 PyObject *resultobj;
14115 wxFileType *arg1 = (wxFileType *) 0 ;
14116 PyObject * obj0 = 0 ;
14117 char *kwnames[] = {
14118 (char *) "self", NULL
14119 };
14120
14121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14123 if (SWIG_arg_fail(1)) SWIG_fail;
14124 {
14125 PyThreadState* __tstate = wxPyBeginAllowThreads();
14126 delete arg1;
14127
14128 wxPyEndAllowThreads(__tstate);
14129 if (PyErr_Occurred()) SWIG_fail;
14130 }
14131 Py_INCREF(Py_None); resultobj = Py_None;
14132 return resultobj;
14133 fail:
14134 return NULL;
14135 }
14136
14137
14138 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14139 PyObject *resultobj;
14140 wxFileType *arg1 = (wxFileType *) 0 ;
14141 PyObject *result;
14142 PyObject * obj0 = 0 ;
14143 char *kwnames[] = {
14144 (char *) "self", NULL
14145 };
14146
14147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14149 if (SWIG_arg_fail(1)) SWIG_fail;
14150 {
14151 PyThreadState* __tstate = wxPyBeginAllowThreads();
14152 result = (PyObject *)wxFileType_GetMimeType(arg1);
14153
14154 wxPyEndAllowThreads(__tstate);
14155 if (PyErr_Occurred()) SWIG_fail;
14156 }
14157 resultobj = result;
14158 return resultobj;
14159 fail:
14160 return NULL;
14161 }
14162
14163
14164 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14165 PyObject *resultobj;
14166 wxFileType *arg1 = (wxFileType *) 0 ;
14167 PyObject *result;
14168 PyObject * obj0 = 0 ;
14169 char *kwnames[] = {
14170 (char *) "self", NULL
14171 };
14172
14173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14175 if (SWIG_arg_fail(1)) SWIG_fail;
14176 {
14177 PyThreadState* __tstate = wxPyBeginAllowThreads();
14178 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14179
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 resultobj = result;
14184 return resultobj;
14185 fail:
14186 return NULL;
14187 }
14188
14189
14190 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14191 PyObject *resultobj;
14192 wxFileType *arg1 = (wxFileType *) 0 ;
14193 PyObject *result;
14194 PyObject * obj0 = 0 ;
14195 char *kwnames[] = {
14196 (char *) "self", NULL
14197 };
14198
14199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14201 if (SWIG_arg_fail(1)) SWIG_fail;
14202 {
14203 PyThreadState* __tstate = wxPyBeginAllowThreads();
14204 result = (PyObject *)wxFileType_GetExtensions(arg1);
14205
14206 wxPyEndAllowThreads(__tstate);
14207 if (PyErr_Occurred()) SWIG_fail;
14208 }
14209 resultobj = result;
14210 return resultobj;
14211 fail:
14212 return NULL;
14213 }
14214
14215
14216 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14217 PyObject *resultobj;
14218 wxFileType *arg1 = (wxFileType *) 0 ;
14219 wxIcon *result;
14220 PyObject * obj0 = 0 ;
14221 char *kwnames[] = {
14222 (char *) "self", NULL
14223 };
14224
14225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14227 if (SWIG_arg_fail(1)) SWIG_fail;
14228 {
14229 PyThreadState* __tstate = wxPyBeginAllowThreads();
14230 result = (wxIcon *)wxFileType_GetIcon(arg1);
14231
14232 wxPyEndAllowThreads(__tstate);
14233 if (PyErr_Occurred()) SWIG_fail;
14234 }
14235 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14236 return resultobj;
14237 fail:
14238 return NULL;
14239 }
14240
14241
14242 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14243 PyObject *resultobj;
14244 wxFileType *arg1 = (wxFileType *) 0 ;
14245 PyObject *result;
14246 PyObject * obj0 = 0 ;
14247 char *kwnames[] = {
14248 (char *) "self", NULL
14249 };
14250
14251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14253 if (SWIG_arg_fail(1)) SWIG_fail;
14254 {
14255 PyThreadState* __tstate = wxPyBeginAllowThreads();
14256 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14257
14258 wxPyEndAllowThreads(__tstate);
14259 if (PyErr_Occurred()) SWIG_fail;
14260 }
14261 resultobj = result;
14262 return resultobj;
14263 fail:
14264 return NULL;
14265 }
14266
14267
14268 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14269 PyObject *resultobj;
14270 wxFileType *arg1 = (wxFileType *) 0 ;
14271 PyObject *result;
14272 PyObject * obj0 = 0 ;
14273 char *kwnames[] = {
14274 (char *) "self", NULL
14275 };
14276
14277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14279 if (SWIG_arg_fail(1)) SWIG_fail;
14280 {
14281 PyThreadState* __tstate = wxPyBeginAllowThreads();
14282 result = (PyObject *)wxFileType_GetDescription(arg1);
14283
14284 wxPyEndAllowThreads(__tstate);
14285 if (PyErr_Occurred()) SWIG_fail;
14286 }
14287 resultobj = result;
14288 return resultobj;
14289 fail:
14290 return NULL;
14291 }
14292
14293
14294 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14295 PyObject *resultobj;
14296 wxFileType *arg1 = (wxFileType *) 0 ;
14297 wxString *arg2 = 0 ;
14298 wxString const &arg3_defvalue = wxPyEmptyString ;
14299 wxString *arg3 = (wxString *) &arg3_defvalue ;
14300 PyObject *result;
14301 bool temp2 = false ;
14302 bool temp3 = false ;
14303 PyObject * obj0 = 0 ;
14304 PyObject * obj1 = 0 ;
14305 PyObject * obj2 = 0 ;
14306 char *kwnames[] = {
14307 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14308 };
14309
14310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14312 if (SWIG_arg_fail(1)) SWIG_fail;
14313 {
14314 arg2 = wxString_in_helper(obj1);
14315 if (arg2 == NULL) SWIG_fail;
14316 temp2 = true;
14317 }
14318 if (obj2) {
14319 {
14320 arg3 = wxString_in_helper(obj2);
14321 if (arg3 == NULL) SWIG_fail;
14322 temp3 = true;
14323 }
14324 }
14325 {
14326 PyThreadState* __tstate = wxPyBeginAllowThreads();
14327 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14328
14329 wxPyEndAllowThreads(__tstate);
14330 if (PyErr_Occurred()) SWIG_fail;
14331 }
14332 resultobj = result;
14333 {
14334 if (temp2)
14335 delete arg2;
14336 }
14337 {
14338 if (temp3)
14339 delete arg3;
14340 }
14341 return resultobj;
14342 fail:
14343 {
14344 if (temp2)
14345 delete arg2;
14346 }
14347 {
14348 if (temp3)
14349 delete arg3;
14350 }
14351 return NULL;
14352 }
14353
14354
14355 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14356 PyObject *resultobj;
14357 wxFileType *arg1 = (wxFileType *) 0 ;
14358 wxString *arg2 = 0 ;
14359 wxString const &arg3_defvalue = wxPyEmptyString ;
14360 wxString *arg3 = (wxString *) &arg3_defvalue ;
14361 PyObject *result;
14362 bool temp2 = false ;
14363 bool temp3 = false ;
14364 PyObject * obj0 = 0 ;
14365 PyObject * obj1 = 0 ;
14366 PyObject * obj2 = 0 ;
14367 char *kwnames[] = {
14368 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14369 };
14370
14371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14373 if (SWIG_arg_fail(1)) SWIG_fail;
14374 {
14375 arg2 = wxString_in_helper(obj1);
14376 if (arg2 == NULL) SWIG_fail;
14377 temp2 = true;
14378 }
14379 if (obj2) {
14380 {
14381 arg3 = wxString_in_helper(obj2);
14382 if (arg3 == NULL) SWIG_fail;
14383 temp3 = true;
14384 }
14385 }
14386 {
14387 PyThreadState* __tstate = wxPyBeginAllowThreads();
14388 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14389
14390 wxPyEndAllowThreads(__tstate);
14391 if (PyErr_Occurred()) SWIG_fail;
14392 }
14393 resultobj = result;
14394 {
14395 if (temp2)
14396 delete arg2;
14397 }
14398 {
14399 if (temp3)
14400 delete arg3;
14401 }
14402 return resultobj;
14403 fail:
14404 {
14405 if (temp2)
14406 delete arg2;
14407 }
14408 {
14409 if (temp3)
14410 delete arg3;
14411 }
14412 return NULL;
14413 }
14414
14415
14416 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14417 PyObject *resultobj;
14418 wxFileType *arg1 = (wxFileType *) 0 ;
14419 wxString *arg2 = 0 ;
14420 wxString const &arg3_defvalue = wxPyEmptyString ;
14421 wxString *arg3 = (wxString *) &arg3_defvalue ;
14422 PyObject *result;
14423 bool temp2 = false ;
14424 bool temp3 = false ;
14425 PyObject * obj0 = 0 ;
14426 PyObject * obj1 = 0 ;
14427 PyObject * obj2 = 0 ;
14428 char *kwnames[] = {
14429 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14430 };
14431
14432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14434 if (SWIG_arg_fail(1)) SWIG_fail;
14435 {
14436 arg2 = wxString_in_helper(obj1);
14437 if (arg2 == NULL) SWIG_fail;
14438 temp2 = true;
14439 }
14440 if (obj2) {
14441 {
14442 arg3 = wxString_in_helper(obj2);
14443 if (arg3 == NULL) SWIG_fail;
14444 temp3 = true;
14445 }
14446 }
14447 {
14448 PyThreadState* __tstate = wxPyBeginAllowThreads();
14449 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14450
14451 wxPyEndAllowThreads(__tstate);
14452 if (PyErr_Occurred()) SWIG_fail;
14453 }
14454 resultobj = result;
14455 {
14456 if (temp2)
14457 delete arg2;
14458 }
14459 {
14460 if (temp3)
14461 delete arg3;
14462 }
14463 return resultobj;
14464 fail:
14465 {
14466 if (temp2)
14467 delete arg2;
14468 }
14469 {
14470 if (temp3)
14471 delete arg3;
14472 }
14473 return NULL;
14474 }
14475
14476
14477 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14478 PyObject *resultobj;
14479 wxFileType *arg1 = (wxFileType *) 0 ;
14480 wxString *arg2 = 0 ;
14481 wxString *arg3 = 0 ;
14482 bool arg4 = (bool) true ;
14483 bool result;
14484 bool temp2 = false ;
14485 bool temp3 = false ;
14486 PyObject * obj0 = 0 ;
14487 PyObject * obj1 = 0 ;
14488 PyObject * obj2 = 0 ;
14489 PyObject * obj3 = 0 ;
14490 char *kwnames[] = {
14491 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14492 };
14493
14494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14496 if (SWIG_arg_fail(1)) SWIG_fail;
14497 {
14498 arg2 = wxString_in_helper(obj1);
14499 if (arg2 == NULL) SWIG_fail;
14500 temp2 = true;
14501 }
14502 {
14503 arg3 = wxString_in_helper(obj2);
14504 if (arg3 == NULL) SWIG_fail;
14505 temp3 = true;
14506 }
14507 if (obj3) {
14508 {
14509 arg4 = (bool)(SWIG_As_bool(obj3));
14510 if (SWIG_arg_fail(4)) SWIG_fail;
14511 }
14512 }
14513 {
14514 PyThreadState* __tstate = wxPyBeginAllowThreads();
14515 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14516
14517 wxPyEndAllowThreads(__tstate);
14518 if (PyErr_Occurred()) SWIG_fail;
14519 }
14520 {
14521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14522 }
14523 {
14524 if (temp2)
14525 delete arg2;
14526 }
14527 {
14528 if (temp3)
14529 delete arg3;
14530 }
14531 return resultobj;
14532 fail:
14533 {
14534 if (temp2)
14535 delete arg2;
14536 }
14537 {
14538 if (temp3)
14539 delete arg3;
14540 }
14541 return NULL;
14542 }
14543
14544
14545 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14546 PyObject *resultobj;
14547 wxFileType *arg1 = (wxFileType *) 0 ;
14548 wxString const &arg2_defvalue = wxPyEmptyString ;
14549 wxString *arg2 = (wxString *) &arg2_defvalue ;
14550 int arg3 = (int) 0 ;
14551 bool result;
14552 bool temp2 = false ;
14553 PyObject * obj0 = 0 ;
14554 PyObject * obj1 = 0 ;
14555 PyObject * obj2 = 0 ;
14556 char *kwnames[] = {
14557 (char *) "self",(char *) "cmd",(char *) "index", NULL
14558 };
14559
14560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14562 if (SWIG_arg_fail(1)) SWIG_fail;
14563 if (obj1) {
14564 {
14565 arg2 = wxString_in_helper(obj1);
14566 if (arg2 == NULL) SWIG_fail;
14567 temp2 = true;
14568 }
14569 }
14570 if (obj2) {
14571 {
14572 arg3 = (int)(SWIG_As_int(obj2));
14573 if (SWIG_arg_fail(3)) SWIG_fail;
14574 }
14575 }
14576 {
14577 PyThreadState* __tstate = wxPyBeginAllowThreads();
14578 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14579
14580 wxPyEndAllowThreads(__tstate);
14581 if (PyErr_Occurred()) SWIG_fail;
14582 }
14583 {
14584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14585 }
14586 {
14587 if (temp2)
14588 delete arg2;
14589 }
14590 return resultobj;
14591 fail:
14592 {
14593 if (temp2)
14594 delete arg2;
14595 }
14596 return NULL;
14597 }
14598
14599
14600 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14601 PyObject *resultobj;
14602 wxFileType *arg1 = (wxFileType *) 0 ;
14603 bool result;
14604 PyObject * obj0 = 0 ;
14605 char *kwnames[] = {
14606 (char *) "self", NULL
14607 };
14608
14609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14611 if (SWIG_arg_fail(1)) SWIG_fail;
14612 {
14613 PyThreadState* __tstate = wxPyBeginAllowThreads();
14614 result = (bool)(arg1)->Unassociate();
14615
14616 wxPyEndAllowThreads(__tstate);
14617 if (PyErr_Occurred()) SWIG_fail;
14618 }
14619 {
14620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14621 }
14622 return resultobj;
14623 fail:
14624 return NULL;
14625 }
14626
14627
14628 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14629 PyObject *resultobj;
14630 wxString *arg1 = 0 ;
14631 wxString *arg2 = 0 ;
14632 wxString const &arg3_defvalue = wxPyEmptyString ;
14633 wxString *arg3 = (wxString *) &arg3_defvalue ;
14634 wxString result;
14635 bool temp1 = false ;
14636 bool temp2 = false ;
14637 bool temp3 = false ;
14638 PyObject * obj0 = 0 ;
14639 PyObject * obj1 = 0 ;
14640 PyObject * obj2 = 0 ;
14641 char *kwnames[] = {
14642 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14643 };
14644
14645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14646 {
14647 arg1 = wxString_in_helper(obj0);
14648 if (arg1 == NULL) SWIG_fail;
14649 temp1 = true;
14650 }
14651 {
14652 arg2 = wxString_in_helper(obj1);
14653 if (arg2 == NULL) SWIG_fail;
14654 temp2 = true;
14655 }
14656 if (obj2) {
14657 {
14658 arg3 = wxString_in_helper(obj2);
14659 if (arg3 == NULL) SWIG_fail;
14660 temp3 = true;
14661 }
14662 }
14663 {
14664 PyThreadState* __tstate = wxPyBeginAllowThreads();
14665 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14666
14667 wxPyEndAllowThreads(__tstate);
14668 if (PyErr_Occurred()) SWIG_fail;
14669 }
14670 {
14671 #if wxUSE_UNICODE
14672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14673 #else
14674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14675 #endif
14676 }
14677 {
14678 if (temp1)
14679 delete arg1;
14680 }
14681 {
14682 if (temp2)
14683 delete arg2;
14684 }
14685 {
14686 if (temp3)
14687 delete arg3;
14688 }
14689 return resultobj;
14690 fail:
14691 {
14692 if (temp1)
14693 delete arg1;
14694 }
14695 {
14696 if (temp2)
14697 delete arg2;
14698 }
14699 {
14700 if (temp3)
14701 delete arg3;
14702 }
14703 return NULL;
14704 }
14705
14706
14707 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14708 PyObject *obj;
14709 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14710 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14711 Py_INCREF(obj);
14712 return Py_BuildValue((char *)"");
14713 }
14714 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14715 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14716 return 1;
14717 }
14718
14719
14720 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14721 PyObject *pyobj;
14722
14723 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14724 return pyobj;
14725 }
14726
14727
14728 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14729 PyObject *resultobj;
14730 wxString *arg1 = 0 ;
14731 wxString *arg2 = 0 ;
14732 bool result;
14733 bool temp1 = false ;
14734 bool temp2 = false ;
14735 PyObject * obj0 = 0 ;
14736 PyObject * obj1 = 0 ;
14737 char *kwnames[] = {
14738 (char *) "mimeType",(char *) "wildcard", NULL
14739 };
14740
14741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14742 {
14743 arg1 = wxString_in_helper(obj0);
14744 if (arg1 == NULL) SWIG_fail;
14745 temp1 = true;
14746 }
14747 {
14748 arg2 = wxString_in_helper(obj1);
14749 if (arg2 == NULL) SWIG_fail;
14750 temp2 = true;
14751 }
14752 {
14753 PyThreadState* __tstate = wxPyBeginAllowThreads();
14754 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14755
14756 wxPyEndAllowThreads(__tstate);
14757 if (PyErr_Occurred()) SWIG_fail;
14758 }
14759 {
14760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14761 }
14762 {
14763 if (temp1)
14764 delete arg1;
14765 }
14766 {
14767 if (temp2)
14768 delete arg2;
14769 }
14770 return resultobj;
14771 fail:
14772 {
14773 if (temp1)
14774 delete arg1;
14775 }
14776 {
14777 if (temp2)
14778 delete arg2;
14779 }
14780 return NULL;
14781 }
14782
14783
14784 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14785 PyObject *resultobj;
14786 wxMimeTypesManager *result;
14787 char *kwnames[] = {
14788 NULL
14789 };
14790
14791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14792 {
14793 PyThreadState* __tstate = wxPyBeginAllowThreads();
14794 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14795
14796 wxPyEndAllowThreads(__tstate);
14797 if (PyErr_Occurred()) SWIG_fail;
14798 }
14799 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14800 return resultobj;
14801 fail:
14802 return NULL;
14803 }
14804
14805
14806 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14807 PyObject *resultobj;
14808 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14809 int arg2 = (int) wxMAILCAP_ALL ;
14810 wxString const &arg3_defvalue = wxPyEmptyString ;
14811 wxString *arg3 = (wxString *) &arg3_defvalue ;
14812 bool temp3 = false ;
14813 PyObject * obj0 = 0 ;
14814 PyObject * obj1 = 0 ;
14815 PyObject * obj2 = 0 ;
14816 char *kwnames[] = {
14817 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14818 };
14819
14820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14822 if (SWIG_arg_fail(1)) SWIG_fail;
14823 if (obj1) {
14824 {
14825 arg2 = (int)(SWIG_As_int(obj1));
14826 if (SWIG_arg_fail(2)) SWIG_fail;
14827 }
14828 }
14829 if (obj2) {
14830 {
14831 arg3 = wxString_in_helper(obj2);
14832 if (arg3 == NULL) SWIG_fail;
14833 temp3 = true;
14834 }
14835 }
14836 {
14837 PyThreadState* __tstate = wxPyBeginAllowThreads();
14838 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14839
14840 wxPyEndAllowThreads(__tstate);
14841 if (PyErr_Occurred()) SWIG_fail;
14842 }
14843 Py_INCREF(Py_None); resultobj = Py_None;
14844 {
14845 if (temp3)
14846 delete arg3;
14847 }
14848 return resultobj;
14849 fail:
14850 {
14851 if (temp3)
14852 delete arg3;
14853 }
14854 return NULL;
14855 }
14856
14857
14858 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
14859 PyObject *resultobj;
14860 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14861 PyObject * obj0 = 0 ;
14862 char *kwnames[] = {
14863 (char *) "self", NULL
14864 };
14865
14866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
14867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14868 if (SWIG_arg_fail(1)) SWIG_fail;
14869 {
14870 PyThreadState* __tstate = wxPyBeginAllowThreads();
14871 (arg1)->ClearData();
14872
14873 wxPyEndAllowThreads(__tstate);
14874 if (PyErr_Occurred()) SWIG_fail;
14875 }
14876 Py_INCREF(Py_None); resultobj = Py_None;
14877 return resultobj;
14878 fail:
14879 return NULL;
14880 }
14881
14882
14883 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
14884 PyObject *resultobj;
14885 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14886 wxString *arg2 = 0 ;
14887 wxFileType *result;
14888 bool temp2 = false ;
14889 PyObject * obj0 = 0 ;
14890 PyObject * obj1 = 0 ;
14891 char *kwnames[] = {
14892 (char *) "self",(char *) "ext", NULL
14893 };
14894
14895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
14896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14897 if (SWIG_arg_fail(1)) SWIG_fail;
14898 {
14899 arg2 = wxString_in_helper(obj1);
14900 if (arg2 == NULL) SWIG_fail;
14901 temp2 = true;
14902 }
14903 {
14904 PyThreadState* __tstate = wxPyBeginAllowThreads();
14905 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
14906
14907 wxPyEndAllowThreads(__tstate);
14908 if (PyErr_Occurred()) SWIG_fail;
14909 }
14910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14911 {
14912 if (temp2)
14913 delete arg2;
14914 }
14915 return resultobj;
14916 fail:
14917 {
14918 if (temp2)
14919 delete arg2;
14920 }
14921 return NULL;
14922 }
14923
14924
14925 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14926 PyObject *resultobj;
14927 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14928 wxString *arg2 = 0 ;
14929 wxFileType *result;
14930 bool temp2 = false ;
14931 PyObject * obj0 = 0 ;
14932 PyObject * obj1 = 0 ;
14933 char *kwnames[] = {
14934 (char *) "self",(char *) "mimeType", NULL
14935 };
14936
14937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
14938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14939 if (SWIG_arg_fail(1)) SWIG_fail;
14940 {
14941 arg2 = wxString_in_helper(obj1);
14942 if (arg2 == NULL) SWIG_fail;
14943 temp2 = true;
14944 }
14945 {
14946 PyThreadState* __tstate = wxPyBeginAllowThreads();
14947 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
14948
14949 wxPyEndAllowThreads(__tstate);
14950 if (PyErr_Occurred()) SWIG_fail;
14951 }
14952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14953 {
14954 if (temp2)
14955 delete arg2;
14956 }
14957 return resultobj;
14958 fail:
14959 {
14960 if (temp2)
14961 delete arg2;
14962 }
14963 return NULL;
14964 }
14965
14966
14967 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
14968 PyObject *resultobj;
14969 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14970 wxString *arg2 = 0 ;
14971 bool arg3 = (bool) false ;
14972 bool result;
14973 bool temp2 = false ;
14974 PyObject * obj0 = 0 ;
14975 PyObject * obj1 = 0 ;
14976 PyObject * obj2 = 0 ;
14977 char *kwnames[] = {
14978 (char *) "self",(char *) "filename",(char *) "fallback", NULL
14979 };
14980
14981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
14982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14983 if (SWIG_arg_fail(1)) SWIG_fail;
14984 {
14985 arg2 = wxString_in_helper(obj1);
14986 if (arg2 == NULL) SWIG_fail;
14987 temp2 = true;
14988 }
14989 if (obj2) {
14990 {
14991 arg3 = (bool)(SWIG_As_bool(obj2));
14992 if (SWIG_arg_fail(3)) SWIG_fail;
14993 }
14994 }
14995 {
14996 PyThreadState* __tstate = wxPyBeginAllowThreads();
14997 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
14998
14999 wxPyEndAllowThreads(__tstate);
15000 if (PyErr_Occurred()) SWIG_fail;
15001 }
15002 {
15003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15004 }
15005 {
15006 if (temp2)
15007 delete arg2;
15008 }
15009 return resultobj;
15010 fail:
15011 {
15012 if (temp2)
15013 delete arg2;
15014 }
15015 return NULL;
15016 }
15017
15018
15019 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15020 PyObject *resultobj;
15021 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15022 wxString *arg2 = 0 ;
15023 bool result;
15024 bool temp2 = false ;
15025 PyObject * obj0 = 0 ;
15026 PyObject * obj1 = 0 ;
15027 char *kwnames[] = {
15028 (char *) "self",(char *) "filename", NULL
15029 };
15030
15031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15033 if (SWIG_arg_fail(1)) SWIG_fail;
15034 {
15035 arg2 = wxString_in_helper(obj1);
15036 if (arg2 == NULL) SWIG_fail;
15037 temp2 = true;
15038 }
15039 {
15040 PyThreadState* __tstate = wxPyBeginAllowThreads();
15041 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15042
15043 wxPyEndAllowThreads(__tstate);
15044 if (PyErr_Occurred()) SWIG_fail;
15045 }
15046 {
15047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15048 }
15049 {
15050 if (temp2)
15051 delete arg2;
15052 }
15053 return resultobj;
15054 fail:
15055 {
15056 if (temp2)
15057 delete arg2;
15058 }
15059 return NULL;
15060 }
15061
15062
15063 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15064 PyObject *resultobj;
15065 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15066 PyObject *result;
15067 PyObject * obj0 = 0 ;
15068 char *kwnames[] = {
15069 (char *) "self", NULL
15070 };
15071
15072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15074 if (SWIG_arg_fail(1)) SWIG_fail;
15075 {
15076 PyThreadState* __tstate = wxPyBeginAllowThreads();
15077 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15078
15079 wxPyEndAllowThreads(__tstate);
15080 if (PyErr_Occurred()) SWIG_fail;
15081 }
15082 resultobj = result;
15083 return resultobj;
15084 fail:
15085 return NULL;
15086 }
15087
15088
15089 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15090 PyObject *resultobj;
15091 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15092 wxFileTypeInfo *arg2 = 0 ;
15093 PyObject * obj0 = 0 ;
15094 PyObject * obj1 = 0 ;
15095 char *kwnames[] = {
15096 (char *) "self",(char *) "ft", NULL
15097 };
15098
15099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15101 if (SWIG_arg_fail(1)) SWIG_fail;
15102 {
15103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15104 if (SWIG_arg_fail(2)) SWIG_fail;
15105 if (arg2 == NULL) {
15106 SWIG_null_ref("wxFileTypeInfo");
15107 }
15108 if (SWIG_arg_fail(2)) SWIG_fail;
15109 }
15110 {
15111 PyThreadState* __tstate = wxPyBeginAllowThreads();
15112 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15113
15114 wxPyEndAllowThreads(__tstate);
15115 if (PyErr_Occurred()) SWIG_fail;
15116 }
15117 Py_INCREF(Py_None); resultobj = Py_None;
15118 return resultobj;
15119 fail:
15120 return NULL;
15121 }
15122
15123
15124 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15125 PyObject *resultobj;
15126 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15127 wxFileTypeInfo *arg2 = 0 ;
15128 wxFileType *result;
15129 PyObject * obj0 = 0 ;
15130 PyObject * obj1 = 0 ;
15131 char *kwnames[] = {
15132 (char *) "self",(char *) "ftInfo", NULL
15133 };
15134
15135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15137 if (SWIG_arg_fail(1)) SWIG_fail;
15138 {
15139 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15140 if (SWIG_arg_fail(2)) SWIG_fail;
15141 if (arg2 == NULL) {
15142 SWIG_null_ref("wxFileTypeInfo");
15143 }
15144 if (SWIG_arg_fail(2)) SWIG_fail;
15145 }
15146 {
15147 PyThreadState* __tstate = wxPyBeginAllowThreads();
15148 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15149
15150 wxPyEndAllowThreads(__tstate);
15151 if (PyErr_Occurred()) SWIG_fail;
15152 }
15153 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15154 return resultobj;
15155 fail:
15156 return NULL;
15157 }
15158
15159
15160 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15161 PyObject *resultobj;
15162 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15163 wxFileType *arg2 = (wxFileType *) 0 ;
15164 bool result;
15165 PyObject * obj0 = 0 ;
15166 PyObject * obj1 = 0 ;
15167 char *kwnames[] = {
15168 (char *) "self",(char *) "ft", NULL
15169 };
15170
15171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15173 if (SWIG_arg_fail(1)) SWIG_fail;
15174 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15175 if (SWIG_arg_fail(2)) SWIG_fail;
15176 {
15177 PyThreadState* __tstate = wxPyBeginAllowThreads();
15178 result = (bool)(arg1)->Unassociate(arg2);
15179
15180 wxPyEndAllowThreads(__tstate);
15181 if (PyErr_Occurred()) SWIG_fail;
15182 }
15183 {
15184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15185 }
15186 return resultobj;
15187 fail:
15188 return NULL;
15189 }
15190
15191
15192 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15193 PyObject *resultobj;
15194 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15195 PyObject * obj0 = 0 ;
15196 char *kwnames[] = {
15197 (char *) "self", NULL
15198 };
15199
15200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15202 if (SWIG_arg_fail(1)) SWIG_fail;
15203 {
15204 PyThreadState* __tstate = wxPyBeginAllowThreads();
15205 delete arg1;
15206
15207 wxPyEndAllowThreads(__tstate);
15208 if (PyErr_Occurred()) SWIG_fail;
15209 }
15210 Py_INCREF(Py_None); resultobj = Py_None;
15211 return resultobj;
15212 fail:
15213 return NULL;
15214 }
15215
15216
15217 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15218 PyObject *obj;
15219 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15220 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15221 Py_INCREF(obj);
15222 return Py_BuildValue((char *)"");
15223 }
15224 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15225 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15226 return 1;
15227 }
15228
15229
15230 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15231 PyObject *pyobj;
15232
15233 {
15234 #if wxUSE_UNICODE
15235 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15236 #else
15237 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15238 #endif
15239 }
15240 return pyobj;
15241 }
15242
15243
15244 static int _wrap_ART_MENU_set(PyObject *) {
15245 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15246 return 1;
15247 }
15248
15249
15250 static PyObject *_wrap_ART_MENU_get(void) {
15251 PyObject *pyobj;
15252
15253 {
15254 #if wxUSE_UNICODE
15255 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15256 #else
15257 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15258 #endif
15259 }
15260 return pyobj;
15261 }
15262
15263
15264 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15265 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15266 return 1;
15267 }
15268
15269
15270 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15271 PyObject *pyobj;
15272
15273 {
15274 #if wxUSE_UNICODE
15275 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15276 #else
15277 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15278 #endif
15279 }
15280 return pyobj;
15281 }
15282
15283
15284 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15285 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15286 return 1;
15287 }
15288
15289
15290 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15291 PyObject *pyobj;
15292
15293 {
15294 #if wxUSE_UNICODE
15295 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15296 #else
15297 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15298 #endif
15299 }
15300 return pyobj;
15301 }
15302
15303
15304 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15305 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15306 return 1;
15307 }
15308
15309
15310 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15311 PyObject *pyobj;
15312
15313 {
15314 #if wxUSE_UNICODE
15315 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15316 #else
15317 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15318 #endif
15319 }
15320 return pyobj;
15321 }
15322
15323
15324 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15325 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15326 return 1;
15327 }
15328
15329
15330 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15331 PyObject *pyobj;
15332
15333 {
15334 #if wxUSE_UNICODE
15335 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15336 #else
15337 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15338 #endif
15339 }
15340 return pyobj;
15341 }
15342
15343
15344 static int _wrap_ART_BUTTON_set(PyObject *) {
15345 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15346 return 1;
15347 }
15348
15349
15350 static PyObject *_wrap_ART_BUTTON_get(void) {
15351 PyObject *pyobj;
15352
15353 {
15354 #if wxUSE_UNICODE
15355 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15356 #else
15357 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15358 #endif
15359 }
15360 return pyobj;
15361 }
15362
15363
15364 static int _wrap_ART_OTHER_set(PyObject *) {
15365 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15366 return 1;
15367 }
15368
15369
15370 static PyObject *_wrap_ART_OTHER_get(void) {
15371 PyObject *pyobj;
15372
15373 {
15374 #if wxUSE_UNICODE
15375 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15376 #else
15377 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15378 #endif
15379 }
15380 return pyobj;
15381 }
15382
15383
15384 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15385 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15386 return 1;
15387 }
15388
15389
15390 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15391 PyObject *pyobj;
15392
15393 {
15394 #if wxUSE_UNICODE
15395 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15396 #else
15397 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15398 #endif
15399 }
15400 return pyobj;
15401 }
15402
15403
15404 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15405 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15406 return 1;
15407 }
15408
15409
15410 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15411 PyObject *pyobj;
15412
15413 {
15414 #if wxUSE_UNICODE
15415 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15416 #else
15417 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15418 #endif
15419 }
15420 return pyobj;
15421 }
15422
15423
15424 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15425 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15426 return 1;
15427 }
15428
15429
15430 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15431 PyObject *pyobj;
15432
15433 {
15434 #if wxUSE_UNICODE
15435 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15436 #else
15437 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15438 #endif
15439 }
15440 return pyobj;
15441 }
15442
15443
15444 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15445 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15446 return 1;
15447 }
15448
15449
15450 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15451 PyObject *pyobj;
15452
15453 {
15454 #if wxUSE_UNICODE
15455 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15456 #else
15457 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15458 #endif
15459 }
15460 return pyobj;
15461 }
15462
15463
15464 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15465 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15466 return 1;
15467 }
15468
15469
15470 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15471 PyObject *pyobj;
15472
15473 {
15474 #if wxUSE_UNICODE
15475 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15476 #else
15477 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15478 #endif
15479 }
15480 return pyobj;
15481 }
15482
15483
15484 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15485 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15486 return 1;
15487 }
15488
15489
15490 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15491 PyObject *pyobj;
15492
15493 {
15494 #if wxUSE_UNICODE
15495 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15496 #else
15497 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15498 #endif
15499 }
15500 return pyobj;
15501 }
15502
15503
15504 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15505 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15506 return 1;
15507 }
15508
15509
15510 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15511 PyObject *pyobj;
15512
15513 {
15514 #if wxUSE_UNICODE
15515 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15516 #else
15517 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15518 #endif
15519 }
15520 return pyobj;
15521 }
15522
15523
15524 static int _wrap_ART_GO_BACK_set(PyObject *) {
15525 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15526 return 1;
15527 }
15528
15529
15530 static PyObject *_wrap_ART_GO_BACK_get(void) {
15531 PyObject *pyobj;
15532
15533 {
15534 #if wxUSE_UNICODE
15535 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15536 #else
15537 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15538 #endif
15539 }
15540 return pyobj;
15541 }
15542
15543
15544 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15545 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15546 return 1;
15547 }
15548
15549
15550 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15551 PyObject *pyobj;
15552
15553 {
15554 #if wxUSE_UNICODE
15555 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15556 #else
15557 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15558 #endif
15559 }
15560 return pyobj;
15561 }
15562
15563
15564 static int _wrap_ART_GO_UP_set(PyObject *) {
15565 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15566 return 1;
15567 }
15568
15569
15570 static PyObject *_wrap_ART_GO_UP_get(void) {
15571 PyObject *pyobj;
15572
15573 {
15574 #if wxUSE_UNICODE
15575 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15576 #else
15577 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15578 #endif
15579 }
15580 return pyobj;
15581 }
15582
15583
15584 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15585 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15586 return 1;
15587 }
15588
15589
15590 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15591 PyObject *pyobj;
15592
15593 {
15594 #if wxUSE_UNICODE
15595 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15596 #else
15597 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15598 #endif
15599 }
15600 return pyobj;
15601 }
15602
15603
15604 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15605 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15606 return 1;
15607 }
15608
15609
15610 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15611 PyObject *pyobj;
15612
15613 {
15614 #if wxUSE_UNICODE
15615 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15616 #else
15617 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15618 #endif
15619 }
15620 return pyobj;
15621 }
15622
15623
15624 static int _wrap_ART_GO_HOME_set(PyObject *) {
15625 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15626 return 1;
15627 }
15628
15629
15630 static PyObject *_wrap_ART_GO_HOME_get(void) {
15631 PyObject *pyobj;
15632
15633 {
15634 #if wxUSE_UNICODE
15635 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15636 #else
15637 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15638 #endif
15639 }
15640 return pyobj;
15641 }
15642
15643
15644 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15645 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15646 return 1;
15647 }
15648
15649
15650 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15651 PyObject *pyobj;
15652
15653 {
15654 #if wxUSE_UNICODE
15655 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15656 #else
15657 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15658 #endif
15659 }
15660 return pyobj;
15661 }
15662
15663
15664 static int _wrap_ART_PRINT_set(PyObject *) {
15665 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15666 return 1;
15667 }
15668
15669
15670 static PyObject *_wrap_ART_PRINT_get(void) {
15671 PyObject *pyobj;
15672
15673 {
15674 #if wxUSE_UNICODE
15675 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15676 #else
15677 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15678 #endif
15679 }
15680 return pyobj;
15681 }
15682
15683
15684 static int _wrap_ART_HELP_set(PyObject *) {
15685 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15686 return 1;
15687 }
15688
15689
15690 static PyObject *_wrap_ART_HELP_get(void) {
15691 PyObject *pyobj;
15692
15693 {
15694 #if wxUSE_UNICODE
15695 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15696 #else
15697 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15698 #endif
15699 }
15700 return pyobj;
15701 }
15702
15703
15704 static int _wrap_ART_TIP_set(PyObject *) {
15705 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15706 return 1;
15707 }
15708
15709
15710 static PyObject *_wrap_ART_TIP_get(void) {
15711 PyObject *pyobj;
15712
15713 {
15714 #if wxUSE_UNICODE
15715 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15716 #else
15717 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15718 #endif
15719 }
15720 return pyobj;
15721 }
15722
15723
15724 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15725 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15726 return 1;
15727 }
15728
15729
15730 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15731 PyObject *pyobj;
15732
15733 {
15734 #if wxUSE_UNICODE
15735 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15736 #else
15737 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15738 #endif
15739 }
15740 return pyobj;
15741 }
15742
15743
15744 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15745 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15746 return 1;
15747 }
15748
15749
15750 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15751 PyObject *pyobj;
15752
15753 {
15754 #if wxUSE_UNICODE
15755 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15756 #else
15757 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15758 #endif
15759 }
15760 return pyobj;
15761 }
15762
15763
15764 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15765 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15766 return 1;
15767 }
15768
15769
15770 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15771 PyObject *pyobj;
15772
15773 {
15774 #if wxUSE_UNICODE
15775 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15776 #else
15777 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15778 #endif
15779 }
15780 return pyobj;
15781 }
15782
15783
15784 static int _wrap_ART_HARDDISK_set(PyObject *) {
15785 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15786 return 1;
15787 }
15788
15789
15790 static PyObject *_wrap_ART_HARDDISK_get(void) {
15791 PyObject *pyobj;
15792
15793 {
15794 #if wxUSE_UNICODE
15795 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15796 #else
15797 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15798 #endif
15799 }
15800 return pyobj;
15801 }
15802
15803
15804 static int _wrap_ART_FLOPPY_set(PyObject *) {
15805 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15806 return 1;
15807 }
15808
15809
15810 static PyObject *_wrap_ART_FLOPPY_get(void) {
15811 PyObject *pyobj;
15812
15813 {
15814 #if wxUSE_UNICODE
15815 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15816 #else
15817 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15818 #endif
15819 }
15820 return pyobj;
15821 }
15822
15823
15824 static int _wrap_ART_CDROM_set(PyObject *) {
15825 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
15826 return 1;
15827 }
15828
15829
15830 static PyObject *_wrap_ART_CDROM_get(void) {
15831 PyObject *pyobj;
15832
15833 {
15834 #if wxUSE_UNICODE
15835 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
15836 #else
15837 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
15838 #endif
15839 }
15840 return pyobj;
15841 }
15842
15843
15844 static int _wrap_ART_REMOVABLE_set(PyObject *) {
15845 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
15846 return 1;
15847 }
15848
15849
15850 static PyObject *_wrap_ART_REMOVABLE_get(void) {
15851 PyObject *pyobj;
15852
15853 {
15854 #if wxUSE_UNICODE
15855 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
15856 #else
15857 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
15858 #endif
15859 }
15860 return pyobj;
15861 }
15862
15863
15864 static int _wrap_ART_FOLDER_set(PyObject *) {
15865 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
15866 return 1;
15867 }
15868
15869
15870 static PyObject *_wrap_ART_FOLDER_get(void) {
15871 PyObject *pyobj;
15872
15873 {
15874 #if wxUSE_UNICODE
15875 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
15876 #else
15877 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
15878 #endif
15879 }
15880 return pyobj;
15881 }
15882
15883
15884 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
15885 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
15886 return 1;
15887 }
15888
15889
15890 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
15891 PyObject *pyobj;
15892
15893 {
15894 #if wxUSE_UNICODE
15895 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
15896 #else
15897 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
15898 #endif
15899 }
15900 return pyobj;
15901 }
15902
15903
15904 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
15905 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
15906 return 1;
15907 }
15908
15909
15910 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
15911 PyObject *pyobj;
15912
15913 {
15914 #if wxUSE_UNICODE
15915 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
15916 #else
15917 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
15918 #endif
15919 }
15920 return pyobj;
15921 }
15922
15923
15924 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
15925 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
15926 return 1;
15927 }
15928
15929
15930 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
15931 PyObject *pyobj;
15932
15933 {
15934 #if wxUSE_UNICODE
15935 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
15936 #else
15937 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
15938 #endif
15939 }
15940 return pyobj;
15941 }
15942
15943
15944 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
15945 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
15946 return 1;
15947 }
15948
15949
15950 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
15951 PyObject *pyobj;
15952
15953 {
15954 #if wxUSE_UNICODE
15955 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
15956 #else
15957 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
15958 #endif
15959 }
15960 return pyobj;
15961 }
15962
15963
15964 static int _wrap_ART_TICK_MARK_set(PyObject *) {
15965 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
15966 return 1;
15967 }
15968
15969
15970 static PyObject *_wrap_ART_TICK_MARK_get(void) {
15971 PyObject *pyobj;
15972
15973 {
15974 #if wxUSE_UNICODE
15975 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
15976 #else
15977 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
15978 #endif
15979 }
15980 return pyobj;
15981 }
15982
15983
15984 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
15985 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
15986 return 1;
15987 }
15988
15989
15990 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
15991 PyObject *pyobj;
15992
15993 {
15994 #if wxUSE_UNICODE
15995 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
15996 #else
15997 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
15998 #endif
15999 }
16000 return pyobj;
16001 }
16002
16003
16004 static int _wrap_ART_ERROR_set(PyObject *) {
16005 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16006 return 1;
16007 }
16008
16009
16010 static PyObject *_wrap_ART_ERROR_get(void) {
16011 PyObject *pyobj;
16012
16013 {
16014 #if wxUSE_UNICODE
16015 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16016 #else
16017 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16018 #endif
16019 }
16020 return pyobj;
16021 }
16022
16023
16024 static int _wrap_ART_QUESTION_set(PyObject *) {
16025 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16026 return 1;
16027 }
16028
16029
16030 static PyObject *_wrap_ART_QUESTION_get(void) {
16031 PyObject *pyobj;
16032
16033 {
16034 #if wxUSE_UNICODE
16035 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16036 #else
16037 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16038 #endif
16039 }
16040 return pyobj;
16041 }
16042
16043
16044 static int _wrap_ART_WARNING_set(PyObject *) {
16045 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16046 return 1;
16047 }
16048
16049
16050 static PyObject *_wrap_ART_WARNING_get(void) {
16051 PyObject *pyobj;
16052
16053 {
16054 #if wxUSE_UNICODE
16055 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16056 #else
16057 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16058 #endif
16059 }
16060 return pyobj;
16061 }
16062
16063
16064 static int _wrap_ART_INFORMATION_set(PyObject *) {
16065 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16066 return 1;
16067 }
16068
16069
16070 static PyObject *_wrap_ART_INFORMATION_get(void) {
16071 PyObject *pyobj;
16072
16073 {
16074 #if wxUSE_UNICODE
16075 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16076 #else
16077 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16078 #endif
16079 }
16080 return pyobj;
16081 }
16082
16083
16084 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16085 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16086 return 1;
16087 }
16088
16089
16090 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16091 PyObject *pyobj;
16092
16093 {
16094 #if wxUSE_UNICODE
16095 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16096 #else
16097 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16098 #endif
16099 }
16100 return pyobj;
16101 }
16102
16103
16104 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16105 PyObject *resultobj;
16106 wxPyArtProvider *result;
16107 char *kwnames[] = {
16108 NULL
16109 };
16110
16111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16112 {
16113 if (!wxPyCheckForApp()) SWIG_fail;
16114 PyThreadState* __tstate = wxPyBeginAllowThreads();
16115 result = (wxPyArtProvider *)new wxPyArtProvider();
16116
16117 wxPyEndAllowThreads(__tstate);
16118 if (PyErr_Occurred()) SWIG_fail;
16119 }
16120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16121 return resultobj;
16122 fail:
16123 return NULL;
16124 }
16125
16126
16127 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16128 PyObject *resultobj;
16129 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16130 PyObject *arg2 = (PyObject *) 0 ;
16131 PyObject *arg3 = (PyObject *) 0 ;
16132 PyObject * obj0 = 0 ;
16133 PyObject * obj1 = 0 ;
16134 PyObject * obj2 = 0 ;
16135 char *kwnames[] = {
16136 (char *) "self",(char *) "self",(char *) "_class", NULL
16137 };
16138
16139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16141 if (SWIG_arg_fail(1)) SWIG_fail;
16142 arg2 = obj1;
16143 arg3 = obj2;
16144 {
16145 PyThreadState* __tstate = wxPyBeginAllowThreads();
16146 (arg1)->_setCallbackInfo(arg2,arg3);
16147
16148 wxPyEndAllowThreads(__tstate);
16149 if (PyErr_Occurred()) SWIG_fail;
16150 }
16151 Py_INCREF(Py_None); resultobj = Py_None;
16152 return resultobj;
16153 fail:
16154 return NULL;
16155 }
16156
16157
16158 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16159 PyObject *resultobj;
16160 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16161 PyObject * obj0 = 0 ;
16162 char *kwnames[] = {
16163 (char *) "provider", NULL
16164 };
16165
16166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16168 if (SWIG_arg_fail(1)) SWIG_fail;
16169 {
16170 PyThreadState* __tstate = wxPyBeginAllowThreads();
16171 wxPyArtProvider::PushProvider(arg1);
16172
16173 wxPyEndAllowThreads(__tstate);
16174 if (PyErr_Occurred()) SWIG_fail;
16175 }
16176 Py_INCREF(Py_None); resultobj = Py_None;
16177 return resultobj;
16178 fail:
16179 return NULL;
16180 }
16181
16182
16183 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16184 PyObject *resultobj;
16185 bool result;
16186 char *kwnames[] = {
16187 NULL
16188 };
16189
16190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 result = (bool)wxPyArtProvider::PopProvider();
16194
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 {
16199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16200 }
16201 return resultobj;
16202 fail:
16203 return NULL;
16204 }
16205
16206
16207 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16208 PyObject *resultobj;
16209 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16210 bool result;
16211 PyObject * obj0 = 0 ;
16212 char *kwnames[] = {
16213 (char *) "provider", NULL
16214 };
16215
16216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16218 if (SWIG_arg_fail(1)) SWIG_fail;
16219 {
16220 PyThreadState* __tstate = wxPyBeginAllowThreads();
16221 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16222
16223 wxPyEndAllowThreads(__tstate);
16224 if (PyErr_Occurred()) SWIG_fail;
16225 }
16226 {
16227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16228 }
16229 return resultobj;
16230 fail:
16231 return NULL;
16232 }
16233
16234
16235 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16236 PyObject *resultobj;
16237 wxString *arg1 = 0 ;
16238 wxString const &arg2_defvalue = wxPyART_OTHER ;
16239 wxString *arg2 = (wxString *) &arg2_defvalue ;
16240 wxSize const &arg3_defvalue = wxDefaultSize ;
16241 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16242 wxBitmap result;
16243 bool temp1 = false ;
16244 bool temp2 = false ;
16245 wxSize temp3 ;
16246 PyObject * obj0 = 0 ;
16247 PyObject * obj1 = 0 ;
16248 PyObject * obj2 = 0 ;
16249 char *kwnames[] = {
16250 (char *) "id",(char *) "client",(char *) "size", NULL
16251 };
16252
16253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16254 {
16255 arg1 = wxString_in_helper(obj0);
16256 if (arg1 == NULL) SWIG_fail;
16257 temp1 = true;
16258 }
16259 if (obj1) {
16260 {
16261 arg2 = wxString_in_helper(obj1);
16262 if (arg2 == NULL) SWIG_fail;
16263 temp2 = true;
16264 }
16265 }
16266 if (obj2) {
16267 {
16268 arg3 = &temp3;
16269 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16270 }
16271 }
16272 {
16273 if (!wxPyCheckForApp()) SWIG_fail;
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16276
16277 wxPyEndAllowThreads(__tstate);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 }
16280 {
16281 wxBitmap * resultptr;
16282 resultptr = new wxBitmap((wxBitmap &)(result));
16283 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16284 }
16285 {
16286 if (temp1)
16287 delete arg1;
16288 }
16289 {
16290 if (temp2)
16291 delete arg2;
16292 }
16293 return resultobj;
16294 fail:
16295 {
16296 if (temp1)
16297 delete arg1;
16298 }
16299 {
16300 if (temp2)
16301 delete arg2;
16302 }
16303 return NULL;
16304 }
16305
16306
16307 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16308 PyObject *resultobj;
16309 wxString *arg1 = 0 ;
16310 wxString const &arg2_defvalue = wxPyART_OTHER ;
16311 wxString *arg2 = (wxString *) &arg2_defvalue ;
16312 wxSize const &arg3_defvalue = wxDefaultSize ;
16313 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16314 wxIcon result;
16315 bool temp1 = false ;
16316 bool temp2 = false ;
16317 wxSize temp3 ;
16318 PyObject * obj0 = 0 ;
16319 PyObject * obj1 = 0 ;
16320 PyObject * obj2 = 0 ;
16321 char *kwnames[] = {
16322 (char *) "id",(char *) "client",(char *) "size", NULL
16323 };
16324
16325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16326 {
16327 arg1 = wxString_in_helper(obj0);
16328 if (arg1 == NULL) SWIG_fail;
16329 temp1 = true;
16330 }
16331 if (obj1) {
16332 {
16333 arg2 = wxString_in_helper(obj1);
16334 if (arg2 == NULL) SWIG_fail;
16335 temp2 = true;
16336 }
16337 }
16338 if (obj2) {
16339 {
16340 arg3 = &temp3;
16341 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16342 }
16343 }
16344 {
16345 if (!wxPyCheckForApp()) SWIG_fail;
16346 PyThreadState* __tstate = wxPyBeginAllowThreads();
16347 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16348
16349 wxPyEndAllowThreads(__tstate);
16350 if (PyErr_Occurred()) SWIG_fail;
16351 }
16352 {
16353 wxIcon * resultptr;
16354 resultptr = new wxIcon((wxIcon &)(result));
16355 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16356 }
16357 {
16358 if (temp1)
16359 delete arg1;
16360 }
16361 {
16362 if (temp2)
16363 delete arg2;
16364 }
16365 return resultobj;
16366 fail:
16367 {
16368 if (temp1)
16369 delete arg1;
16370 }
16371 {
16372 if (temp2)
16373 delete arg2;
16374 }
16375 return NULL;
16376 }
16377
16378
16379 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16380 PyObject *resultobj;
16381 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16382 PyObject * obj0 = 0 ;
16383 char *kwnames[] = {
16384 (char *) "self", NULL
16385 };
16386
16387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16389 if (SWIG_arg_fail(1)) SWIG_fail;
16390 {
16391 PyThreadState* __tstate = wxPyBeginAllowThreads();
16392 wxPyArtProvider_Destroy(arg1);
16393
16394 wxPyEndAllowThreads(__tstate);
16395 if (PyErr_Occurred()) SWIG_fail;
16396 }
16397 Py_INCREF(Py_None); resultobj = Py_None;
16398 return resultobj;
16399 fail:
16400 return NULL;
16401 }
16402
16403
16404 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16405 PyObject *obj;
16406 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16407 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16408 Py_INCREF(obj);
16409 return Py_BuildValue((char *)"");
16410 }
16411 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16412 PyObject *resultobj;
16413 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16414 PyObject * obj0 = 0 ;
16415 char *kwnames[] = {
16416 (char *) "self", NULL
16417 };
16418
16419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16421 if (SWIG_arg_fail(1)) SWIG_fail;
16422 {
16423 PyThreadState* __tstate = wxPyBeginAllowThreads();
16424 delete arg1;
16425
16426 wxPyEndAllowThreads(__tstate);
16427 if (PyErr_Occurred()) SWIG_fail;
16428 }
16429 Py_INCREF(Py_None); resultobj = Py_None;
16430 return resultobj;
16431 fail:
16432 return NULL;
16433 }
16434
16435
16436 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16437 PyObject *resultobj;
16438 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16439 wxConfigBase *result;
16440 PyObject * obj0 = 0 ;
16441 char *kwnames[] = {
16442 (char *) "config", NULL
16443 };
16444
16445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16447 if (SWIG_arg_fail(1)) SWIG_fail;
16448 {
16449 PyThreadState* __tstate = wxPyBeginAllowThreads();
16450 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16451
16452 wxPyEndAllowThreads(__tstate);
16453 if (PyErr_Occurred()) SWIG_fail;
16454 }
16455 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16456 return resultobj;
16457 fail:
16458 return NULL;
16459 }
16460
16461
16462 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16463 PyObject *resultobj;
16464 bool arg1 = (bool) true ;
16465 wxConfigBase *result;
16466 PyObject * obj0 = 0 ;
16467 char *kwnames[] = {
16468 (char *) "createOnDemand", NULL
16469 };
16470
16471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16472 if (obj0) {
16473 {
16474 arg1 = (bool)(SWIG_As_bool(obj0));
16475 if (SWIG_arg_fail(1)) SWIG_fail;
16476 }
16477 }
16478 {
16479 PyThreadState* __tstate = wxPyBeginAllowThreads();
16480 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16481
16482 wxPyEndAllowThreads(__tstate);
16483 if (PyErr_Occurred()) SWIG_fail;
16484 }
16485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16486 return resultobj;
16487 fail:
16488 return NULL;
16489 }
16490
16491
16492 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16493 PyObject *resultobj;
16494 wxConfigBase *result;
16495 char *kwnames[] = {
16496 NULL
16497 };
16498
16499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16500 {
16501 PyThreadState* __tstate = wxPyBeginAllowThreads();
16502 result = (wxConfigBase *)wxConfigBase::Create();
16503
16504 wxPyEndAllowThreads(__tstate);
16505 if (PyErr_Occurred()) SWIG_fail;
16506 }
16507 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16508 return resultobj;
16509 fail:
16510 return NULL;
16511 }
16512
16513
16514 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16515 PyObject *resultobj;
16516 char *kwnames[] = {
16517 NULL
16518 };
16519
16520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16521 {
16522 PyThreadState* __tstate = wxPyBeginAllowThreads();
16523 wxConfigBase::DontCreateOnDemand();
16524
16525 wxPyEndAllowThreads(__tstate);
16526 if (PyErr_Occurred()) SWIG_fail;
16527 }
16528 Py_INCREF(Py_None); resultobj = Py_None;
16529 return resultobj;
16530 fail:
16531 return NULL;
16532 }
16533
16534
16535 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16536 PyObject *resultobj;
16537 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16538 wxString *arg2 = 0 ;
16539 bool temp2 = false ;
16540 PyObject * obj0 = 0 ;
16541 PyObject * obj1 = 0 ;
16542 char *kwnames[] = {
16543 (char *) "self",(char *) "path", NULL
16544 };
16545
16546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16548 if (SWIG_arg_fail(1)) SWIG_fail;
16549 {
16550 arg2 = wxString_in_helper(obj1);
16551 if (arg2 == NULL) SWIG_fail;
16552 temp2 = true;
16553 }
16554 {
16555 PyThreadState* __tstate = wxPyBeginAllowThreads();
16556 (arg1)->SetPath((wxString const &)*arg2);
16557
16558 wxPyEndAllowThreads(__tstate);
16559 if (PyErr_Occurred()) SWIG_fail;
16560 }
16561 Py_INCREF(Py_None); resultobj = Py_None;
16562 {
16563 if (temp2)
16564 delete arg2;
16565 }
16566 return resultobj;
16567 fail:
16568 {
16569 if (temp2)
16570 delete arg2;
16571 }
16572 return NULL;
16573 }
16574
16575
16576 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16577 PyObject *resultobj;
16578 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16579 wxString *result;
16580 PyObject * obj0 = 0 ;
16581 char *kwnames[] = {
16582 (char *) "self", NULL
16583 };
16584
16585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16587 if (SWIG_arg_fail(1)) SWIG_fail;
16588 {
16589 PyThreadState* __tstate = wxPyBeginAllowThreads();
16590 {
16591 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16592 result = (wxString *) &_result_ref;
16593 }
16594
16595 wxPyEndAllowThreads(__tstate);
16596 if (PyErr_Occurred()) SWIG_fail;
16597 }
16598 {
16599 #if wxUSE_UNICODE
16600 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16601 #else
16602 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16603 #endif
16604 }
16605 return resultobj;
16606 fail:
16607 return NULL;
16608 }
16609
16610
16611 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16612 PyObject *resultobj;
16613 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16614 PyObject *result;
16615 PyObject * obj0 = 0 ;
16616 char *kwnames[] = {
16617 (char *) "self", NULL
16618 };
16619
16620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16622 if (SWIG_arg_fail(1)) SWIG_fail;
16623 {
16624 PyThreadState* __tstate = wxPyBeginAllowThreads();
16625 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16626
16627 wxPyEndAllowThreads(__tstate);
16628 if (PyErr_Occurred()) SWIG_fail;
16629 }
16630 resultobj = result;
16631 return resultobj;
16632 fail:
16633 return NULL;
16634 }
16635
16636
16637 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16638 PyObject *resultobj;
16639 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16640 long arg2 ;
16641 PyObject *result;
16642 PyObject * obj0 = 0 ;
16643 PyObject * obj1 = 0 ;
16644 char *kwnames[] = {
16645 (char *) "self",(char *) "index", NULL
16646 };
16647
16648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
16649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16650 if (SWIG_arg_fail(1)) SWIG_fail;
16651 {
16652 arg2 = (long)(SWIG_As_long(obj1));
16653 if (SWIG_arg_fail(2)) SWIG_fail;
16654 }
16655 {
16656 PyThreadState* __tstate = wxPyBeginAllowThreads();
16657 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
16658
16659 wxPyEndAllowThreads(__tstate);
16660 if (PyErr_Occurred()) SWIG_fail;
16661 }
16662 resultobj = result;
16663 return resultobj;
16664 fail:
16665 return NULL;
16666 }
16667
16668
16669 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16670 PyObject *resultobj;
16671 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16672 PyObject *result;
16673 PyObject * obj0 = 0 ;
16674 char *kwnames[] = {
16675 (char *) "self", NULL
16676 };
16677
16678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
16679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16680 if (SWIG_arg_fail(1)) SWIG_fail;
16681 {
16682 PyThreadState* __tstate = wxPyBeginAllowThreads();
16683 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
16684
16685 wxPyEndAllowThreads(__tstate);
16686 if (PyErr_Occurred()) SWIG_fail;
16687 }
16688 resultobj = result;
16689 return resultobj;
16690 fail:
16691 return NULL;
16692 }
16693
16694
16695 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16696 PyObject *resultobj;
16697 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16698 long arg2 ;
16699 PyObject *result;
16700 PyObject * obj0 = 0 ;
16701 PyObject * obj1 = 0 ;
16702 char *kwnames[] = {
16703 (char *) "self",(char *) "index", NULL
16704 };
16705
16706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
16707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16708 if (SWIG_arg_fail(1)) SWIG_fail;
16709 {
16710 arg2 = (long)(SWIG_As_long(obj1));
16711 if (SWIG_arg_fail(2)) SWIG_fail;
16712 }
16713 {
16714 PyThreadState* __tstate = wxPyBeginAllowThreads();
16715 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
16716
16717 wxPyEndAllowThreads(__tstate);
16718 if (PyErr_Occurred()) SWIG_fail;
16719 }
16720 resultobj = result;
16721 return resultobj;
16722 fail:
16723 return NULL;
16724 }
16725
16726
16727 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
16728 PyObject *resultobj;
16729 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16730 bool arg2 = (bool) false ;
16731 size_t result;
16732 PyObject * obj0 = 0 ;
16733 PyObject * obj1 = 0 ;
16734 char *kwnames[] = {
16735 (char *) "self",(char *) "recursive", NULL
16736 };
16737
16738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
16739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16740 if (SWIG_arg_fail(1)) SWIG_fail;
16741 if (obj1) {
16742 {
16743 arg2 = (bool)(SWIG_As_bool(obj1));
16744 if (SWIG_arg_fail(2)) SWIG_fail;
16745 }
16746 }
16747 {
16748 PyThreadState* __tstate = wxPyBeginAllowThreads();
16749 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
16750
16751 wxPyEndAllowThreads(__tstate);
16752 if (PyErr_Occurred()) SWIG_fail;
16753 }
16754 {
16755 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16756 }
16757 return resultobj;
16758 fail:
16759 return NULL;
16760 }
16761
16762
16763 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
16764 PyObject *resultobj;
16765 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16766 bool arg2 = (bool) false ;
16767 size_t result;
16768 PyObject * obj0 = 0 ;
16769 PyObject * obj1 = 0 ;
16770 char *kwnames[] = {
16771 (char *) "self",(char *) "recursive", NULL
16772 };
16773
16774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
16775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16776 if (SWIG_arg_fail(1)) SWIG_fail;
16777 if (obj1) {
16778 {
16779 arg2 = (bool)(SWIG_As_bool(obj1));
16780 if (SWIG_arg_fail(2)) SWIG_fail;
16781 }
16782 }
16783 {
16784 PyThreadState* __tstate = wxPyBeginAllowThreads();
16785 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
16786
16787 wxPyEndAllowThreads(__tstate);
16788 if (PyErr_Occurred()) SWIG_fail;
16789 }
16790 {
16791 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
16792 }
16793 return resultobj;
16794 fail:
16795 return NULL;
16796 }
16797
16798
16799 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16800 PyObject *resultobj;
16801 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16802 wxString *arg2 = 0 ;
16803 bool result;
16804 bool temp2 = false ;
16805 PyObject * obj0 = 0 ;
16806 PyObject * obj1 = 0 ;
16807 char *kwnames[] = {
16808 (char *) "self",(char *) "name", NULL
16809 };
16810
16811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
16812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16813 if (SWIG_arg_fail(1)) SWIG_fail;
16814 {
16815 arg2 = wxString_in_helper(obj1);
16816 if (arg2 == NULL) SWIG_fail;
16817 temp2 = true;
16818 }
16819 {
16820 PyThreadState* __tstate = wxPyBeginAllowThreads();
16821 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
16822
16823 wxPyEndAllowThreads(__tstate);
16824 if (PyErr_Occurred()) SWIG_fail;
16825 }
16826 {
16827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16828 }
16829 {
16830 if (temp2)
16831 delete arg2;
16832 }
16833 return resultobj;
16834 fail:
16835 {
16836 if (temp2)
16837 delete arg2;
16838 }
16839 return NULL;
16840 }
16841
16842
16843 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
16844 PyObject *resultobj;
16845 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16846 wxString *arg2 = 0 ;
16847 bool result;
16848 bool temp2 = false ;
16849 PyObject * obj0 = 0 ;
16850 PyObject * obj1 = 0 ;
16851 char *kwnames[] = {
16852 (char *) "self",(char *) "name", NULL
16853 };
16854
16855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
16856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16857 if (SWIG_arg_fail(1)) SWIG_fail;
16858 {
16859 arg2 = wxString_in_helper(obj1);
16860 if (arg2 == NULL) SWIG_fail;
16861 temp2 = true;
16862 }
16863 {
16864 PyThreadState* __tstate = wxPyBeginAllowThreads();
16865 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
16866
16867 wxPyEndAllowThreads(__tstate);
16868 if (PyErr_Occurred()) SWIG_fail;
16869 }
16870 {
16871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16872 }
16873 {
16874 if (temp2)
16875 delete arg2;
16876 }
16877 return resultobj;
16878 fail:
16879 {
16880 if (temp2)
16881 delete arg2;
16882 }
16883 return NULL;
16884 }
16885
16886
16887 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
16888 PyObject *resultobj;
16889 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16890 wxString *arg2 = 0 ;
16891 bool result;
16892 bool temp2 = false ;
16893 PyObject * obj0 = 0 ;
16894 PyObject * obj1 = 0 ;
16895 char *kwnames[] = {
16896 (char *) "self",(char *) "name", NULL
16897 };
16898
16899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
16900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16901 if (SWIG_arg_fail(1)) SWIG_fail;
16902 {
16903 arg2 = wxString_in_helper(obj1);
16904 if (arg2 == NULL) SWIG_fail;
16905 temp2 = true;
16906 }
16907 {
16908 PyThreadState* __tstate = wxPyBeginAllowThreads();
16909 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
16910
16911 wxPyEndAllowThreads(__tstate);
16912 if (PyErr_Occurred()) SWIG_fail;
16913 }
16914 {
16915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16916 }
16917 {
16918 if (temp2)
16919 delete arg2;
16920 }
16921 return resultobj;
16922 fail:
16923 {
16924 if (temp2)
16925 delete arg2;
16926 }
16927 return NULL;
16928 }
16929
16930
16931 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
16932 PyObject *resultobj;
16933 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16934 wxString *arg2 = 0 ;
16935 wxConfigBase::EntryType result;
16936 bool temp2 = false ;
16937 PyObject * obj0 = 0 ;
16938 PyObject * obj1 = 0 ;
16939 char *kwnames[] = {
16940 (char *) "self",(char *) "name", NULL
16941 };
16942
16943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
16944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16945 if (SWIG_arg_fail(1)) SWIG_fail;
16946 {
16947 arg2 = wxString_in_helper(obj1);
16948 if (arg2 == NULL) SWIG_fail;
16949 temp2 = true;
16950 }
16951 {
16952 PyThreadState* __tstate = wxPyBeginAllowThreads();
16953 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
16954
16955 wxPyEndAllowThreads(__tstate);
16956 if (PyErr_Occurred()) SWIG_fail;
16957 }
16958 resultobj = SWIG_From_int((result));
16959 {
16960 if (temp2)
16961 delete arg2;
16962 }
16963 return resultobj;
16964 fail:
16965 {
16966 if (temp2)
16967 delete arg2;
16968 }
16969 return NULL;
16970 }
16971
16972
16973 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
16974 PyObject *resultobj;
16975 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16976 wxString *arg2 = 0 ;
16977 wxString const &arg3_defvalue = wxPyEmptyString ;
16978 wxString *arg3 = (wxString *) &arg3_defvalue ;
16979 wxString result;
16980 bool temp2 = false ;
16981 bool temp3 = false ;
16982 PyObject * obj0 = 0 ;
16983 PyObject * obj1 = 0 ;
16984 PyObject * obj2 = 0 ;
16985 char *kwnames[] = {
16986 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
16987 };
16988
16989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
16990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16991 if (SWIG_arg_fail(1)) SWIG_fail;
16992 {
16993 arg2 = wxString_in_helper(obj1);
16994 if (arg2 == NULL) SWIG_fail;
16995 temp2 = true;
16996 }
16997 if (obj2) {
16998 {
16999 arg3 = wxString_in_helper(obj2);
17000 if (arg3 == NULL) SWIG_fail;
17001 temp3 = true;
17002 }
17003 }
17004 {
17005 PyThreadState* __tstate = wxPyBeginAllowThreads();
17006 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17007
17008 wxPyEndAllowThreads(__tstate);
17009 if (PyErr_Occurred()) SWIG_fail;
17010 }
17011 {
17012 #if wxUSE_UNICODE
17013 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17014 #else
17015 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17016 #endif
17017 }
17018 {
17019 if (temp2)
17020 delete arg2;
17021 }
17022 {
17023 if (temp3)
17024 delete arg3;
17025 }
17026 return resultobj;
17027 fail:
17028 {
17029 if (temp2)
17030 delete arg2;
17031 }
17032 {
17033 if (temp3)
17034 delete arg3;
17035 }
17036 return NULL;
17037 }
17038
17039
17040 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17041 PyObject *resultobj;
17042 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17043 wxString *arg2 = 0 ;
17044 long arg3 = (long) 0 ;
17045 long result;
17046 bool temp2 = false ;
17047 PyObject * obj0 = 0 ;
17048 PyObject * obj1 = 0 ;
17049 PyObject * obj2 = 0 ;
17050 char *kwnames[] = {
17051 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17052 };
17053
17054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17056 if (SWIG_arg_fail(1)) SWIG_fail;
17057 {
17058 arg2 = wxString_in_helper(obj1);
17059 if (arg2 == NULL) SWIG_fail;
17060 temp2 = true;
17061 }
17062 if (obj2) {
17063 {
17064 arg3 = (long)(SWIG_As_long(obj2));
17065 if (SWIG_arg_fail(3)) SWIG_fail;
17066 }
17067 }
17068 {
17069 PyThreadState* __tstate = wxPyBeginAllowThreads();
17070 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17071
17072 wxPyEndAllowThreads(__tstate);
17073 if (PyErr_Occurred()) SWIG_fail;
17074 }
17075 {
17076 resultobj = SWIG_From_long((long)(result));
17077 }
17078 {
17079 if (temp2)
17080 delete arg2;
17081 }
17082 return resultobj;
17083 fail:
17084 {
17085 if (temp2)
17086 delete arg2;
17087 }
17088 return NULL;
17089 }
17090
17091
17092 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17093 PyObject *resultobj;
17094 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17095 wxString *arg2 = 0 ;
17096 double arg3 = (double) 0.0 ;
17097 double result;
17098 bool temp2 = false ;
17099 PyObject * obj0 = 0 ;
17100 PyObject * obj1 = 0 ;
17101 PyObject * obj2 = 0 ;
17102 char *kwnames[] = {
17103 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17104 };
17105
17106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17108 if (SWIG_arg_fail(1)) SWIG_fail;
17109 {
17110 arg2 = wxString_in_helper(obj1);
17111 if (arg2 == NULL) SWIG_fail;
17112 temp2 = true;
17113 }
17114 if (obj2) {
17115 {
17116 arg3 = (double)(SWIG_As_double(obj2));
17117 if (SWIG_arg_fail(3)) SWIG_fail;
17118 }
17119 }
17120 {
17121 PyThreadState* __tstate = wxPyBeginAllowThreads();
17122 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17123
17124 wxPyEndAllowThreads(__tstate);
17125 if (PyErr_Occurred()) SWIG_fail;
17126 }
17127 {
17128 resultobj = SWIG_From_double((double)(result));
17129 }
17130 {
17131 if (temp2)
17132 delete arg2;
17133 }
17134 return resultobj;
17135 fail:
17136 {
17137 if (temp2)
17138 delete arg2;
17139 }
17140 return NULL;
17141 }
17142
17143
17144 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17145 PyObject *resultobj;
17146 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17147 wxString *arg2 = 0 ;
17148 bool arg3 = (bool) false ;
17149 bool result;
17150 bool temp2 = false ;
17151 PyObject * obj0 = 0 ;
17152 PyObject * obj1 = 0 ;
17153 PyObject * obj2 = 0 ;
17154 char *kwnames[] = {
17155 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17156 };
17157
17158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17160 if (SWIG_arg_fail(1)) SWIG_fail;
17161 {
17162 arg2 = wxString_in_helper(obj1);
17163 if (arg2 == NULL) SWIG_fail;
17164 temp2 = true;
17165 }
17166 if (obj2) {
17167 {
17168 arg3 = (bool)(SWIG_As_bool(obj2));
17169 if (SWIG_arg_fail(3)) SWIG_fail;
17170 }
17171 }
17172 {
17173 PyThreadState* __tstate = wxPyBeginAllowThreads();
17174 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17175
17176 wxPyEndAllowThreads(__tstate);
17177 if (PyErr_Occurred()) SWIG_fail;
17178 }
17179 {
17180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17181 }
17182 {
17183 if (temp2)
17184 delete arg2;
17185 }
17186 return resultobj;
17187 fail:
17188 {
17189 if (temp2)
17190 delete arg2;
17191 }
17192 return NULL;
17193 }
17194
17195
17196 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17197 PyObject *resultobj;
17198 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17199 wxString *arg2 = 0 ;
17200 wxString *arg3 = 0 ;
17201 bool result;
17202 bool temp2 = false ;
17203 bool temp3 = false ;
17204 PyObject * obj0 = 0 ;
17205 PyObject * obj1 = 0 ;
17206 PyObject * obj2 = 0 ;
17207 char *kwnames[] = {
17208 (char *) "self",(char *) "key",(char *) "value", NULL
17209 };
17210
17211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17213 if (SWIG_arg_fail(1)) SWIG_fail;
17214 {
17215 arg2 = wxString_in_helper(obj1);
17216 if (arg2 == NULL) SWIG_fail;
17217 temp2 = true;
17218 }
17219 {
17220 arg3 = wxString_in_helper(obj2);
17221 if (arg3 == NULL) SWIG_fail;
17222 temp3 = true;
17223 }
17224 {
17225 PyThreadState* __tstate = wxPyBeginAllowThreads();
17226 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17227
17228 wxPyEndAllowThreads(__tstate);
17229 if (PyErr_Occurred()) SWIG_fail;
17230 }
17231 {
17232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17233 }
17234 {
17235 if (temp2)
17236 delete arg2;
17237 }
17238 {
17239 if (temp3)
17240 delete arg3;
17241 }
17242 return resultobj;
17243 fail:
17244 {
17245 if (temp2)
17246 delete arg2;
17247 }
17248 {
17249 if (temp3)
17250 delete arg3;
17251 }
17252 return NULL;
17253 }
17254
17255
17256 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17257 PyObject *resultobj;
17258 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17259 wxString *arg2 = 0 ;
17260 long arg3 ;
17261 bool result;
17262 bool temp2 = false ;
17263 PyObject * obj0 = 0 ;
17264 PyObject * obj1 = 0 ;
17265 PyObject * obj2 = 0 ;
17266 char *kwnames[] = {
17267 (char *) "self",(char *) "key",(char *) "value", NULL
17268 };
17269
17270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17272 if (SWIG_arg_fail(1)) SWIG_fail;
17273 {
17274 arg2 = wxString_in_helper(obj1);
17275 if (arg2 == NULL) SWIG_fail;
17276 temp2 = true;
17277 }
17278 {
17279 arg3 = (long)(SWIG_As_long(obj2));
17280 if (SWIG_arg_fail(3)) SWIG_fail;
17281 }
17282 {
17283 PyThreadState* __tstate = wxPyBeginAllowThreads();
17284 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17285
17286 wxPyEndAllowThreads(__tstate);
17287 if (PyErr_Occurred()) SWIG_fail;
17288 }
17289 {
17290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17291 }
17292 {
17293 if (temp2)
17294 delete arg2;
17295 }
17296 return resultobj;
17297 fail:
17298 {
17299 if (temp2)
17300 delete arg2;
17301 }
17302 return NULL;
17303 }
17304
17305
17306 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17307 PyObject *resultobj;
17308 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17309 wxString *arg2 = 0 ;
17310 double arg3 ;
17311 bool result;
17312 bool temp2 = false ;
17313 PyObject * obj0 = 0 ;
17314 PyObject * obj1 = 0 ;
17315 PyObject * obj2 = 0 ;
17316 char *kwnames[] = {
17317 (char *) "self",(char *) "key",(char *) "value", NULL
17318 };
17319
17320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17322 if (SWIG_arg_fail(1)) SWIG_fail;
17323 {
17324 arg2 = wxString_in_helper(obj1);
17325 if (arg2 == NULL) SWIG_fail;
17326 temp2 = true;
17327 }
17328 {
17329 arg3 = (double)(SWIG_As_double(obj2));
17330 if (SWIG_arg_fail(3)) SWIG_fail;
17331 }
17332 {
17333 PyThreadState* __tstate = wxPyBeginAllowThreads();
17334 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17335
17336 wxPyEndAllowThreads(__tstate);
17337 if (PyErr_Occurred()) SWIG_fail;
17338 }
17339 {
17340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17341 }
17342 {
17343 if (temp2)
17344 delete arg2;
17345 }
17346 return resultobj;
17347 fail:
17348 {
17349 if (temp2)
17350 delete arg2;
17351 }
17352 return NULL;
17353 }
17354
17355
17356 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17357 PyObject *resultobj;
17358 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17359 wxString *arg2 = 0 ;
17360 bool arg3 ;
17361 bool result;
17362 bool temp2 = false ;
17363 PyObject * obj0 = 0 ;
17364 PyObject * obj1 = 0 ;
17365 PyObject * obj2 = 0 ;
17366 char *kwnames[] = {
17367 (char *) "self",(char *) "key",(char *) "value", NULL
17368 };
17369
17370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17372 if (SWIG_arg_fail(1)) SWIG_fail;
17373 {
17374 arg2 = wxString_in_helper(obj1);
17375 if (arg2 == NULL) SWIG_fail;
17376 temp2 = true;
17377 }
17378 {
17379 arg3 = (bool)(SWIG_As_bool(obj2));
17380 if (SWIG_arg_fail(3)) SWIG_fail;
17381 }
17382 {
17383 PyThreadState* __tstate = wxPyBeginAllowThreads();
17384 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17385
17386 wxPyEndAllowThreads(__tstate);
17387 if (PyErr_Occurred()) SWIG_fail;
17388 }
17389 {
17390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17391 }
17392 {
17393 if (temp2)
17394 delete arg2;
17395 }
17396 return resultobj;
17397 fail:
17398 {
17399 if (temp2)
17400 delete arg2;
17401 }
17402 return NULL;
17403 }
17404
17405
17406 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17407 PyObject *resultobj;
17408 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17409 bool arg2 = (bool) false ;
17410 bool result;
17411 PyObject * obj0 = 0 ;
17412 PyObject * obj1 = 0 ;
17413 char *kwnames[] = {
17414 (char *) "self",(char *) "currentOnly", NULL
17415 };
17416
17417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17419 if (SWIG_arg_fail(1)) SWIG_fail;
17420 if (obj1) {
17421 {
17422 arg2 = (bool)(SWIG_As_bool(obj1));
17423 if (SWIG_arg_fail(2)) SWIG_fail;
17424 }
17425 }
17426 {
17427 PyThreadState* __tstate = wxPyBeginAllowThreads();
17428 result = (bool)(arg1)->Flush(arg2);
17429
17430 wxPyEndAllowThreads(__tstate);
17431 if (PyErr_Occurred()) SWIG_fail;
17432 }
17433 {
17434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17435 }
17436 return resultobj;
17437 fail:
17438 return NULL;
17439 }
17440
17441
17442 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17443 PyObject *resultobj;
17444 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17445 wxString *arg2 = 0 ;
17446 wxString *arg3 = 0 ;
17447 bool result;
17448 bool temp2 = false ;
17449 bool temp3 = false ;
17450 PyObject * obj0 = 0 ;
17451 PyObject * obj1 = 0 ;
17452 PyObject * obj2 = 0 ;
17453 char *kwnames[] = {
17454 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17455 };
17456
17457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17459 if (SWIG_arg_fail(1)) SWIG_fail;
17460 {
17461 arg2 = wxString_in_helper(obj1);
17462 if (arg2 == NULL) SWIG_fail;
17463 temp2 = true;
17464 }
17465 {
17466 arg3 = wxString_in_helper(obj2);
17467 if (arg3 == NULL) SWIG_fail;
17468 temp3 = true;
17469 }
17470 {
17471 PyThreadState* __tstate = wxPyBeginAllowThreads();
17472 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17473
17474 wxPyEndAllowThreads(__tstate);
17475 if (PyErr_Occurred()) SWIG_fail;
17476 }
17477 {
17478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17479 }
17480 {
17481 if (temp2)
17482 delete arg2;
17483 }
17484 {
17485 if (temp3)
17486 delete arg3;
17487 }
17488 return resultobj;
17489 fail:
17490 {
17491 if (temp2)
17492 delete arg2;
17493 }
17494 {
17495 if (temp3)
17496 delete arg3;
17497 }
17498 return NULL;
17499 }
17500
17501
17502 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17503 PyObject *resultobj;
17504 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17505 wxString *arg2 = 0 ;
17506 wxString *arg3 = 0 ;
17507 bool result;
17508 bool temp2 = false ;
17509 bool temp3 = false ;
17510 PyObject * obj0 = 0 ;
17511 PyObject * obj1 = 0 ;
17512 PyObject * obj2 = 0 ;
17513 char *kwnames[] = {
17514 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17515 };
17516
17517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17519 if (SWIG_arg_fail(1)) SWIG_fail;
17520 {
17521 arg2 = wxString_in_helper(obj1);
17522 if (arg2 == NULL) SWIG_fail;
17523 temp2 = true;
17524 }
17525 {
17526 arg3 = wxString_in_helper(obj2);
17527 if (arg3 == NULL) SWIG_fail;
17528 temp3 = true;
17529 }
17530 {
17531 PyThreadState* __tstate = wxPyBeginAllowThreads();
17532 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17533
17534 wxPyEndAllowThreads(__tstate);
17535 if (PyErr_Occurred()) SWIG_fail;
17536 }
17537 {
17538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17539 }
17540 {
17541 if (temp2)
17542 delete arg2;
17543 }
17544 {
17545 if (temp3)
17546 delete arg3;
17547 }
17548 return resultobj;
17549 fail:
17550 {
17551 if (temp2)
17552 delete arg2;
17553 }
17554 {
17555 if (temp3)
17556 delete arg3;
17557 }
17558 return NULL;
17559 }
17560
17561
17562 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17563 PyObject *resultobj;
17564 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17565 wxString *arg2 = 0 ;
17566 bool arg3 = (bool) true ;
17567 bool result;
17568 bool temp2 = false ;
17569 PyObject * obj0 = 0 ;
17570 PyObject * obj1 = 0 ;
17571 PyObject * obj2 = 0 ;
17572 char *kwnames[] = {
17573 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17574 };
17575
17576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17578 if (SWIG_arg_fail(1)) SWIG_fail;
17579 {
17580 arg2 = wxString_in_helper(obj1);
17581 if (arg2 == NULL) SWIG_fail;
17582 temp2 = true;
17583 }
17584 if (obj2) {
17585 {
17586 arg3 = (bool)(SWIG_As_bool(obj2));
17587 if (SWIG_arg_fail(3)) SWIG_fail;
17588 }
17589 }
17590 {
17591 PyThreadState* __tstate = wxPyBeginAllowThreads();
17592 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17593
17594 wxPyEndAllowThreads(__tstate);
17595 if (PyErr_Occurred()) SWIG_fail;
17596 }
17597 {
17598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17599 }
17600 {
17601 if (temp2)
17602 delete arg2;
17603 }
17604 return resultobj;
17605 fail:
17606 {
17607 if (temp2)
17608 delete arg2;
17609 }
17610 return NULL;
17611 }
17612
17613
17614 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17615 PyObject *resultobj;
17616 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17617 wxString *arg2 = 0 ;
17618 bool result;
17619 bool temp2 = false ;
17620 PyObject * obj0 = 0 ;
17621 PyObject * obj1 = 0 ;
17622 char *kwnames[] = {
17623 (char *) "self",(char *) "key", NULL
17624 };
17625
17626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17628 if (SWIG_arg_fail(1)) SWIG_fail;
17629 {
17630 arg2 = wxString_in_helper(obj1);
17631 if (arg2 == NULL) SWIG_fail;
17632 temp2 = true;
17633 }
17634 {
17635 PyThreadState* __tstate = wxPyBeginAllowThreads();
17636 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17637
17638 wxPyEndAllowThreads(__tstate);
17639 if (PyErr_Occurred()) SWIG_fail;
17640 }
17641 {
17642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17643 }
17644 {
17645 if (temp2)
17646 delete arg2;
17647 }
17648 return resultobj;
17649 fail:
17650 {
17651 if (temp2)
17652 delete arg2;
17653 }
17654 return NULL;
17655 }
17656
17657
17658 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
17659 PyObject *resultobj;
17660 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17661 bool result;
17662 PyObject * obj0 = 0 ;
17663 char *kwnames[] = {
17664 (char *) "self", NULL
17665 };
17666
17667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
17668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17669 if (SWIG_arg_fail(1)) SWIG_fail;
17670 {
17671 PyThreadState* __tstate = wxPyBeginAllowThreads();
17672 result = (bool)(arg1)->DeleteAll();
17673
17674 wxPyEndAllowThreads(__tstate);
17675 if (PyErr_Occurred()) SWIG_fail;
17676 }
17677 {
17678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17679 }
17680 return resultobj;
17681 fail:
17682 return NULL;
17683 }
17684
17685
17686 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17687 PyObject *resultobj;
17688 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17689 bool arg2 = (bool) true ;
17690 PyObject * obj0 = 0 ;
17691 PyObject * obj1 = 0 ;
17692 char *kwnames[] = {
17693 (char *) "self",(char *) "doIt", NULL
17694 };
17695
17696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17698 if (SWIG_arg_fail(1)) SWIG_fail;
17699 if (obj1) {
17700 {
17701 arg2 = (bool)(SWIG_As_bool(obj1));
17702 if (SWIG_arg_fail(2)) SWIG_fail;
17703 }
17704 }
17705 {
17706 PyThreadState* __tstate = wxPyBeginAllowThreads();
17707 (arg1)->SetExpandEnvVars(arg2);
17708
17709 wxPyEndAllowThreads(__tstate);
17710 if (PyErr_Occurred()) SWIG_fail;
17711 }
17712 Py_INCREF(Py_None); resultobj = Py_None;
17713 return resultobj;
17714 fail:
17715 return NULL;
17716 }
17717
17718
17719 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17720 PyObject *resultobj;
17721 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17722 bool result;
17723 PyObject * obj0 = 0 ;
17724 char *kwnames[] = {
17725 (char *) "self", NULL
17726 };
17727
17728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
17729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17730 if (SWIG_arg_fail(1)) SWIG_fail;
17731 {
17732 PyThreadState* __tstate = wxPyBeginAllowThreads();
17733 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
17734
17735 wxPyEndAllowThreads(__tstate);
17736 if (PyErr_Occurred()) SWIG_fail;
17737 }
17738 {
17739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17740 }
17741 return resultobj;
17742 fail:
17743 return NULL;
17744 }
17745
17746
17747 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17748 PyObject *resultobj;
17749 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17750 bool arg2 = (bool) true ;
17751 PyObject * obj0 = 0 ;
17752 PyObject * obj1 = 0 ;
17753 char *kwnames[] = {
17754 (char *) "self",(char *) "doIt", NULL
17755 };
17756
17757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
17758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17759 if (SWIG_arg_fail(1)) SWIG_fail;
17760 if (obj1) {
17761 {
17762 arg2 = (bool)(SWIG_As_bool(obj1));
17763 if (SWIG_arg_fail(2)) SWIG_fail;
17764 }
17765 }
17766 {
17767 PyThreadState* __tstate = wxPyBeginAllowThreads();
17768 (arg1)->SetRecordDefaults(arg2);
17769
17770 wxPyEndAllowThreads(__tstate);
17771 if (PyErr_Occurred()) SWIG_fail;
17772 }
17773 Py_INCREF(Py_None); resultobj = Py_None;
17774 return resultobj;
17775 fail:
17776 return NULL;
17777 }
17778
17779
17780 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
17781 PyObject *resultobj;
17782 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17783 bool result;
17784 PyObject * obj0 = 0 ;
17785 char *kwnames[] = {
17786 (char *) "self", NULL
17787 };
17788
17789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
17790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17791 if (SWIG_arg_fail(1)) SWIG_fail;
17792 {
17793 PyThreadState* __tstate = wxPyBeginAllowThreads();
17794 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
17795
17796 wxPyEndAllowThreads(__tstate);
17797 if (PyErr_Occurred()) SWIG_fail;
17798 }
17799 {
17800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17801 }
17802 return resultobj;
17803 fail:
17804 return NULL;
17805 }
17806
17807
17808 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
17809 PyObject *resultobj;
17810 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17811 wxString *arg2 = 0 ;
17812 wxString result;
17813 bool temp2 = false ;
17814 PyObject * obj0 = 0 ;
17815 PyObject * obj1 = 0 ;
17816 char *kwnames[] = {
17817 (char *) "self",(char *) "str", NULL
17818 };
17819
17820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
17821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17822 if (SWIG_arg_fail(1)) SWIG_fail;
17823 {
17824 arg2 = wxString_in_helper(obj1);
17825 if (arg2 == NULL) SWIG_fail;
17826 temp2 = true;
17827 }
17828 {
17829 PyThreadState* __tstate = wxPyBeginAllowThreads();
17830 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
17831
17832 wxPyEndAllowThreads(__tstate);
17833 if (PyErr_Occurred()) SWIG_fail;
17834 }
17835 {
17836 #if wxUSE_UNICODE
17837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17838 #else
17839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17840 #endif
17841 }
17842 {
17843 if (temp2)
17844 delete arg2;
17845 }
17846 return resultobj;
17847 fail:
17848 {
17849 if (temp2)
17850 delete arg2;
17851 }
17852 return NULL;
17853 }
17854
17855
17856 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
17857 PyObject *resultobj;
17858 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17859 wxString result;
17860 PyObject * obj0 = 0 ;
17861 char *kwnames[] = {
17862 (char *) "self", NULL
17863 };
17864
17865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
17866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17867 if (SWIG_arg_fail(1)) SWIG_fail;
17868 {
17869 PyThreadState* __tstate = wxPyBeginAllowThreads();
17870 result = ((wxConfigBase const *)arg1)->GetAppName();
17871
17872 wxPyEndAllowThreads(__tstate);
17873 if (PyErr_Occurred()) SWIG_fail;
17874 }
17875 {
17876 #if wxUSE_UNICODE
17877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17878 #else
17879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17880 #endif
17881 }
17882 return resultobj;
17883 fail:
17884 return NULL;
17885 }
17886
17887
17888 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
17889 PyObject *resultobj;
17890 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17891 wxString result;
17892 PyObject * obj0 = 0 ;
17893 char *kwnames[] = {
17894 (char *) "self", NULL
17895 };
17896
17897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
17898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17899 if (SWIG_arg_fail(1)) SWIG_fail;
17900 {
17901 PyThreadState* __tstate = wxPyBeginAllowThreads();
17902 result = ((wxConfigBase const *)arg1)->GetVendorName();
17903
17904 wxPyEndAllowThreads(__tstate);
17905 if (PyErr_Occurred()) SWIG_fail;
17906 }
17907 {
17908 #if wxUSE_UNICODE
17909 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17910 #else
17911 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17912 #endif
17913 }
17914 return resultobj;
17915 fail:
17916 return NULL;
17917 }
17918
17919
17920 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
17921 PyObject *resultobj;
17922 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17923 wxString *arg2 = 0 ;
17924 bool temp2 = false ;
17925 PyObject * obj0 = 0 ;
17926 PyObject * obj1 = 0 ;
17927 char *kwnames[] = {
17928 (char *) "self",(char *) "appName", NULL
17929 };
17930
17931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
17932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17933 if (SWIG_arg_fail(1)) SWIG_fail;
17934 {
17935 arg2 = wxString_in_helper(obj1);
17936 if (arg2 == NULL) SWIG_fail;
17937 temp2 = true;
17938 }
17939 {
17940 PyThreadState* __tstate = wxPyBeginAllowThreads();
17941 (arg1)->SetAppName((wxString const &)*arg2);
17942
17943 wxPyEndAllowThreads(__tstate);
17944 if (PyErr_Occurred()) SWIG_fail;
17945 }
17946 Py_INCREF(Py_None); resultobj = Py_None;
17947 {
17948 if (temp2)
17949 delete arg2;
17950 }
17951 return resultobj;
17952 fail:
17953 {
17954 if (temp2)
17955 delete arg2;
17956 }
17957 return NULL;
17958 }
17959
17960
17961 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
17962 PyObject *resultobj;
17963 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17964 wxString *arg2 = 0 ;
17965 bool temp2 = false ;
17966 PyObject * obj0 = 0 ;
17967 PyObject * obj1 = 0 ;
17968 char *kwnames[] = {
17969 (char *) "self",(char *) "vendorName", NULL
17970 };
17971
17972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
17973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17974 if (SWIG_arg_fail(1)) SWIG_fail;
17975 {
17976 arg2 = wxString_in_helper(obj1);
17977 if (arg2 == NULL) SWIG_fail;
17978 temp2 = true;
17979 }
17980 {
17981 PyThreadState* __tstate = wxPyBeginAllowThreads();
17982 (arg1)->SetVendorName((wxString const &)*arg2);
17983
17984 wxPyEndAllowThreads(__tstate);
17985 if (PyErr_Occurred()) SWIG_fail;
17986 }
17987 Py_INCREF(Py_None); resultobj = Py_None;
17988 {
17989 if (temp2)
17990 delete arg2;
17991 }
17992 return resultobj;
17993 fail:
17994 {
17995 if (temp2)
17996 delete arg2;
17997 }
17998 return NULL;
17999 }
18000
18001
18002 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18003 PyObject *resultobj;
18004 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18005 long arg2 ;
18006 PyObject * obj0 = 0 ;
18007 PyObject * obj1 = 0 ;
18008 char *kwnames[] = {
18009 (char *) "self",(char *) "style", NULL
18010 };
18011
18012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18014 if (SWIG_arg_fail(1)) SWIG_fail;
18015 {
18016 arg2 = (long)(SWIG_As_long(obj1));
18017 if (SWIG_arg_fail(2)) SWIG_fail;
18018 }
18019 {
18020 PyThreadState* __tstate = wxPyBeginAllowThreads();
18021 (arg1)->SetStyle(arg2);
18022
18023 wxPyEndAllowThreads(__tstate);
18024 if (PyErr_Occurred()) SWIG_fail;
18025 }
18026 Py_INCREF(Py_None); resultobj = Py_None;
18027 return resultobj;
18028 fail:
18029 return NULL;
18030 }
18031
18032
18033 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18034 PyObject *resultobj;
18035 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18036 long result;
18037 PyObject * obj0 = 0 ;
18038 char *kwnames[] = {
18039 (char *) "self", NULL
18040 };
18041
18042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18044 if (SWIG_arg_fail(1)) SWIG_fail;
18045 {
18046 PyThreadState* __tstate = wxPyBeginAllowThreads();
18047 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18048
18049 wxPyEndAllowThreads(__tstate);
18050 if (PyErr_Occurred()) SWIG_fail;
18051 }
18052 {
18053 resultobj = SWIG_From_long((long)(result));
18054 }
18055 return resultobj;
18056 fail:
18057 return NULL;
18058 }
18059
18060
18061 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18062 PyObject *obj;
18063 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18064 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18065 Py_INCREF(obj);
18066 return Py_BuildValue((char *)"");
18067 }
18068 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18069 PyObject *resultobj;
18070 wxString const &arg1_defvalue = wxPyEmptyString ;
18071 wxString *arg1 = (wxString *) &arg1_defvalue ;
18072 wxString const &arg2_defvalue = wxPyEmptyString ;
18073 wxString *arg2 = (wxString *) &arg2_defvalue ;
18074 wxString const &arg3_defvalue = wxPyEmptyString ;
18075 wxString *arg3 = (wxString *) &arg3_defvalue ;
18076 wxString const &arg4_defvalue = wxPyEmptyString ;
18077 wxString *arg4 = (wxString *) &arg4_defvalue ;
18078 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18079 wxConfig *result;
18080 bool temp1 = false ;
18081 bool temp2 = false ;
18082 bool temp3 = false ;
18083 bool temp4 = false ;
18084 PyObject * obj0 = 0 ;
18085 PyObject * obj1 = 0 ;
18086 PyObject * obj2 = 0 ;
18087 PyObject * obj3 = 0 ;
18088 PyObject * obj4 = 0 ;
18089 char *kwnames[] = {
18090 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18091 };
18092
18093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18094 if (obj0) {
18095 {
18096 arg1 = wxString_in_helper(obj0);
18097 if (arg1 == NULL) SWIG_fail;
18098 temp1 = true;
18099 }
18100 }
18101 if (obj1) {
18102 {
18103 arg2 = wxString_in_helper(obj1);
18104 if (arg2 == NULL) SWIG_fail;
18105 temp2 = true;
18106 }
18107 }
18108 if (obj2) {
18109 {
18110 arg3 = wxString_in_helper(obj2);
18111 if (arg3 == NULL) SWIG_fail;
18112 temp3 = true;
18113 }
18114 }
18115 if (obj3) {
18116 {
18117 arg4 = wxString_in_helper(obj3);
18118 if (arg4 == NULL) SWIG_fail;
18119 temp4 = true;
18120 }
18121 }
18122 if (obj4) {
18123 {
18124 arg5 = (long)(SWIG_As_long(obj4));
18125 if (SWIG_arg_fail(5)) SWIG_fail;
18126 }
18127 }
18128 {
18129 PyThreadState* __tstate = wxPyBeginAllowThreads();
18130 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18131
18132 wxPyEndAllowThreads(__tstate);
18133 if (PyErr_Occurred()) SWIG_fail;
18134 }
18135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18136 {
18137 if (temp1)
18138 delete arg1;
18139 }
18140 {
18141 if (temp2)
18142 delete arg2;
18143 }
18144 {
18145 if (temp3)
18146 delete arg3;
18147 }
18148 {
18149 if (temp4)
18150 delete arg4;
18151 }
18152 return resultobj;
18153 fail:
18154 {
18155 if (temp1)
18156 delete arg1;
18157 }
18158 {
18159 if (temp2)
18160 delete arg2;
18161 }
18162 {
18163 if (temp3)
18164 delete arg3;
18165 }
18166 {
18167 if (temp4)
18168 delete arg4;
18169 }
18170 return NULL;
18171 }
18172
18173
18174 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18175 PyObject *resultobj;
18176 wxConfig *arg1 = (wxConfig *) 0 ;
18177 PyObject * obj0 = 0 ;
18178 char *kwnames[] = {
18179 (char *) "self", NULL
18180 };
18181
18182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18184 if (SWIG_arg_fail(1)) SWIG_fail;
18185 {
18186 PyThreadState* __tstate = wxPyBeginAllowThreads();
18187 delete arg1;
18188
18189 wxPyEndAllowThreads(__tstate);
18190 if (PyErr_Occurred()) SWIG_fail;
18191 }
18192 Py_INCREF(Py_None); resultobj = Py_None;
18193 return resultobj;
18194 fail:
18195 return NULL;
18196 }
18197
18198
18199 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18200 PyObject *obj;
18201 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18202 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18203 Py_INCREF(obj);
18204 return Py_BuildValue((char *)"");
18205 }
18206 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18207 PyObject *resultobj;
18208 wxString const &arg1_defvalue = wxPyEmptyString ;
18209 wxString *arg1 = (wxString *) &arg1_defvalue ;
18210 wxString const &arg2_defvalue = wxPyEmptyString ;
18211 wxString *arg2 = (wxString *) &arg2_defvalue ;
18212 wxString const &arg3_defvalue = wxPyEmptyString ;
18213 wxString *arg3 = (wxString *) &arg3_defvalue ;
18214 wxString const &arg4_defvalue = wxPyEmptyString ;
18215 wxString *arg4 = (wxString *) &arg4_defvalue ;
18216 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18217 wxFileConfig *result;
18218 bool temp1 = false ;
18219 bool temp2 = false ;
18220 bool temp3 = false ;
18221 bool temp4 = false ;
18222 PyObject * obj0 = 0 ;
18223 PyObject * obj1 = 0 ;
18224 PyObject * obj2 = 0 ;
18225 PyObject * obj3 = 0 ;
18226 PyObject * obj4 = 0 ;
18227 char *kwnames[] = {
18228 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18229 };
18230
18231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18232 if (obj0) {
18233 {
18234 arg1 = wxString_in_helper(obj0);
18235 if (arg1 == NULL) SWIG_fail;
18236 temp1 = true;
18237 }
18238 }
18239 if (obj1) {
18240 {
18241 arg2 = wxString_in_helper(obj1);
18242 if (arg2 == NULL) SWIG_fail;
18243 temp2 = true;
18244 }
18245 }
18246 if (obj2) {
18247 {
18248 arg3 = wxString_in_helper(obj2);
18249 if (arg3 == NULL) SWIG_fail;
18250 temp3 = true;
18251 }
18252 }
18253 if (obj3) {
18254 {
18255 arg4 = wxString_in_helper(obj3);
18256 if (arg4 == NULL) SWIG_fail;
18257 temp4 = true;
18258 }
18259 }
18260 if (obj4) {
18261 {
18262 arg5 = (long)(SWIG_As_long(obj4));
18263 if (SWIG_arg_fail(5)) SWIG_fail;
18264 }
18265 }
18266 {
18267 PyThreadState* __tstate = wxPyBeginAllowThreads();
18268 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18269
18270 wxPyEndAllowThreads(__tstate);
18271 if (PyErr_Occurred()) SWIG_fail;
18272 }
18273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18274 {
18275 if (temp1)
18276 delete arg1;
18277 }
18278 {
18279 if (temp2)
18280 delete arg2;
18281 }
18282 {
18283 if (temp3)
18284 delete arg3;
18285 }
18286 {
18287 if (temp4)
18288 delete arg4;
18289 }
18290 return resultobj;
18291 fail:
18292 {
18293 if (temp1)
18294 delete arg1;
18295 }
18296 {
18297 if (temp2)
18298 delete arg2;
18299 }
18300 {
18301 if (temp3)
18302 delete arg3;
18303 }
18304 {
18305 if (temp4)
18306 delete arg4;
18307 }
18308 return NULL;
18309 }
18310
18311
18312 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18313 PyObject *resultobj;
18314 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18315 PyObject * obj0 = 0 ;
18316 char *kwnames[] = {
18317 (char *) "self", NULL
18318 };
18319
18320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18322 if (SWIG_arg_fail(1)) SWIG_fail;
18323 {
18324 PyThreadState* __tstate = wxPyBeginAllowThreads();
18325 delete arg1;
18326
18327 wxPyEndAllowThreads(__tstate);
18328 if (PyErr_Occurred()) SWIG_fail;
18329 }
18330 Py_INCREF(Py_None); resultobj = Py_None;
18331 return resultobj;
18332 fail:
18333 return NULL;
18334 }
18335
18336
18337 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18338 PyObject *obj;
18339 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18340 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18341 Py_INCREF(obj);
18342 return Py_BuildValue((char *)"");
18343 }
18344 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18345 PyObject *resultobj;
18346 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18347 wxString *arg2 = 0 ;
18348 wxConfigPathChanger *result;
18349 bool temp2 = false ;
18350 PyObject * obj0 = 0 ;
18351 PyObject * obj1 = 0 ;
18352 char *kwnames[] = {
18353 (char *) "config",(char *) "entry", NULL
18354 };
18355
18356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18358 if (SWIG_arg_fail(1)) SWIG_fail;
18359 {
18360 arg2 = wxString_in_helper(obj1);
18361 if (arg2 == NULL) SWIG_fail;
18362 temp2 = true;
18363 }
18364 {
18365 PyThreadState* __tstate = wxPyBeginAllowThreads();
18366 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18367
18368 wxPyEndAllowThreads(__tstate);
18369 if (PyErr_Occurred()) SWIG_fail;
18370 }
18371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18372 {
18373 if (temp2)
18374 delete arg2;
18375 }
18376 return resultobj;
18377 fail:
18378 {
18379 if (temp2)
18380 delete arg2;
18381 }
18382 return NULL;
18383 }
18384
18385
18386 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18387 PyObject *resultobj;
18388 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18389 PyObject * obj0 = 0 ;
18390 char *kwnames[] = {
18391 (char *) "self", NULL
18392 };
18393
18394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18396 if (SWIG_arg_fail(1)) SWIG_fail;
18397 {
18398 PyThreadState* __tstate = wxPyBeginAllowThreads();
18399 delete arg1;
18400
18401 wxPyEndAllowThreads(__tstate);
18402 if (PyErr_Occurred()) SWIG_fail;
18403 }
18404 Py_INCREF(Py_None); resultobj = Py_None;
18405 return resultobj;
18406 fail:
18407 return NULL;
18408 }
18409
18410
18411 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18412 PyObject *resultobj;
18413 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18414 wxString *result;
18415 PyObject * obj0 = 0 ;
18416 char *kwnames[] = {
18417 (char *) "self", NULL
18418 };
18419
18420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18422 if (SWIG_arg_fail(1)) SWIG_fail;
18423 {
18424 PyThreadState* __tstate = wxPyBeginAllowThreads();
18425 {
18426 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18427 result = (wxString *) &_result_ref;
18428 }
18429
18430 wxPyEndAllowThreads(__tstate);
18431 if (PyErr_Occurred()) SWIG_fail;
18432 }
18433 {
18434 #if wxUSE_UNICODE
18435 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18436 #else
18437 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18438 #endif
18439 }
18440 return resultobj;
18441 fail:
18442 return NULL;
18443 }
18444
18445
18446 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18447 PyObject *obj;
18448 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18449 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18450 Py_INCREF(obj);
18451 return Py_BuildValue((char *)"");
18452 }
18453 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18454 PyObject *resultobj;
18455 wxString *arg1 = 0 ;
18456 wxString result;
18457 bool temp1 = false ;
18458 PyObject * obj0 = 0 ;
18459 char *kwnames[] = {
18460 (char *) "sz", NULL
18461 };
18462
18463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18464 {
18465 arg1 = wxString_in_helper(obj0);
18466 if (arg1 == NULL) SWIG_fail;
18467 temp1 = true;
18468 }
18469 {
18470 PyThreadState* __tstate = wxPyBeginAllowThreads();
18471 result = wxExpandEnvVars((wxString const &)*arg1);
18472
18473 wxPyEndAllowThreads(__tstate);
18474 if (PyErr_Occurred()) SWIG_fail;
18475 }
18476 {
18477 #if wxUSE_UNICODE
18478 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18479 #else
18480 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18481 #endif
18482 }
18483 {
18484 if (temp1)
18485 delete arg1;
18486 }
18487 return resultobj;
18488 fail:
18489 {
18490 if (temp1)
18491 delete arg1;
18492 }
18493 return NULL;
18494 }
18495
18496
18497 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18498 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18499 return 1;
18500 }
18501
18502
18503 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18504 PyObject *pyobj;
18505
18506 {
18507 #if wxUSE_UNICODE
18508 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18509 #else
18510 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18511 #endif
18512 }
18513 return pyobj;
18514 }
18515
18516
18517 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18518 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18519 return 1;
18520 }
18521
18522
18523 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18524 PyObject *pyobj;
18525
18526 {
18527 #if wxUSE_UNICODE
18528 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18529 #else
18530 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18531 #endif
18532 }
18533 return pyobj;
18534 }
18535
18536
18537 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18538 PyObject *resultobj;
18539 wxDateTime::Country arg1 ;
18540 PyObject * obj0 = 0 ;
18541 char *kwnames[] = {
18542 (char *) "country", NULL
18543 };
18544
18545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18546 {
18547 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18548 if (SWIG_arg_fail(1)) SWIG_fail;
18549 }
18550 {
18551 PyThreadState* __tstate = wxPyBeginAllowThreads();
18552 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18553
18554 wxPyEndAllowThreads(__tstate);
18555 if (PyErr_Occurred()) SWIG_fail;
18556 }
18557 Py_INCREF(Py_None); resultobj = Py_None;
18558 return resultobj;
18559 fail:
18560 return NULL;
18561 }
18562
18563
18564 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18565 PyObject *resultobj;
18566 wxDateTime::Country result;
18567 char *kwnames[] = {
18568 NULL
18569 };
18570
18571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18572 {
18573 PyThreadState* __tstate = wxPyBeginAllowThreads();
18574 result = (wxDateTime::Country)wxDateTime::GetCountry();
18575
18576 wxPyEndAllowThreads(__tstate);
18577 if (PyErr_Occurred()) SWIG_fail;
18578 }
18579 resultobj = SWIG_From_int((result));
18580 return resultobj;
18581 fail:
18582 return NULL;
18583 }
18584
18585
18586 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18587 PyObject *resultobj;
18588 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18589 bool result;
18590 PyObject * obj0 = 0 ;
18591 char *kwnames[] = {
18592 (char *) "country", NULL
18593 };
18594
18595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18596 if (obj0) {
18597 {
18598 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18599 if (SWIG_arg_fail(1)) SWIG_fail;
18600 }
18601 }
18602 {
18603 PyThreadState* __tstate = wxPyBeginAllowThreads();
18604 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18605
18606 wxPyEndAllowThreads(__tstate);
18607 if (PyErr_Occurred()) SWIG_fail;
18608 }
18609 {
18610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18611 }
18612 return resultobj;
18613 fail:
18614 return NULL;
18615 }
18616
18617
18618 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18619 PyObject *resultobj;
18620 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18621 int result;
18622 PyObject * obj0 = 0 ;
18623 char *kwnames[] = {
18624 (char *) "cal", NULL
18625 };
18626
18627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18628 if (obj0) {
18629 {
18630 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18631 if (SWIG_arg_fail(1)) SWIG_fail;
18632 }
18633 }
18634 {
18635 PyThreadState* __tstate = wxPyBeginAllowThreads();
18636 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18637
18638 wxPyEndAllowThreads(__tstate);
18639 if (PyErr_Occurred()) SWIG_fail;
18640 }
18641 {
18642 resultobj = SWIG_From_int((int)(result));
18643 }
18644 return resultobj;
18645 fail:
18646 return NULL;
18647 }
18648
18649
18650 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
18651 PyObject *resultobj;
18652 int arg1 ;
18653 int result;
18654 PyObject * obj0 = 0 ;
18655 char *kwnames[] = {
18656 (char *) "year", NULL
18657 };
18658
18659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
18660 {
18661 arg1 = (int)(SWIG_As_int(obj0));
18662 if (SWIG_arg_fail(1)) SWIG_fail;
18663 }
18664 {
18665 PyThreadState* __tstate = wxPyBeginAllowThreads();
18666 result = (int)wxDateTime::ConvertYearToBC(arg1);
18667
18668 wxPyEndAllowThreads(__tstate);
18669 if (PyErr_Occurred()) SWIG_fail;
18670 }
18671 {
18672 resultobj = SWIG_From_int((int)(result));
18673 }
18674 return resultobj;
18675 fail:
18676 return NULL;
18677 }
18678
18679
18680 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18681 PyObject *resultobj;
18682 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18683 wxDateTime::Month result;
18684 PyObject * obj0 = 0 ;
18685 char *kwnames[] = {
18686 (char *) "cal", NULL
18687 };
18688
18689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
18690 if (obj0) {
18691 {
18692 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18693 if (SWIG_arg_fail(1)) SWIG_fail;
18694 }
18695 }
18696 {
18697 PyThreadState* __tstate = wxPyBeginAllowThreads();
18698 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
18699
18700 wxPyEndAllowThreads(__tstate);
18701 if (PyErr_Occurred()) SWIG_fail;
18702 }
18703 resultobj = SWIG_From_int((result));
18704 return resultobj;
18705 fail:
18706 return NULL;
18707 }
18708
18709
18710 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
18711 PyObject *resultobj;
18712 int arg1 = (int) wxDateTime::Inv_Year ;
18713 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18714 bool result;
18715 PyObject * obj0 = 0 ;
18716 PyObject * obj1 = 0 ;
18717 char *kwnames[] = {
18718 (char *) "year",(char *) "cal", NULL
18719 };
18720
18721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
18722 if (obj0) {
18723 {
18724 arg1 = (int)(SWIG_As_int(obj0));
18725 if (SWIG_arg_fail(1)) SWIG_fail;
18726 }
18727 }
18728 if (obj1) {
18729 {
18730 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18731 if (SWIG_arg_fail(2)) SWIG_fail;
18732 }
18733 }
18734 {
18735 PyThreadState* __tstate = wxPyBeginAllowThreads();
18736 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
18737
18738 wxPyEndAllowThreads(__tstate);
18739 if (PyErr_Occurred()) SWIG_fail;
18740 }
18741 {
18742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18743 }
18744 return resultobj;
18745 fail:
18746 return NULL;
18747 }
18748
18749
18750 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
18751 PyObject *resultobj;
18752 int arg1 = (int) wxDateTime::Inv_Year ;
18753 int result;
18754 PyObject * obj0 = 0 ;
18755 char *kwnames[] = {
18756 (char *) "year", NULL
18757 };
18758
18759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
18760 if (obj0) {
18761 {
18762 arg1 = (int)(SWIG_As_int(obj0));
18763 if (SWIG_arg_fail(1)) SWIG_fail;
18764 }
18765 }
18766 {
18767 PyThreadState* __tstate = wxPyBeginAllowThreads();
18768 result = (int)wxDateTime::GetCentury(arg1);
18769
18770 wxPyEndAllowThreads(__tstate);
18771 if (PyErr_Occurred()) SWIG_fail;
18772 }
18773 {
18774 resultobj = SWIG_From_int((int)(result));
18775 }
18776 return resultobj;
18777 fail:
18778 return NULL;
18779 }
18780
18781
18782 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
18783 PyObject *resultobj;
18784 int arg1 ;
18785 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18786 int result;
18787 PyObject * obj0 = 0 ;
18788 PyObject * obj1 = 0 ;
18789 char *kwnames[] = {
18790 (char *) "year",(char *) "cal", NULL
18791 };
18792
18793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
18794 {
18795 arg1 = (int)(SWIG_As_int(obj0));
18796 if (SWIG_arg_fail(1)) SWIG_fail;
18797 }
18798 if (obj1) {
18799 {
18800 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
18801 if (SWIG_arg_fail(2)) SWIG_fail;
18802 }
18803 }
18804 {
18805 PyThreadState* __tstate = wxPyBeginAllowThreads();
18806 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
18807
18808 wxPyEndAllowThreads(__tstate);
18809 if (PyErr_Occurred()) SWIG_fail;
18810 }
18811 {
18812 resultobj = SWIG_From_int((int)(result));
18813 }
18814 return resultobj;
18815 fail:
18816 return NULL;
18817 }
18818
18819
18820 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
18821 PyObject *resultobj;
18822 wxDateTime::Month arg1 ;
18823 int arg2 = (int) wxDateTime::Inv_Year ;
18824 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18825 int result;
18826 PyObject * obj0 = 0 ;
18827 PyObject * obj1 = 0 ;
18828 PyObject * obj2 = 0 ;
18829 char *kwnames[] = {
18830 (char *) "month",(char *) "year",(char *) "cal", NULL
18831 };
18832
18833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
18834 {
18835 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
18836 if (SWIG_arg_fail(1)) SWIG_fail;
18837 }
18838 if (obj1) {
18839 {
18840 arg2 = (int)(SWIG_As_int(obj1));
18841 if (SWIG_arg_fail(2)) SWIG_fail;
18842 }
18843 }
18844 if (obj2) {
18845 {
18846 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
18847 if (SWIG_arg_fail(3)) SWIG_fail;
18848 }
18849 }
18850 {
18851 PyThreadState* __tstate = wxPyBeginAllowThreads();
18852 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
18853
18854 wxPyEndAllowThreads(__tstate);
18855 if (PyErr_Occurred()) SWIG_fail;
18856 }
18857 {
18858 resultobj = SWIG_From_int((int)(result));
18859 }
18860 return resultobj;
18861 fail:
18862 return NULL;
18863 }
18864
18865
18866 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
18867 PyObject *resultobj;
18868 wxDateTime::Month arg1 ;
18869 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
18870 wxString result;
18871 PyObject * obj0 = 0 ;
18872 PyObject * obj1 = 0 ;
18873 char *kwnames[] = {
18874 (char *) "month",(char *) "flags", NULL
18875 };
18876
18877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
18878 {
18879 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
18880 if (SWIG_arg_fail(1)) SWIG_fail;
18881 }
18882 if (obj1) {
18883 {
18884 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
18885 if (SWIG_arg_fail(2)) SWIG_fail;
18886 }
18887 }
18888 {
18889 PyThreadState* __tstate = wxPyBeginAllowThreads();
18890 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
18891
18892 wxPyEndAllowThreads(__tstate);
18893 if (PyErr_Occurred()) SWIG_fail;
18894 }
18895 {
18896 #if wxUSE_UNICODE
18897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18898 #else
18899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18900 #endif
18901 }
18902 return resultobj;
18903 fail:
18904 return NULL;
18905 }
18906
18907
18908 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
18909 PyObject *resultobj;
18910 wxDateTime::WeekDay arg1 ;
18911 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
18912 wxString result;
18913 PyObject * obj0 = 0 ;
18914 PyObject * obj1 = 0 ;
18915 char *kwnames[] = {
18916 (char *) "weekday",(char *) "flags", NULL
18917 };
18918
18919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
18920 {
18921 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
18922 if (SWIG_arg_fail(1)) SWIG_fail;
18923 }
18924 if (obj1) {
18925 {
18926 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
18927 if (SWIG_arg_fail(2)) SWIG_fail;
18928 }
18929 }
18930 {
18931 PyThreadState* __tstate = wxPyBeginAllowThreads();
18932 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
18933
18934 wxPyEndAllowThreads(__tstate);
18935 if (PyErr_Occurred()) SWIG_fail;
18936 }
18937 {
18938 #if wxUSE_UNICODE
18939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18940 #else
18941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18942 #endif
18943 }
18944 return resultobj;
18945 fail:
18946 return NULL;
18947 }
18948
18949
18950 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
18951 PyObject *resultobj;
18952 wxString *arg1 = (wxString *) 0 ;
18953 wxString *arg2 = (wxString *) 0 ;
18954 bool temp1 = false ;
18955 bool temp2 = false ;
18956 PyObject * obj0 = 0 ;
18957 PyObject * obj1 = 0 ;
18958 char *kwnames[] = {
18959 (char *) "OUTPUT",(char *) "OUTPUT", NULL
18960 };
18961
18962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
18963 {
18964 arg1 = wxString_in_helper(obj0);
18965 if (arg1 == NULL) SWIG_fail;
18966 temp1 = true;
18967 }
18968 {
18969 arg2 = wxString_in_helper(obj1);
18970 if (arg2 == NULL) SWIG_fail;
18971 temp2 = true;
18972 }
18973 {
18974 PyThreadState* __tstate = wxPyBeginAllowThreads();
18975 wxDateTime::GetAmPmStrings(arg1,arg2);
18976
18977 wxPyEndAllowThreads(__tstate);
18978 if (PyErr_Occurred()) SWIG_fail;
18979 }
18980 Py_INCREF(Py_None); resultobj = Py_None;
18981 {
18982 if (temp1)
18983 delete arg1;
18984 }
18985 {
18986 if (temp2)
18987 delete arg2;
18988 }
18989 return resultobj;
18990 fail:
18991 {
18992 if (temp1)
18993 delete arg1;
18994 }
18995 {
18996 if (temp2)
18997 delete arg2;
18998 }
18999 return NULL;
19000 }
19001
19002
19003 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19004 PyObject *resultobj;
19005 int arg1 = (int) wxDateTime::Inv_Year ;
19006 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19007 bool result;
19008 PyObject * obj0 = 0 ;
19009 PyObject * obj1 = 0 ;
19010 char *kwnames[] = {
19011 (char *) "year",(char *) "country", NULL
19012 };
19013
19014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19015 if (obj0) {
19016 {
19017 arg1 = (int)(SWIG_As_int(obj0));
19018 if (SWIG_arg_fail(1)) SWIG_fail;
19019 }
19020 }
19021 if (obj1) {
19022 {
19023 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19024 if (SWIG_arg_fail(2)) SWIG_fail;
19025 }
19026 }
19027 {
19028 PyThreadState* __tstate = wxPyBeginAllowThreads();
19029 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19030
19031 wxPyEndAllowThreads(__tstate);
19032 if (PyErr_Occurred()) SWIG_fail;
19033 }
19034 {
19035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19036 }
19037 return resultobj;
19038 fail:
19039 return NULL;
19040 }
19041
19042
19043 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19044 PyObject *resultobj;
19045 int arg1 = (int) wxDateTime::Inv_Year ;
19046 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19047 wxDateTime result;
19048 PyObject * obj0 = 0 ;
19049 PyObject * obj1 = 0 ;
19050 char *kwnames[] = {
19051 (char *) "year",(char *) "country", NULL
19052 };
19053
19054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19055 if (obj0) {
19056 {
19057 arg1 = (int)(SWIG_As_int(obj0));
19058 if (SWIG_arg_fail(1)) SWIG_fail;
19059 }
19060 }
19061 if (obj1) {
19062 {
19063 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19064 if (SWIG_arg_fail(2)) SWIG_fail;
19065 }
19066 }
19067 {
19068 PyThreadState* __tstate = wxPyBeginAllowThreads();
19069 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19070
19071 wxPyEndAllowThreads(__tstate);
19072 if (PyErr_Occurred()) SWIG_fail;
19073 }
19074 {
19075 wxDateTime * resultptr;
19076 resultptr = new wxDateTime((wxDateTime &)(result));
19077 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19078 }
19079 return resultobj;
19080 fail:
19081 return NULL;
19082 }
19083
19084
19085 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19086 PyObject *resultobj;
19087 int arg1 = (int) wxDateTime::Inv_Year ;
19088 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19089 wxDateTime result;
19090 PyObject * obj0 = 0 ;
19091 PyObject * obj1 = 0 ;
19092 char *kwnames[] = {
19093 (char *) "year",(char *) "country", NULL
19094 };
19095
19096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19097 if (obj0) {
19098 {
19099 arg1 = (int)(SWIG_As_int(obj0));
19100 if (SWIG_arg_fail(1)) SWIG_fail;
19101 }
19102 }
19103 if (obj1) {
19104 {
19105 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19106 if (SWIG_arg_fail(2)) SWIG_fail;
19107 }
19108 }
19109 {
19110 PyThreadState* __tstate = wxPyBeginAllowThreads();
19111 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19112
19113 wxPyEndAllowThreads(__tstate);
19114 if (PyErr_Occurred()) SWIG_fail;
19115 }
19116 {
19117 wxDateTime * resultptr;
19118 resultptr = new wxDateTime((wxDateTime &)(result));
19119 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19120 }
19121 return resultobj;
19122 fail:
19123 return NULL;
19124 }
19125
19126
19127 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19128 PyObject *resultobj;
19129 wxDateTime result;
19130 char *kwnames[] = {
19131 NULL
19132 };
19133
19134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19135 {
19136 PyThreadState* __tstate = wxPyBeginAllowThreads();
19137 result = wxDateTime::Now();
19138
19139 wxPyEndAllowThreads(__tstate);
19140 if (PyErr_Occurred()) SWIG_fail;
19141 }
19142 {
19143 wxDateTime * resultptr;
19144 resultptr = new wxDateTime((wxDateTime &)(result));
19145 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19146 }
19147 return resultobj;
19148 fail:
19149 return NULL;
19150 }
19151
19152
19153 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19154 PyObject *resultobj;
19155 wxDateTime result;
19156 char *kwnames[] = {
19157 NULL
19158 };
19159
19160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19161 {
19162 PyThreadState* __tstate = wxPyBeginAllowThreads();
19163 result = wxDateTime::UNow();
19164
19165 wxPyEndAllowThreads(__tstate);
19166 if (PyErr_Occurred()) SWIG_fail;
19167 }
19168 {
19169 wxDateTime * resultptr;
19170 resultptr = new wxDateTime((wxDateTime &)(result));
19171 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19172 }
19173 return resultobj;
19174 fail:
19175 return NULL;
19176 }
19177
19178
19179 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19180 PyObject *resultobj;
19181 wxDateTime result;
19182 char *kwnames[] = {
19183 NULL
19184 };
19185
19186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19187 {
19188 PyThreadState* __tstate = wxPyBeginAllowThreads();
19189 result = wxDateTime::Today();
19190
19191 wxPyEndAllowThreads(__tstate);
19192 if (PyErr_Occurred()) SWIG_fail;
19193 }
19194 {
19195 wxDateTime * resultptr;
19196 resultptr = new wxDateTime((wxDateTime &)(result));
19197 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19198 }
19199 return resultobj;
19200 fail:
19201 return NULL;
19202 }
19203
19204
19205 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19206 PyObject *resultobj;
19207 wxDateTime *result;
19208 char *kwnames[] = {
19209 NULL
19210 };
19211
19212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19213 {
19214 PyThreadState* __tstate = wxPyBeginAllowThreads();
19215 result = (wxDateTime *)new wxDateTime();
19216
19217 wxPyEndAllowThreads(__tstate);
19218 if (PyErr_Occurred()) SWIG_fail;
19219 }
19220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19221 return resultobj;
19222 fail:
19223 return NULL;
19224 }
19225
19226
19227 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19228 PyObject *resultobj;
19229 time_t arg1 ;
19230 wxDateTime *result;
19231 PyObject * obj0 = 0 ;
19232 char *kwnames[] = {
19233 (char *) "timet", NULL
19234 };
19235
19236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19237 {
19238 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19239 if (SWIG_arg_fail(1)) SWIG_fail;
19240 }
19241 {
19242 PyThreadState* __tstate = wxPyBeginAllowThreads();
19243 result = (wxDateTime *)new wxDateTime(arg1);
19244
19245 wxPyEndAllowThreads(__tstate);
19246 if (PyErr_Occurred()) SWIG_fail;
19247 }
19248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19249 return resultobj;
19250 fail:
19251 return NULL;
19252 }
19253
19254
19255 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19256 PyObject *resultobj;
19257 double arg1 ;
19258 wxDateTime *result;
19259 PyObject * obj0 = 0 ;
19260 char *kwnames[] = {
19261 (char *) "jdn", NULL
19262 };
19263
19264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19265 {
19266 arg1 = (double)(SWIG_As_double(obj0));
19267 if (SWIG_arg_fail(1)) SWIG_fail;
19268 }
19269 {
19270 PyThreadState* __tstate = wxPyBeginAllowThreads();
19271 result = (wxDateTime *)new wxDateTime(arg1);
19272
19273 wxPyEndAllowThreads(__tstate);
19274 if (PyErr_Occurred()) SWIG_fail;
19275 }
19276 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19277 return resultobj;
19278 fail:
19279 return NULL;
19280 }
19281
19282
19283 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19284 PyObject *resultobj;
19285 int arg1 ;
19286 int arg2 = (int) 0 ;
19287 int arg3 = (int) 0 ;
19288 int arg4 = (int) 0 ;
19289 wxDateTime *result;
19290 PyObject * obj0 = 0 ;
19291 PyObject * obj1 = 0 ;
19292 PyObject * obj2 = 0 ;
19293 PyObject * obj3 = 0 ;
19294 char *kwnames[] = {
19295 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19296 };
19297
19298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19299 {
19300 arg1 = (int)(SWIG_As_int(obj0));
19301 if (SWIG_arg_fail(1)) SWIG_fail;
19302 }
19303 if (obj1) {
19304 {
19305 arg2 = (int)(SWIG_As_int(obj1));
19306 if (SWIG_arg_fail(2)) SWIG_fail;
19307 }
19308 }
19309 if (obj2) {
19310 {
19311 arg3 = (int)(SWIG_As_int(obj2));
19312 if (SWIG_arg_fail(3)) SWIG_fail;
19313 }
19314 }
19315 if (obj3) {
19316 {
19317 arg4 = (int)(SWIG_As_int(obj3));
19318 if (SWIG_arg_fail(4)) SWIG_fail;
19319 }
19320 }
19321 {
19322 PyThreadState* __tstate = wxPyBeginAllowThreads();
19323 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19324
19325 wxPyEndAllowThreads(__tstate);
19326 if (PyErr_Occurred()) SWIG_fail;
19327 }
19328 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19329 return resultobj;
19330 fail:
19331 return NULL;
19332 }
19333
19334
19335 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19336 PyObject *resultobj;
19337 int arg1 ;
19338 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19339 int arg3 = (int) wxDateTime::Inv_Year ;
19340 int arg4 = (int) 0 ;
19341 int arg5 = (int) 0 ;
19342 int arg6 = (int) 0 ;
19343 int arg7 = (int) 0 ;
19344 wxDateTime *result;
19345 PyObject * obj0 = 0 ;
19346 PyObject * obj1 = 0 ;
19347 PyObject * obj2 = 0 ;
19348 PyObject * obj3 = 0 ;
19349 PyObject * obj4 = 0 ;
19350 PyObject * obj5 = 0 ;
19351 PyObject * obj6 = 0 ;
19352 char *kwnames[] = {
19353 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19354 };
19355
19356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19357 {
19358 arg1 = (int)(SWIG_As_int(obj0));
19359 if (SWIG_arg_fail(1)) SWIG_fail;
19360 }
19361 if (obj1) {
19362 {
19363 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19364 if (SWIG_arg_fail(2)) SWIG_fail;
19365 }
19366 }
19367 if (obj2) {
19368 {
19369 arg3 = (int)(SWIG_As_int(obj2));
19370 if (SWIG_arg_fail(3)) SWIG_fail;
19371 }
19372 }
19373 if (obj3) {
19374 {
19375 arg4 = (int)(SWIG_As_int(obj3));
19376 if (SWIG_arg_fail(4)) SWIG_fail;
19377 }
19378 }
19379 if (obj4) {
19380 {
19381 arg5 = (int)(SWIG_As_int(obj4));
19382 if (SWIG_arg_fail(5)) SWIG_fail;
19383 }
19384 }
19385 if (obj5) {
19386 {
19387 arg6 = (int)(SWIG_As_int(obj5));
19388 if (SWIG_arg_fail(6)) SWIG_fail;
19389 }
19390 }
19391 if (obj6) {
19392 {
19393 arg7 = (int)(SWIG_As_int(obj6));
19394 if (SWIG_arg_fail(7)) SWIG_fail;
19395 }
19396 }
19397 {
19398 PyThreadState* __tstate = wxPyBeginAllowThreads();
19399 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19400
19401 wxPyEndAllowThreads(__tstate);
19402 if (PyErr_Occurred()) SWIG_fail;
19403 }
19404 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19405 return resultobj;
19406 fail:
19407 return NULL;
19408 }
19409
19410
19411 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19412 PyObject *resultobj;
19413 wxDateTime *arg1 = (wxDateTime *) 0 ;
19414 PyObject * obj0 = 0 ;
19415 char *kwnames[] = {
19416 (char *) "self", NULL
19417 };
19418
19419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19421 if (SWIG_arg_fail(1)) SWIG_fail;
19422 {
19423 PyThreadState* __tstate = wxPyBeginAllowThreads();
19424 delete arg1;
19425
19426 wxPyEndAllowThreads(__tstate);
19427 if (PyErr_Occurred()) SWIG_fail;
19428 }
19429 Py_INCREF(Py_None); resultobj = Py_None;
19430 return resultobj;
19431 fail:
19432 return NULL;
19433 }
19434
19435
19436 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19437 PyObject *resultobj;
19438 wxDateTime *arg1 = (wxDateTime *) 0 ;
19439 wxDateTime *result;
19440 PyObject * obj0 = 0 ;
19441 char *kwnames[] = {
19442 (char *) "self", NULL
19443 };
19444
19445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19447 if (SWIG_arg_fail(1)) SWIG_fail;
19448 {
19449 PyThreadState* __tstate = wxPyBeginAllowThreads();
19450 {
19451 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19452 result = (wxDateTime *) &_result_ref;
19453 }
19454
19455 wxPyEndAllowThreads(__tstate);
19456 if (PyErr_Occurred()) SWIG_fail;
19457 }
19458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19459 return resultobj;
19460 fail:
19461 return NULL;
19462 }
19463
19464
19465 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19466 PyObject *resultobj;
19467 wxDateTime *arg1 = (wxDateTime *) 0 ;
19468 time_t arg2 ;
19469 wxDateTime *result;
19470 PyObject * obj0 = 0 ;
19471 PyObject * obj1 = 0 ;
19472 char *kwnames[] = {
19473 (char *) "self",(char *) "timet", NULL
19474 };
19475
19476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19478 if (SWIG_arg_fail(1)) SWIG_fail;
19479 {
19480 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19481 if (SWIG_arg_fail(2)) SWIG_fail;
19482 }
19483 {
19484 PyThreadState* __tstate = wxPyBeginAllowThreads();
19485 {
19486 wxDateTime &_result_ref = (arg1)->Set(arg2);
19487 result = (wxDateTime *) &_result_ref;
19488 }
19489
19490 wxPyEndAllowThreads(__tstate);
19491 if (PyErr_Occurred()) SWIG_fail;
19492 }
19493 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19494 return resultobj;
19495 fail:
19496 return NULL;
19497 }
19498
19499
19500 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19501 PyObject *resultobj;
19502 wxDateTime *arg1 = (wxDateTime *) 0 ;
19503 double arg2 ;
19504 wxDateTime *result;
19505 PyObject * obj0 = 0 ;
19506 PyObject * obj1 = 0 ;
19507 char *kwnames[] = {
19508 (char *) "self",(char *) "jdn", NULL
19509 };
19510
19511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19513 if (SWIG_arg_fail(1)) SWIG_fail;
19514 {
19515 arg2 = (double)(SWIG_As_double(obj1));
19516 if (SWIG_arg_fail(2)) SWIG_fail;
19517 }
19518 {
19519 PyThreadState* __tstate = wxPyBeginAllowThreads();
19520 {
19521 wxDateTime &_result_ref = (arg1)->Set(arg2);
19522 result = (wxDateTime *) &_result_ref;
19523 }
19524
19525 wxPyEndAllowThreads(__tstate);
19526 if (PyErr_Occurred()) SWIG_fail;
19527 }
19528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19529 return resultobj;
19530 fail:
19531 return NULL;
19532 }
19533
19534
19535 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19536 PyObject *resultobj;
19537 wxDateTime *arg1 = (wxDateTime *) 0 ;
19538 int arg2 ;
19539 int arg3 = (int) 0 ;
19540 int arg4 = (int) 0 ;
19541 int arg5 = (int) 0 ;
19542 wxDateTime *result;
19543 PyObject * obj0 = 0 ;
19544 PyObject * obj1 = 0 ;
19545 PyObject * obj2 = 0 ;
19546 PyObject * obj3 = 0 ;
19547 PyObject * obj4 = 0 ;
19548 char *kwnames[] = {
19549 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19550 };
19551
19552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19554 if (SWIG_arg_fail(1)) SWIG_fail;
19555 {
19556 arg2 = (int)(SWIG_As_int(obj1));
19557 if (SWIG_arg_fail(2)) SWIG_fail;
19558 }
19559 if (obj2) {
19560 {
19561 arg3 = (int)(SWIG_As_int(obj2));
19562 if (SWIG_arg_fail(3)) SWIG_fail;
19563 }
19564 }
19565 if (obj3) {
19566 {
19567 arg4 = (int)(SWIG_As_int(obj3));
19568 if (SWIG_arg_fail(4)) SWIG_fail;
19569 }
19570 }
19571 if (obj4) {
19572 {
19573 arg5 = (int)(SWIG_As_int(obj4));
19574 if (SWIG_arg_fail(5)) SWIG_fail;
19575 }
19576 }
19577 {
19578 PyThreadState* __tstate = wxPyBeginAllowThreads();
19579 {
19580 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19581 result = (wxDateTime *) &_result_ref;
19582 }
19583
19584 wxPyEndAllowThreads(__tstate);
19585 if (PyErr_Occurred()) SWIG_fail;
19586 }
19587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19588 return resultobj;
19589 fail:
19590 return NULL;
19591 }
19592
19593
19594 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19595 PyObject *resultobj;
19596 wxDateTime *arg1 = (wxDateTime *) 0 ;
19597 int arg2 ;
19598 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19599 int arg4 = (int) wxDateTime::Inv_Year ;
19600 int arg5 = (int) 0 ;
19601 int arg6 = (int) 0 ;
19602 int arg7 = (int) 0 ;
19603 int arg8 = (int) 0 ;
19604 wxDateTime *result;
19605 PyObject * obj0 = 0 ;
19606 PyObject * obj1 = 0 ;
19607 PyObject * obj2 = 0 ;
19608 PyObject * obj3 = 0 ;
19609 PyObject * obj4 = 0 ;
19610 PyObject * obj5 = 0 ;
19611 PyObject * obj6 = 0 ;
19612 PyObject * obj7 = 0 ;
19613 char *kwnames[] = {
19614 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19615 };
19616
19617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19619 if (SWIG_arg_fail(1)) SWIG_fail;
19620 {
19621 arg2 = (int)(SWIG_As_int(obj1));
19622 if (SWIG_arg_fail(2)) SWIG_fail;
19623 }
19624 if (obj2) {
19625 {
19626 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19627 if (SWIG_arg_fail(3)) SWIG_fail;
19628 }
19629 }
19630 if (obj3) {
19631 {
19632 arg4 = (int)(SWIG_As_int(obj3));
19633 if (SWIG_arg_fail(4)) SWIG_fail;
19634 }
19635 }
19636 if (obj4) {
19637 {
19638 arg5 = (int)(SWIG_As_int(obj4));
19639 if (SWIG_arg_fail(5)) SWIG_fail;
19640 }
19641 }
19642 if (obj5) {
19643 {
19644 arg6 = (int)(SWIG_As_int(obj5));
19645 if (SWIG_arg_fail(6)) SWIG_fail;
19646 }
19647 }
19648 if (obj6) {
19649 {
19650 arg7 = (int)(SWIG_As_int(obj6));
19651 if (SWIG_arg_fail(7)) SWIG_fail;
19652 }
19653 }
19654 if (obj7) {
19655 {
19656 arg8 = (int)(SWIG_As_int(obj7));
19657 if (SWIG_arg_fail(8)) SWIG_fail;
19658 }
19659 }
19660 {
19661 PyThreadState* __tstate = wxPyBeginAllowThreads();
19662 {
19663 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
19664 result = (wxDateTime *) &_result_ref;
19665 }
19666
19667 wxPyEndAllowThreads(__tstate);
19668 if (PyErr_Occurred()) SWIG_fail;
19669 }
19670 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19671 return resultobj;
19672 fail:
19673 return NULL;
19674 }
19675
19676
19677 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
19678 PyObject *resultobj;
19679 wxDateTime *arg1 = (wxDateTime *) 0 ;
19680 wxDateTime *result;
19681 PyObject * obj0 = 0 ;
19682 char *kwnames[] = {
19683 (char *) "self", NULL
19684 };
19685
19686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
19687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19688 if (SWIG_arg_fail(1)) SWIG_fail;
19689 {
19690 PyThreadState* __tstate = wxPyBeginAllowThreads();
19691 {
19692 wxDateTime &_result_ref = (arg1)->ResetTime();
19693 result = (wxDateTime *) &_result_ref;
19694 }
19695
19696 wxPyEndAllowThreads(__tstate);
19697 if (PyErr_Occurred()) SWIG_fail;
19698 }
19699 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19700 return resultobj;
19701 fail:
19702 return NULL;
19703 }
19704
19705
19706 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
19707 PyObject *resultobj;
19708 wxDateTime *arg1 = (wxDateTime *) 0 ;
19709 int arg2 ;
19710 wxDateTime *result;
19711 PyObject * obj0 = 0 ;
19712 PyObject * obj1 = 0 ;
19713 char *kwnames[] = {
19714 (char *) "self",(char *) "year", NULL
19715 };
19716
19717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
19718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19719 if (SWIG_arg_fail(1)) SWIG_fail;
19720 {
19721 arg2 = (int)(SWIG_As_int(obj1));
19722 if (SWIG_arg_fail(2)) SWIG_fail;
19723 }
19724 {
19725 PyThreadState* __tstate = wxPyBeginAllowThreads();
19726 {
19727 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
19728 result = (wxDateTime *) &_result_ref;
19729 }
19730
19731 wxPyEndAllowThreads(__tstate);
19732 if (PyErr_Occurred()) SWIG_fail;
19733 }
19734 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19735 return resultobj;
19736 fail:
19737 return NULL;
19738 }
19739
19740
19741 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19742 PyObject *resultobj;
19743 wxDateTime *arg1 = (wxDateTime *) 0 ;
19744 wxDateTime::Month arg2 ;
19745 wxDateTime *result;
19746 PyObject * obj0 = 0 ;
19747 PyObject * obj1 = 0 ;
19748 char *kwnames[] = {
19749 (char *) "self",(char *) "month", NULL
19750 };
19751
19752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
19753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19754 if (SWIG_arg_fail(1)) SWIG_fail;
19755 {
19756 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19757 if (SWIG_arg_fail(2)) SWIG_fail;
19758 }
19759 {
19760 PyThreadState* __tstate = wxPyBeginAllowThreads();
19761 {
19762 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
19763 result = (wxDateTime *) &_result_ref;
19764 }
19765
19766 wxPyEndAllowThreads(__tstate);
19767 if (PyErr_Occurred()) SWIG_fail;
19768 }
19769 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19770 return resultobj;
19771 fail:
19772 return NULL;
19773 }
19774
19775
19776 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
19777 PyObject *resultobj;
19778 wxDateTime *arg1 = (wxDateTime *) 0 ;
19779 int arg2 ;
19780 wxDateTime *result;
19781 PyObject * obj0 = 0 ;
19782 PyObject * obj1 = 0 ;
19783 char *kwnames[] = {
19784 (char *) "self",(char *) "day", NULL
19785 };
19786
19787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
19788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19789 if (SWIG_arg_fail(1)) SWIG_fail;
19790 {
19791 arg2 = (int)(SWIG_As_int(obj1));
19792 if (SWIG_arg_fail(2)) SWIG_fail;
19793 }
19794 {
19795 PyThreadState* __tstate = wxPyBeginAllowThreads();
19796 {
19797 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
19798 result = (wxDateTime *) &_result_ref;
19799 }
19800
19801 wxPyEndAllowThreads(__tstate);
19802 if (PyErr_Occurred()) SWIG_fail;
19803 }
19804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19805 return resultobj;
19806 fail:
19807 return NULL;
19808 }
19809
19810
19811 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
19812 PyObject *resultobj;
19813 wxDateTime *arg1 = (wxDateTime *) 0 ;
19814 int arg2 ;
19815 wxDateTime *result;
19816 PyObject * obj0 = 0 ;
19817 PyObject * obj1 = 0 ;
19818 char *kwnames[] = {
19819 (char *) "self",(char *) "hour", NULL
19820 };
19821
19822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
19823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19824 if (SWIG_arg_fail(1)) SWIG_fail;
19825 {
19826 arg2 = (int)(SWIG_As_int(obj1));
19827 if (SWIG_arg_fail(2)) SWIG_fail;
19828 }
19829 {
19830 PyThreadState* __tstate = wxPyBeginAllowThreads();
19831 {
19832 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
19833 result = (wxDateTime *) &_result_ref;
19834 }
19835
19836 wxPyEndAllowThreads(__tstate);
19837 if (PyErr_Occurred()) SWIG_fail;
19838 }
19839 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19840 return resultobj;
19841 fail:
19842 return NULL;
19843 }
19844
19845
19846 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
19847 PyObject *resultobj;
19848 wxDateTime *arg1 = (wxDateTime *) 0 ;
19849 int arg2 ;
19850 wxDateTime *result;
19851 PyObject * obj0 = 0 ;
19852 PyObject * obj1 = 0 ;
19853 char *kwnames[] = {
19854 (char *) "self",(char *) "minute", NULL
19855 };
19856
19857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
19858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19859 if (SWIG_arg_fail(1)) SWIG_fail;
19860 {
19861 arg2 = (int)(SWIG_As_int(obj1));
19862 if (SWIG_arg_fail(2)) SWIG_fail;
19863 }
19864 {
19865 PyThreadState* __tstate = wxPyBeginAllowThreads();
19866 {
19867 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
19868 result = (wxDateTime *) &_result_ref;
19869 }
19870
19871 wxPyEndAllowThreads(__tstate);
19872 if (PyErr_Occurred()) SWIG_fail;
19873 }
19874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19875 return resultobj;
19876 fail:
19877 return NULL;
19878 }
19879
19880
19881 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
19882 PyObject *resultobj;
19883 wxDateTime *arg1 = (wxDateTime *) 0 ;
19884 int arg2 ;
19885 wxDateTime *result;
19886 PyObject * obj0 = 0 ;
19887 PyObject * obj1 = 0 ;
19888 char *kwnames[] = {
19889 (char *) "self",(char *) "second", NULL
19890 };
19891
19892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
19893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19894 if (SWIG_arg_fail(1)) SWIG_fail;
19895 {
19896 arg2 = (int)(SWIG_As_int(obj1));
19897 if (SWIG_arg_fail(2)) SWIG_fail;
19898 }
19899 {
19900 PyThreadState* __tstate = wxPyBeginAllowThreads();
19901 {
19902 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
19903 result = (wxDateTime *) &_result_ref;
19904 }
19905
19906 wxPyEndAllowThreads(__tstate);
19907 if (PyErr_Occurred()) SWIG_fail;
19908 }
19909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19910 return resultobj;
19911 fail:
19912 return NULL;
19913 }
19914
19915
19916 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
19917 PyObject *resultobj;
19918 wxDateTime *arg1 = (wxDateTime *) 0 ;
19919 int arg2 ;
19920 wxDateTime *result;
19921 PyObject * obj0 = 0 ;
19922 PyObject * obj1 = 0 ;
19923 char *kwnames[] = {
19924 (char *) "self",(char *) "millisecond", NULL
19925 };
19926
19927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
19928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19929 if (SWIG_arg_fail(1)) SWIG_fail;
19930 {
19931 arg2 = (int)(SWIG_As_int(obj1));
19932 if (SWIG_arg_fail(2)) SWIG_fail;
19933 }
19934 {
19935 PyThreadState* __tstate = wxPyBeginAllowThreads();
19936 {
19937 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
19938 result = (wxDateTime *) &_result_ref;
19939 }
19940
19941 wxPyEndAllowThreads(__tstate);
19942 if (PyErr_Occurred()) SWIG_fail;
19943 }
19944 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19945 return resultobj;
19946 fail:
19947 return NULL;
19948 }
19949
19950
19951 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
19952 PyObject *resultobj;
19953 wxDateTime *arg1 = (wxDateTime *) 0 ;
19954 wxDateTime::WeekDay arg2 ;
19955 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
19956 wxDateTime *result;
19957 PyObject * obj0 = 0 ;
19958 PyObject * obj1 = 0 ;
19959 PyObject * obj2 = 0 ;
19960 char *kwnames[] = {
19961 (char *) "self",(char *) "weekday",(char *) "flags", NULL
19962 };
19963
19964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
19965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19966 if (SWIG_arg_fail(1)) SWIG_fail;
19967 {
19968 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
19969 if (SWIG_arg_fail(2)) SWIG_fail;
19970 }
19971 if (obj2) {
19972 {
19973 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
19974 if (SWIG_arg_fail(3)) SWIG_fail;
19975 }
19976 }
19977 {
19978 PyThreadState* __tstate = wxPyBeginAllowThreads();
19979 {
19980 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
19981 result = (wxDateTime *) &_result_ref;
19982 }
19983
19984 wxPyEndAllowThreads(__tstate);
19985 if (PyErr_Occurred()) SWIG_fail;
19986 }
19987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19988 return resultobj;
19989 fail:
19990 return NULL;
19991 }
19992
19993
19994 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
19995 PyObject *resultobj;
19996 wxDateTime *arg1 = (wxDateTime *) 0 ;
19997 wxDateTime::WeekDay arg2 ;
19998 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
19999 wxDateTime result;
20000 PyObject * obj0 = 0 ;
20001 PyObject * obj1 = 0 ;
20002 PyObject * obj2 = 0 ;
20003 char *kwnames[] = {
20004 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20005 };
20006
20007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20009 if (SWIG_arg_fail(1)) SWIG_fail;
20010 {
20011 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20012 if (SWIG_arg_fail(2)) SWIG_fail;
20013 }
20014 if (obj2) {
20015 {
20016 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20017 if (SWIG_arg_fail(3)) SWIG_fail;
20018 }
20019 }
20020 {
20021 PyThreadState* __tstate = wxPyBeginAllowThreads();
20022 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20023
20024 wxPyEndAllowThreads(__tstate);
20025 if (PyErr_Occurred()) SWIG_fail;
20026 }
20027 {
20028 wxDateTime * resultptr;
20029 resultptr = new wxDateTime((wxDateTime &)(result));
20030 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20031 }
20032 return resultobj;
20033 fail:
20034 return NULL;
20035 }
20036
20037
20038 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20039 PyObject *resultobj;
20040 wxDateTime *arg1 = (wxDateTime *) 0 ;
20041 wxDateTime::WeekDay arg2 ;
20042 wxDateTime *result;
20043 PyObject * obj0 = 0 ;
20044 PyObject * obj1 = 0 ;
20045 char *kwnames[] = {
20046 (char *) "self",(char *) "weekday", NULL
20047 };
20048
20049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20051 if (SWIG_arg_fail(1)) SWIG_fail;
20052 {
20053 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20054 if (SWIG_arg_fail(2)) SWIG_fail;
20055 }
20056 {
20057 PyThreadState* __tstate = wxPyBeginAllowThreads();
20058 {
20059 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20060 result = (wxDateTime *) &_result_ref;
20061 }
20062
20063 wxPyEndAllowThreads(__tstate);
20064 if (PyErr_Occurred()) SWIG_fail;
20065 }
20066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20067 return resultobj;
20068 fail:
20069 return NULL;
20070 }
20071
20072
20073 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20074 PyObject *resultobj;
20075 wxDateTime *arg1 = (wxDateTime *) 0 ;
20076 wxDateTime::WeekDay arg2 ;
20077 wxDateTime result;
20078 PyObject * obj0 = 0 ;
20079 PyObject * obj1 = 0 ;
20080 char *kwnames[] = {
20081 (char *) "self",(char *) "weekday", NULL
20082 };
20083
20084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20086 if (SWIG_arg_fail(1)) SWIG_fail;
20087 {
20088 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20089 if (SWIG_arg_fail(2)) SWIG_fail;
20090 }
20091 {
20092 PyThreadState* __tstate = wxPyBeginAllowThreads();
20093 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20094
20095 wxPyEndAllowThreads(__tstate);
20096 if (PyErr_Occurred()) SWIG_fail;
20097 }
20098 {
20099 wxDateTime * resultptr;
20100 resultptr = new wxDateTime((wxDateTime &)(result));
20101 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20102 }
20103 return resultobj;
20104 fail:
20105 return NULL;
20106 }
20107
20108
20109 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20110 PyObject *resultobj;
20111 wxDateTime *arg1 = (wxDateTime *) 0 ;
20112 wxDateTime::WeekDay arg2 ;
20113 wxDateTime *result;
20114 PyObject * obj0 = 0 ;
20115 PyObject * obj1 = 0 ;
20116 char *kwnames[] = {
20117 (char *) "self",(char *) "weekday", NULL
20118 };
20119
20120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20122 if (SWIG_arg_fail(1)) SWIG_fail;
20123 {
20124 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20125 if (SWIG_arg_fail(2)) SWIG_fail;
20126 }
20127 {
20128 PyThreadState* __tstate = wxPyBeginAllowThreads();
20129 {
20130 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20131 result = (wxDateTime *) &_result_ref;
20132 }
20133
20134 wxPyEndAllowThreads(__tstate);
20135 if (PyErr_Occurred()) SWIG_fail;
20136 }
20137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20138 return resultobj;
20139 fail:
20140 return NULL;
20141 }
20142
20143
20144 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20145 PyObject *resultobj;
20146 wxDateTime *arg1 = (wxDateTime *) 0 ;
20147 wxDateTime::WeekDay arg2 ;
20148 wxDateTime result;
20149 PyObject * obj0 = 0 ;
20150 PyObject * obj1 = 0 ;
20151 char *kwnames[] = {
20152 (char *) "self",(char *) "weekday", NULL
20153 };
20154
20155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20157 if (SWIG_arg_fail(1)) SWIG_fail;
20158 {
20159 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20160 if (SWIG_arg_fail(2)) SWIG_fail;
20161 }
20162 {
20163 PyThreadState* __tstate = wxPyBeginAllowThreads();
20164 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20165
20166 wxPyEndAllowThreads(__tstate);
20167 if (PyErr_Occurred()) SWIG_fail;
20168 }
20169 {
20170 wxDateTime * resultptr;
20171 resultptr = new wxDateTime((wxDateTime &)(result));
20172 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20173 }
20174 return resultobj;
20175 fail:
20176 return NULL;
20177 }
20178
20179
20180 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20181 PyObject *resultobj;
20182 wxDateTime *arg1 = (wxDateTime *) 0 ;
20183 wxDateTime::WeekDay arg2 ;
20184 int arg3 = (int) 1 ;
20185 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20186 int arg5 = (int) wxDateTime::Inv_Year ;
20187 bool result;
20188 PyObject * obj0 = 0 ;
20189 PyObject * obj1 = 0 ;
20190 PyObject * obj2 = 0 ;
20191 PyObject * obj3 = 0 ;
20192 PyObject * obj4 = 0 ;
20193 char *kwnames[] = {
20194 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20195 };
20196
20197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20199 if (SWIG_arg_fail(1)) SWIG_fail;
20200 {
20201 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20202 if (SWIG_arg_fail(2)) SWIG_fail;
20203 }
20204 if (obj2) {
20205 {
20206 arg3 = (int)(SWIG_As_int(obj2));
20207 if (SWIG_arg_fail(3)) SWIG_fail;
20208 }
20209 }
20210 if (obj3) {
20211 {
20212 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20213 if (SWIG_arg_fail(4)) SWIG_fail;
20214 }
20215 }
20216 if (obj4) {
20217 {
20218 arg5 = (int)(SWIG_As_int(obj4));
20219 if (SWIG_arg_fail(5)) SWIG_fail;
20220 }
20221 }
20222 {
20223 PyThreadState* __tstate = wxPyBeginAllowThreads();
20224 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20225
20226 wxPyEndAllowThreads(__tstate);
20227 if (PyErr_Occurred()) SWIG_fail;
20228 }
20229 {
20230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20231 }
20232 return resultobj;
20233 fail:
20234 return NULL;
20235 }
20236
20237
20238 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20239 PyObject *resultobj;
20240 wxDateTime *arg1 = (wxDateTime *) 0 ;
20241 wxDateTime::WeekDay arg2 ;
20242 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20243 int arg4 = (int) wxDateTime::Inv_Year ;
20244 bool result;
20245 PyObject * obj0 = 0 ;
20246 PyObject * obj1 = 0 ;
20247 PyObject * obj2 = 0 ;
20248 PyObject * obj3 = 0 ;
20249 char *kwnames[] = {
20250 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20251 };
20252
20253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20255 if (SWIG_arg_fail(1)) SWIG_fail;
20256 {
20257 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20258 if (SWIG_arg_fail(2)) SWIG_fail;
20259 }
20260 if (obj2) {
20261 {
20262 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20263 if (SWIG_arg_fail(3)) SWIG_fail;
20264 }
20265 }
20266 if (obj3) {
20267 {
20268 arg4 = (int)(SWIG_As_int(obj3));
20269 if (SWIG_arg_fail(4)) SWIG_fail;
20270 }
20271 }
20272 {
20273 PyThreadState* __tstate = wxPyBeginAllowThreads();
20274 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20275
20276 wxPyEndAllowThreads(__tstate);
20277 if (PyErr_Occurred()) SWIG_fail;
20278 }
20279 {
20280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20281 }
20282 return resultobj;
20283 fail:
20284 return NULL;
20285 }
20286
20287
20288 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20289 PyObject *resultobj;
20290 wxDateTime *arg1 = (wxDateTime *) 0 ;
20291 wxDateTime::WeekDay arg2 ;
20292 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20293 int arg4 = (int) wxDateTime::Inv_Year ;
20294 wxDateTime result;
20295 PyObject * obj0 = 0 ;
20296 PyObject * obj1 = 0 ;
20297 PyObject * obj2 = 0 ;
20298 PyObject * obj3 = 0 ;
20299 char *kwnames[] = {
20300 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20301 };
20302
20303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20305 if (SWIG_arg_fail(1)) SWIG_fail;
20306 {
20307 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20308 if (SWIG_arg_fail(2)) SWIG_fail;
20309 }
20310 if (obj2) {
20311 {
20312 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20313 if (SWIG_arg_fail(3)) SWIG_fail;
20314 }
20315 }
20316 if (obj3) {
20317 {
20318 arg4 = (int)(SWIG_As_int(obj3));
20319 if (SWIG_arg_fail(4)) SWIG_fail;
20320 }
20321 }
20322 {
20323 PyThreadState* __tstate = wxPyBeginAllowThreads();
20324 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20325
20326 wxPyEndAllowThreads(__tstate);
20327 if (PyErr_Occurred()) SWIG_fail;
20328 }
20329 {
20330 wxDateTime * resultptr;
20331 resultptr = new wxDateTime((wxDateTime &)(result));
20332 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20333 }
20334 return resultobj;
20335 fail:
20336 return NULL;
20337 }
20338
20339
20340 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20341 PyObject *resultobj;
20342 wxDateTime *arg1 = (wxDateTime *) 0 ;
20343 int arg2 ;
20344 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20345 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20346 bool result;
20347 PyObject * obj0 = 0 ;
20348 PyObject * obj1 = 0 ;
20349 PyObject * obj2 = 0 ;
20350 PyObject * obj3 = 0 ;
20351 char *kwnames[] = {
20352 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20353 };
20354
20355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20357 if (SWIG_arg_fail(1)) SWIG_fail;
20358 {
20359 arg2 = (int)(SWIG_As_int(obj1));
20360 if (SWIG_arg_fail(2)) SWIG_fail;
20361 }
20362 if (obj2) {
20363 {
20364 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20365 if (SWIG_arg_fail(3)) SWIG_fail;
20366 }
20367 }
20368 if (obj3) {
20369 {
20370 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20371 if (SWIG_arg_fail(4)) SWIG_fail;
20372 }
20373 }
20374 {
20375 PyThreadState* __tstate = wxPyBeginAllowThreads();
20376 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20377
20378 wxPyEndAllowThreads(__tstate);
20379 if (PyErr_Occurred()) SWIG_fail;
20380 }
20381 {
20382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20383 }
20384 return resultobj;
20385 fail:
20386 return NULL;
20387 }
20388
20389
20390 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20391 PyObject *resultobj;
20392 wxDateTime *arg1 = (wxDateTime *) 0 ;
20393 int arg2 ;
20394 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20395 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20396 wxDateTime result;
20397 PyObject * obj0 = 0 ;
20398 PyObject * obj1 = 0 ;
20399 PyObject * obj2 = 0 ;
20400 PyObject * obj3 = 0 ;
20401 char *kwnames[] = {
20402 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20403 };
20404
20405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20407 if (SWIG_arg_fail(1)) SWIG_fail;
20408 {
20409 arg2 = (int)(SWIG_As_int(obj1));
20410 if (SWIG_arg_fail(2)) SWIG_fail;
20411 }
20412 if (obj2) {
20413 {
20414 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20415 if (SWIG_arg_fail(3)) SWIG_fail;
20416 }
20417 }
20418 if (obj3) {
20419 {
20420 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20421 if (SWIG_arg_fail(4)) SWIG_fail;
20422 }
20423 }
20424 {
20425 PyThreadState* __tstate = wxPyBeginAllowThreads();
20426 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20427
20428 wxPyEndAllowThreads(__tstate);
20429 if (PyErr_Occurred()) SWIG_fail;
20430 }
20431 {
20432 wxDateTime * resultptr;
20433 resultptr = new wxDateTime((wxDateTime &)(result));
20434 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20435 }
20436 return resultobj;
20437 fail:
20438 return NULL;
20439 }
20440
20441
20442 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20443 PyObject *resultobj;
20444 int arg1 ;
20445 int arg2 ;
20446 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20447 wxDateTime result;
20448 PyObject * obj0 = 0 ;
20449 PyObject * obj1 = 0 ;
20450 PyObject * obj2 = 0 ;
20451 char *kwnames[] = {
20452 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20453 };
20454
20455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20456 {
20457 arg1 = (int)(SWIG_As_int(obj0));
20458 if (SWIG_arg_fail(1)) SWIG_fail;
20459 }
20460 {
20461 arg2 = (int)(SWIG_As_int(obj1));
20462 if (SWIG_arg_fail(2)) SWIG_fail;
20463 }
20464 if (obj2) {
20465 {
20466 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20467 if (SWIG_arg_fail(3)) SWIG_fail;
20468 }
20469 }
20470 {
20471 PyThreadState* __tstate = wxPyBeginAllowThreads();
20472 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20473
20474 wxPyEndAllowThreads(__tstate);
20475 if (PyErr_Occurred()) SWIG_fail;
20476 }
20477 {
20478 wxDateTime * resultptr;
20479 resultptr = new wxDateTime((wxDateTime &)(result));
20480 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20481 }
20482 return resultobj;
20483 fail:
20484 return NULL;
20485 }
20486
20487
20488 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20489 PyObject *resultobj;
20490 wxDateTime *arg1 = (wxDateTime *) 0 ;
20491 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20492 int arg3 = (int) wxDateTime::Inv_Year ;
20493 wxDateTime *result;
20494 PyObject * obj0 = 0 ;
20495 PyObject * obj1 = 0 ;
20496 PyObject * obj2 = 0 ;
20497 char *kwnames[] = {
20498 (char *) "self",(char *) "month",(char *) "year", NULL
20499 };
20500
20501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20503 if (SWIG_arg_fail(1)) SWIG_fail;
20504 if (obj1) {
20505 {
20506 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20507 if (SWIG_arg_fail(2)) SWIG_fail;
20508 }
20509 }
20510 if (obj2) {
20511 {
20512 arg3 = (int)(SWIG_As_int(obj2));
20513 if (SWIG_arg_fail(3)) SWIG_fail;
20514 }
20515 }
20516 {
20517 PyThreadState* __tstate = wxPyBeginAllowThreads();
20518 {
20519 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20520 result = (wxDateTime *) &_result_ref;
20521 }
20522
20523 wxPyEndAllowThreads(__tstate);
20524 if (PyErr_Occurred()) SWIG_fail;
20525 }
20526 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20527 return resultobj;
20528 fail:
20529 return NULL;
20530 }
20531
20532
20533 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20534 PyObject *resultobj;
20535 wxDateTime *arg1 = (wxDateTime *) 0 ;
20536 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20537 int arg3 = (int) wxDateTime::Inv_Year ;
20538 wxDateTime result;
20539 PyObject * obj0 = 0 ;
20540 PyObject * obj1 = 0 ;
20541 PyObject * obj2 = 0 ;
20542 char *kwnames[] = {
20543 (char *) "self",(char *) "month",(char *) "year", NULL
20544 };
20545
20546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20548 if (SWIG_arg_fail(1)) SWIG_fail;
20549 if (obj1) {
20550 {
20551 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20552 if (SWIG_arg_fail(2)) SWIG_fail;
20553 }
20554 }
20555 if (obj2) {
20556 {
20557 arg3 = (int)(SWIG_As_int(obj2));
20558 if (SWIG_arg_fail(3)) SWIG_fail;
20559 }
20560 }
20561 {
20562 PyThreadState* __tstate = wxPyBeginAllowThreads();
20563 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20564
20565 wxPyEndAllowThreads(__tstate);
20566 if (PyErr_Occurred()) SWIG_fail;
20567 }
20568 {
20569 wxDateTime * resultptr;
20570 resultptr = new wxDateTime((wxDateTime &)(result));
20571 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20572 }
20573 return resultobj;
20574 fail:
20575 return NULL;
20576 }
20577
20578
20579 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20580 PyObject *resultobj;
20581 wxDateTime *arg1 = (wxDateTime *) 0 ;
20582 int arg2 ;
20583 wxDateTime *result;
20584 PyObject * obj0 = 0 ;
20585 PyObject * obj1 = 0 ;
20586 char *kwnames[] = {
20587 (char *) "self",(char *) "yday", NULL
20588 };
20589
20590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20592 if (SWIG_arg_fail(1)) SWIG_fail;
20593 {
20594 arg2 = (int)(SWIG_As_int(obj1));
20595 if (SWIG_arg_fail(2)) SWIG_fail;
20596 }
20597 {
20598 PyThreadState* __tstate = wxPyBeginAllowThreads();
20599 {
20600 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20601 result = (wxDateTime *) &_result_ref;
20602 }
20603
20604 wxPyEndAllowThreads(__tstate);
20605 if (PyErr_Occurred()) SWIG_fail;
20606 }
20607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20608 return resultobj;
20609 fail:
20610 return NULL;
20611 }
20612
20613
20614 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20615 PyObject *resultobj;
20616 wxDateTime *arg1 = (wxDateTime *) 0 ;
20617 int arg2 ;
20618 wxDateTime result;
20619 PyObject * obj0 = 0 ;
20620 PyObject * obj1 = 0 ;
20621 char *kwnames[] = {
20622 (char *) "self",(char *) "yday", NULL
20623 };
20624
20625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20627 if (SWIG_arg_fail(1)) SWIG_fail;
20628 {
20629 arg2 = (int)(SWIG_As_int(obj1));
20630 if (SWIG_arg_fail(2)) SWIG_fail;
20631 }
20632 {
20633 PyThreadState* __tstate = wxPyBeginAllowThreads();
20634 result = (arg1)->GetYearDay(arg2);
20635
20636 wxPyEndAllowThreads(__tstate);
20637 if (PyErr_Occurred()) SWIG_fail;
20638 }
20639 {
20640 wxDateTime * resultptr;
20641 resultptr = new wxDateTime((wxDateTime &)(result));
20642 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20643 }
20644 return resultobj;
20645 fail:
20646 return NULL;
20647 }
20648
20649
20650 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20651 PyObject *resultobj;
20652 wxDateTime *arg1 = (wxDateTime *) 0 ;
20653 double result;
20654 PyObject * obj0 = 0 ;
20655 char *kwnames[] = {
20656 (char *) "self", NULL
20657 };
20658
20659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
20660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20661 if (SWIG_arg_fail(1)) SWIG_fail;
20662 {
20663 PyThreadState* __tstate = wxPyBeginAllowThreads();
20664 result = (double)(arg1)->GetJulianDayNumber();
20665
20666 wxPyEndAllowThreads(__tstate);
20667 if (PyErr_Occurred()) SWIG_fail;
20668 }
20669 {
20670 resultobj = SWIG_From_double((double)(result));
20671 }
20672 return resultobj;
20673 fail:
20674 return NULL;
20675 }
20676
20677
20678 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
20679 PyObject *resultobj;
20680 wxDateTime *arg1 = (wxDateTime *) 0 ;
20681 double result;
20682 PyObject * obj0 = 0 ;
20683 char *kwnames[] = {
20684 (char *) "self", NULL
20685 };
20686
20687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
20688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20689 if (SWIG_arg_fail(1)) SWIG_fail;
20690 {
20691 PyThreadState* __tstate = wxPyBeginAllowThreads();
20692 result = (double)(arg1)->GetJDN();
20693
20694 wxPyEndAllowThreads(__tstate);
20695 if (PyErr_Occurred()) SWIG_fail;
20696 }
20697 {
20698 resultobj = SWIG_From_double((double)(result));
20699 }
20700 return resultobj;
20701 fail:
20702 return NULL;
20703 }
20704
20705
20706 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20707 PyObject *resultobj;
20708 wxDateTime *arg1 = (wxDateTime *) 0 ;
20709 double result;
20710 PyObject * obj0 = 0 ;
20711 char *kwnames[] = {
20712 (char *) "self", NULL
20713 };
20714
20715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
20716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20717 if (SWIG_arg_fail(1)) SWIG_fail;
20718 {
20719 PyThreadState* __tstate = wxPyBeginAllowThreads();
20720 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
20721
20722 wxPyEndAllowThreads(__tstate);
20723 if (PyErr_Occurred()) SWIG_fail;
20724 }
20725 {
20726 resultobj = SWIG_From_double((double)(result));
20727 }
20728 return resultobj;
20729 fail:
20730 return NULL;
20731 }
20732
20733
20734 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
20735 PyObject *resultobj;
20736 wxDateTime *arg1 = (wxDateTime *) 0 ;
20737 double result;
20738 PyObject * obj0 = 0 ;
20739 char *kwnames[] = {
20740 (char *) "self", NULL
20741 };
20742
20743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
20744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20745 if (SWIG_arg_fail(1)) SWIG_fail;
20746 {
20747 PyThreadState* __tstate = wxPyBeginAllowThreads();
20748 result = (double)(arg1)->GetMJD();
20749
20750 wxPyEndAllowThreads(__tstate);
20751 if (PyErr_Occurred()) SWIG_fail;
20752 }
20753 {
20754 resultobj = SWIG_From_double((double)(result));
20755 }
20756 return resultobj;
20757 fail:
20758 return NULL;
20759 }
20760
20761
20762 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
20763 PyObject *resultobj;
20764 wxDateTime *arg1 = (wxDateTime *) 0 ;
20765 double result;
20766 PyObject * obj0 = 0 ;
20767 char *kwnames[] = {
20768 (char *) "self", NULL
20769 };
20770
20771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
20772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20773 if (SWIG_arg_fail(1)) SWIG_fail;
20774 {
20775 PyThreadState* __tstate = wxPyBeginAllowThreads();
20776 result = (double)(arg1)->GetRataDie();
20777
20778 wxPyEndAllowThreads(__tstate);
20779 if (PyErr_Occurred()) SWIG_fail;
20780 }
20781 {
20782 resultobj = SWIG_From_double((double)(result));
20783 }
20784 return resultobj;
20785 fail:
20786 return NULL;
20787 }
20788
20789
20790 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
20791 PyObject *resultobj;
20792 wxDateTime *arg1 = (wxDateTime *) 0 ;
20793 wxDateTime::TimeZone *arg2 = 0 ;
20794 bool arg3 = (bool) false ;
20795 wxDateTime result;
20796 bool temp2 = false ;
20797 PyObject * obj0 = 0 ;
20798 PyObject * obj1 = 0 ;
20799 PyObject * obj2 = 0 ;
20800 char *kwnames[] = {
20801 (char *) "self",(char *) "tz",(char *) "noDST", NULL
20802 };
20803
20804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
20805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20806 if (SWIG_arg_fail(1)) SWIG_fail;
20807 {
20808 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
20809 temp2 = true;
20810 }
20811 if (obj2) {
20812 {
20813 arg3 = (bool)(SWIG_As_bool(obj2));
20814 if (SWIG_arg_fail(3)) SWIG_fail;
20815 }
20816 }
20817 {
20818 PyThreadState* __tstate = wxPyBeginAllowThreads();
20819 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
20820
20821 wxPyEndAllowThreads(__tstate);
20822 if (PyErr_Occurred()) SWIG_fail;
20823 }
20824 {
20825 wxDateTime * resultptr;
20826 resultptr = new wxDateTime((wxDateTime &)(result));
20827 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20828 }
20829 {
20830 if (temp2) delete arg2;
20831 }
20832 return resultobj;
20833 fail:
20834 {
20835 if (temp2) delete arg2;
20836 }
20837 return NULL;
20838 }
20839
20840
20841 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
20842 PyObject *resultobj;
20843 wxDateTime *arg1 = (wxDateTime *) 0 ;
20844 wxDateTime::TimeZone *arg2 = 0 ;
20845 bool arg3 = (bool) false ;
20846 wxDateTime *result;
20847 bool temp2 = false ;
20848 PyObject * obj0 = 0 ;
20849 PyObject * obj1 = 0 ;
20850 PyObject * obj2 = 0 ;
20851 char *kwnames[] = {
20852 (char *) "self",(char *) "tz",(char *) "noDST", NULL
20853 };
20854
20855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
20856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20857 if (SWIG_arg_fail(1)) SWIG_fail;
20858 {
20859 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
20860 temp2 = true;
20861 }
20862 if (obj2) {
20863 {
20864 arg3 = (bool)(SWIG_As_bool(obj2));
20865 if (SWIG_arg_fail(3)) SWIG_fail;
20866 }
20867 }
20868 {
20869 PyThreadState* __tstate = wxPyBeginAllowThreads();
20870 {
20871 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
20872 result = (wxDateTime *) &_result_ref;
20873 }
20874
20875 wxPyEndAllowThreads(__tstate);
20876 if (PyErr_Occurred()) SWIG_fail;
20877 }
20878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20879 {
20880 if (temp2) delete arg2;
20881 }
20882 return resultobj;
20883 fail:
20884 {
20885 if (temp2) delete arg2;
20886 }
20887 return NULL;
20888 }
20889
20890
20891 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
20892 PyObject *resultobj;
20893 wxDateTime *arg1 = (wxDateTime *) 0 ;
20894 bool arg2 = (bool) false ;
20895 wxDateTime result;
20896 PyObject * obj0 = 0 ;
20897 PyObject * obj1 = 0 ;
20898 char *kwnames[] = {
20899 (char *) "self",(char *) "noDST", NULL
20900 };
20901
20902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
20903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20904 if (SWIG_arg_fail(1)) SWIG_fail;
20905 if (obj1) {
20906 {
20907 arg2 = (bool)(SWIG_As_bool(obj1));
20908 if (SWIG_arg_fail(2)) SWIG_fail;
20909 }
20910 }
20911 {
20912 PyThreadState* __tstate = wxPyBeginAllowThreads();
20913 result = (arg1)->ToGMT(arg2);
20914
20915 wxPyEndAllowThreads(__tstate);
20916 if (PyErr_Occurred()) SWIG_fail;
20917 }
20918 {
20919 wxDateTime * resultptr;
20920 resultptr = new wxDateTime((wxDateTime &)(result));
20921 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20922 }
20923 return resultobj;
20924 fail:
20925 return NULL;
20926 }
20927
20928
20929 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
20930 PyObject *resultobj;
20931 wxDateTime *arg1 = (wxDateTime *) 0 ;
20932 bool arg2 = (bool) false ;
20933 wxDateTime *result;
20934 PyObject * obj0 = 0 ;
20935 PyObject * obj1 = 0 ;
20936 char *kwnames[] = {
20937 (char *) "self",(char *) "noDST", NULL
20938 };
20939
20940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
20941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20942 if (SWIG_arg_fail(1)) SWIG_fail;
20943 if (obj1) {
20944 {
20945 arg2 = (bool)(SWIG_As_bool(obj1));
20946 if (SWIG_arg_fail(2)) SWIG_fail;
20947 }
20948 }
20949 {
20950 PyThreadState* __tstate = wxPyBeginAllowThreads();
20951 {
20952 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
20953 result = (wxDateTime *) &_result_ref;
20954 }
20955
20956 wxPyEndAllowThreads(__tstate);
20957 if (PyErr_Occurred()) SWIG_fail;
20958 }
20959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20960 return resultobj;
20961 fail:
20962 return NULL;
20963 }
20964
20965
20966 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
20967 PyObject *resultobj;
20968 wxDateTime *arg1 = (wxDateTime *) 0 ;
20969 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
20970 int result;
20971 PyObject * obj0 = 0 ;
20972 PyObject * obj1 = 0 ;
20973 char *kwnames[] = {
20974 (char *) "self",(char *) "country", NULL
20975 };
20976
20977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
20978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20979 if (SWIG_arg_fail(1)) SWIG_fail;
20980 if (obj1) {
20981 {
20982 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
20983 if (SWIG_arg_fail(2)) SWIG_fail;
20984 }
20985 }
20986 {
20987 PyThreadState* __tstate = wxPyBeginAllowThreads();
20988 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
20989
20990 wxPyEndAllowThreads(__tstate);
20991 if (PyErr_Occurred()) SWIG_fail;
20992 }
20993 {
20994 resultobj = SWIG_From_int((int)(result));
20995 }
20996 return resultobj;
20997 fail:
20998 return NULL;
20999 }
21000
21001
21002 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21003 PyObject *resultobj;
21004 wxDateTime *arg1 = (wxDateTime *) 0 ;
21005 bool result;
21006 PyObject * obj0 = 0 ;
21007 char *kwnames[] = {
21008 (char *) "self", NULL
21009 };
21010
21011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21013 if (SWIG_arg_fail(1)) SWIG_fail;
21014 {
21015 PyThreadState* __tstate = wxPyBeginAllowThreads();
21016 result = (bool)((wxDateTime const *)arg1)->IsValid();
21017
21018 wxPyEndAllowThreads(__tstate);
21019 if (PyErr_Occurred()) SWIG_fail;
21020 }
21021 {
21022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21023 }
21024 return resultobj;
21025 fail:
21026 return NULL;
21027 }
21028
21029
21030 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21031 PyObject *resultobj;
21032 wxDateTime *arg1 = (wxDateTime *) 0 ;
21033 time_t result;
21034 PyObject * obj0 = 0 ;
21035 char *kwnames[] = {
21036 (char *) "self", NULL
21037 };
21038
21039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21041 if (SWIG_arg_fail(1)) SWIG_fail;
21042 {
21043 PyThreadState* __tstate = wxPyBeginAllowThreads();
21044 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21045
21046 wxPyEndAllowThreads(__tstate);
21047 if (PyErr_Occurred()) SWIG_fail;
21048 }
21049 {
21050 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21051 }
21052 return resultobj;
21053 fail:
21054 return NULL;
21055 }
21056
21057
21058 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21059 PyObject *resultobj;
21060 wxDateTime *arg1 = (wxDateTime *) 0 ;
21061 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21062 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21063 int result;
21064 bool temp2 = false ;
21065 PyObject * obj0 = 0 ;
21066 PyObject * obj1 = 0 ;
21067 char *kwnames[] = {
21068 (char *) "self",(char *) "tz", NULL
21069 };
21070
21071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21073 if (SWIG_arg_fail(1)) SWIG_fail;
21074 if (obj1) {
21075 {
21076 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21077 temp2 = true;
21078 }
21079 }
21080 {
21081 PyThreadState* __tstate = wxPyBeginAllowThreads();
21082 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21083
21084 wxPyEndAllowThreads(__tstate);
21085 if (PyErr_Occurred()) SWIG_fail;
21086 }
21087 {
21088 resultobj = SWIG_From_int((int)(result));
21089 }
21090 {
21091 if (temp2) delete arg2;
21092 }
21093 return resultobj;
21094 fail:
21095 {
21096 if (temp2) delete arg2;
21097 }
21098 return NULL;
21099 }
21100
21101
21102 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21103 PyObject *resultobj;
21104 wxDateTime *arg1 = (wxDateTime *) 0 ;
21105 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21106 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21107 wxDateTime::Month result;
21108 bool temp2 = false ;
21109 PyObject * obj0 = 0 ;
21110 PyObject * obj1 = 0 ;
21111 char *kwnames[] = {
21112 (char *) "self",(char *) "tz", NULL
21113 };
21114
21115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21117 if (SWIG_arg_fail(1)) SWIG_fail;
21118 if (obj1) {
21119 {
21120 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21121 temp2 = true;
21122 }
21123 }
21124 {
21125 PyThreadState* __tstate = wxPyBeginAllowThreads();
21126 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21127
21128 wxPyEndAllowThreads(__tstate);
21129 if (PyErr_Occurred()) SWIG_fail;
21130 }
21131 resultobj = SWIG_From_int((result));
21132 {
21133 if (temp2) delete arg2;
21134 }
21135 return resultobj;
21136 fail:
21137 {
21138 if (temp2) delete arg2;
21139 }
21140 return NULL;
21141 }
21142
21143
21144 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21145 PyObject *resultobj;
21146 wxDateTime *arg1 = (wxDateTime *) 0 ;
21147 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21148 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21149 int result;
21150 bool temp2 = false ;
21151 PyObject * obj0 = 0 ;
21152 PyObject * obj1 = 0 ;
21153 char *kwnames[] = {
21154 (char *) "self",(char *) "tz", NULL
21155 };
21156
21157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21159 if (SWIG_arg_fail(1)) SWIG_fail;
21160 if (obj1) {
21161 {
21162 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21163 temp2 = true;
21164 }
21165 }
21166 {
21167 PyThreadState* __tstate = wxPyBeginAllowThreads();
21168 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21169
21170 wxPyEndAllowThreads(__tstate);
21171 if (PyErr_Occurred()) SWIG_fail;
21172 }
21173 {
21174 resultobj = SWIG_From_int((int)(result));
21175 }
21176 {
21177 if (temp2) delete arg2;
21178 }
21179 return resultobj;
21180 fail:
21181 {
21182 if (temp2) delete arg2;
21183 }
21184 return NULL;
21185 }
21186
21187
21188 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21189 PyObject *resultobj;
21190 wxDateTime *arg1 = (wxDateTime *) 0 ;
21191 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21192 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21193 wxDateTime::WeekDay result;
21194 bool temp2 = false ;
21195 PyObject * obj0 = 0 ;
21196 PyObject * obj1 = 0 ;
21197 char *kwnames[] = {
21198 (char *) "self",(char *) "tz", NULL
21199 };
21200
21201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21203 if (SWIG_arg_fail(1)) SWIG_fail;
21204 if (obj1) {
21205 {
21206 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21207 temp2 = true;
21208 }
21209 }
21210 {
21211 PyThreadState* __tstate = wxPyBeginAllowThreads();
21212 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21213
21214 wxPyEndAllowThreads(__tstate);
21215 if (PyErr_Occurred()) SWIG_fail;
21216 }
21217 resultobj = SWIG_From_int((result));
21218 {
21219 if (temp2) delete arg2;
21220 }
21221 return resultobj;
21222 fail:
21223 {
21224 if (temp2) delete arg2;
21225 }
21226 return NULL;
21227 }
21228
21229
21230 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21231 PyObject *resultobj;
21232 wxDateTime *arg1 = (wxDateTime *) 0 ;
21233 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21234 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21235 int result;
21236 bool temp2 = false ;
21237 PyObject * obj0 = 0 ;
21238 PyObject * obj1 = 0 ;
21239 char *kwnames[] = {
21240 (char *) "self",(char *) "tz", NULL
21241 };
21242
21243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21245 if (SWIG_arg_fail(1)) SWIG_fail;
21246 if (obj1) {
21247 {
21248 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21249 temp2 = true;
21250 }
21251 }
21252 {
21253 PyThreadState* __tstate = wxPyBeginAllowThreads();
21254 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21255
21256 wxPyEndAllowThreads(__tstate);
21257 if (PyErr_Occurred()) SWIG_fail;
21258 }
21259 {
21260 resultobj = SWIG_From_int((int)(result));
21261 }
21262 {
21263 if (temp2) delete arg2;
21264 }
21265 return resultobj;
21266 fail:
21267 {
21268 if (temp2) delete arg2;
21269 }
21270 return NULL;
21271 }
21272
21273
21274 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21275 PyObject *resultobj;
21276 wxDateTime *arg1 = (wxDateTime *) 0 ;
21277 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21278 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21279 int result;
21280 bool temp2 = false ;
21281 PyObject * obj0 = 0 ;
21282 PyObject * obj1 = 0 ;
21283 char *kwnames[] = {
21284 (char *) "self",(char *) "tz", NULL
21285 };
21286
21287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21289 if (SWIG_arg_fail(1)) SWIG_fail;
21290 if (obj1) {
21291 {
21292 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21293 temp2 = true;
21294 }
21295 }
21296 {
21297 PyThreadState* __tstate = wxPyBeginAllowThreads();
21298 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21299
21300 wxPyEndAllowThreads(__tstate);
21301 if (PyErr_Occurred()) SWIG_fail;
21302 }
21303 {
21304 resultobj = SWIG_From_int((int)(result));
21305 }
21306 {
21307 if (temp2) delete arg2;
21308 }
21309 return resultobj;
21310 fail:
21311 {
21312 if (temp2) delete arg2;
21313 }
21314 return NULL;
21315 }
21316
21317
21318 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21319 PyObject *resultobj;
21320 wxDateTime *arg1 = (wxDateTime *) 0 ;
21321 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21322 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21323 int result;
21324 bool temp2 = false ;
21325 PyObject * obj0 = 0 ;
21326 PyObject * obj1 = 0 ;
21327 char *kwnames[] = {
21328 (char *) "self",(char *) "tz", NULL
21329 };
21330
21331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21333 if (SWIG_arg_fail(1)) SWIG_fail;
21334 if (obj1) {
21335 {
21336 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21337 temp2 = true;
21338 }
21339 }
21340 {
21341 PyThreadState* __tstate = wxPyBeginAllowThreads();
21342 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21343
21344 wxPyEndAllowThreads(__tstate);
21345 if (PyErr_Occurred()) SWIG_fail;
21346 }
21347 {
21348 resultobj = SWIG_From_int((int)(result));
21349 }
21350 {
21351 if (temp2) delete arg2;
21352 }
21353 return resultobj;
21354 fail:
21355 {
21356 if (temp2) delete arg2;
21357 }
21358 return NULL;
21359 }
21360
21361
21362 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21363 PyObject *resultobj;
21364 wxDateTime *arg1 = (wxDateTime *) 0 ;
21365 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21366 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21367 int result;
21368 bool temp2 = false ;
21369 PyObject * obj0 = 0 ;
21370 PyObject * obj1 = 0 ;
21371 char *kwnames[] = {
21372 (char *) "self",(char *) "tz", NULL
21373 };
21374
21375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21377 if (SWIG_arg_fail(1)) SWIG_fail;
21378 if (obj1) {
21379 {
21380 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21381 temp2 = true;
21382 }
21383 }
21384 {
21385 PyThreadState* __tstate = wxPyBeginAllowThreads();
21386 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21387
21388 wxPyEndAllowThreads(__tstate);
21389 if (PyErr_Occurred()) SWIG_fail;
21390 }
21391 {
21392 resultobj = SWIG_From_int((int)(result));
21393 }
21394 {
21395 if (temp2) delete arg2;
21396 }
21397 return resultobj;
21398 fail:
21399 {
21400 if (temp2) delete arg2;
21401 }
21402 return NULL;
21403 }
21404
21405
21406 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21407 PyObject *resultobj;
21408 wxDateTime *arg1 = (wxDateTime *) 0 ;
21409 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21410 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21411 int result;
21412 bool temp2 = false ;
21413 PyObject * obj0 = 0 ;
21414 PyObject * obj1 = 0 ;
21415 char *kwnames[] = {
21416 (char *) "self",(char *) "tz", NULL
21417 };
21418
21419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21421 if (SWIG_arg_fail(1)) SWIG_fail;
21422 if (obj1) {
21423 {
21424 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21425 temp2 = true;
21426 }
21427 }
21428 {
21429 PyThreadState* __tstate = wxPyBeginAllowThreads();
21430 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21431
21432 wxPyEndAllowThreads(__tstate);
21433 if (PyErr_Occurred()) SWIG_fail;
21434 }
21435 {
21436 resultobj = SWIG_From_int((int)(result));
21437 }
21438 {
21439 if (temp2) delete arg2;
21440 }
21441 return resultobj;
21442 fail:
21443 {
21444 if (temp2) delete arg2;
21445 }
21446 return NULL;
21447 }
21448
21449
21450 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21451 PyObject *resultobj;
21452 wxDateTime *arg1 = (wxDateTime *) 0 ;
21453 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21454 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21455 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21456 int result;
21457 bool temp3 = false ;
21458 PyObject * obj0 = 0 ;
21459 PyObject * obj1 = 0 ;
21460 PyObject * obj2 = 0 ;
21461 char *kwnames[] = {
21462 (char *) "self",(char *) "flags",(char *) "tz", NULL
21463 };
21464
21465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21467 if (SWIG_arg_fail(1)) SWIG_fail;
21468 if (obj1) {
21469 {
21470 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21471 if (SWIG_arg_fail(2)) SWIG_fail;
21472 }
21473 }
21474 if (obj2) {
21475 {
21476 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21477 temp3 = true;
21478 }
21479 }
21480 {
21481 PyThreadState* __tstate = wxPyBeginAllowThreads();
21482 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21483
21484 wxPyEndAllowThreads(__tstate);
21485 if (PyErr_Occurred()) SWIG_fail;
21486 }
21487 {
21488 resultobj = SWIG_From_int((int)(result));
21489 }
21490 {
21491 if (temp3) delete arg3;
21492 }
21493 return resultobj;
21494 fail:
21495 {
21496 if (temp3) delete arg3;
21497 }
21498 return NULL;
21499 }
21500
21501
21502 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21503 PyObject *resultobj;
21504 wxDateTime *arg1 = (wxDateTime *) 0 ;
21505 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21506 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21507 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21508 int result;
21509 bool temp3 = false ;
21510 PyObject * obj0 = 0 ;
21511 PyObject * obj1 = 0 ;
21512 PyObject * obj2 = 0 ;
21513 char *kwnames[] = {
21514 (char *) "self",(char *) "flags",(char *) "tz", NULL
21515 };
21516
21517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21519 if (SWIG_arg_fail(1)) SWIG_fail;
21520 if (obj1) {
21521 {
21522 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21523 if (SWIG_arg_fail(2)) SWIG_fail;
21524 }
21525 }
21526 if (obj2) {
21527 {
21528 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21529 temp3 = true;
21530 }
21531 }
21532 {
21533 PyThreadState* __tstate = wxPyBeginAllowThreads();
21534 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21535
21536 wxPyEndAllowThreads(__tstate);
21537 if (PyErr_Occurred()) SWIG_fail;
21538 }
21539 {
21540 resultobj = SWIG_From_int((int)(result));
21541 }
21542 {
21543 if (temp3) delete arg3;
21544 }
21545 return resultobj;
21546 fail:
21547 {
21548 if (temp3) delete arg3;
21549 }
21550 return NULL;
21551 }
21552
21553
21554 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21555 PyObject *resultobj;
21556 wxDateTime *arg1 = (wxDateTime *) 0 ;
21557 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21558 bool result;
21559 PyObject * obj0 = 0 ;
21560 PyObject * obj1 = 0 ;
21561 char *kwnames[] = {
21562 (char *) "self",(char *) "country", NULL
21563 };
21564
21565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21567 if (SWIG_arg_fail(1)) SWIG_fail;
21568 if (obj1) {
21569 {
21570 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21571 if (SWIG_arg_fail(2)) SWIG_fail;
21572 }
21573 }
21574 {
21575 PyThreadState* __tstate = wxPyBeginAllowThreads();
21576 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21577
21578 wxPyEndAllowThreads(__tstate);
21579 if (PyErr_Occurred()) SWIG_fail;
21580 }
21581 {
21582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21583 }
21584 return resultobj;
21585 fail:
21586 return NULL;
21587 }
21588
21589
21590 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21591 PyObject *resultobj;
21592 wxDateTime *arg1 = (wxDateTime *) 0 ;
21593 wxDateTime *arg2 = 0 ;
21594 bool result;
21595 PyObject * obj0 = 0 ;
21596 PyObject * obj1 = 0 ;
21597 char *kwnames[] = {
21598 (char *) "self",(char *) "datetime", NULL
21599 };
21600
21601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21603 if (SWIG_arg_fail(1)) SWIG_fail;
21604 {
21605 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21606 if (SWIG_arg_fail(2)) SWIG_fail;
21607 if (arg2 == NULL) {
21608 SWIG_null_ref("wxDateTime");
21609 }
21610 if (SWIG_arg_fail(2)) SWIG_fail;
21611 }
21612 {
21613 PyThreadState* __tstate = wxPyBeginAllowThreads();
21614 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21615
21616 wxPyEndAllowThreads(__tstate);
21617 if (PyErr_Occurred()) SWIG_fail;
21618 }
21619 {
21620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21621 }
21622 return resultobj;
21623 fail:
21624 return NULL;
21625 }
21626
21627
21628 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21629 PyObject *resultobj;
21630 wxDateTime *arg1 = (wxDateTime *) 0 ;
21631 wxDateTime *arg2 = 0 ;
21632 bool result;
21633 PyObject * obj0 = 0 ;
21634 PyObject * obj1 = 0 ;
21635 char *kwnames[] = {
21636 (char *) "self",(char *) "datetime", NULL
21637 };
21638
21639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21641 if (SWIG_arg_fail(1)) SWIG_fail;
21642 {
21643 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21644 if (SWIG_arg_fail(2)) SWIG_fail;
21645 if (arg2 == NULL) {
21646 SWIG_null_ref("wxDateTime");
21647 }
21648 if (SWIG_arg_fail(2)) SWIG_fail;
21649 }
21650 {
21651 PyThreadState* __tstate = wxPyBeginAllowThreads();
21652 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21653
21654 wxPyEndAllowThreads(__tstate);
21655 if (PyErr_Occurred()) SWIG_fail;
21656 }
21657 {
21658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21659 }
21660 return resultobj;
21661 fail:
21662 return NULL;
21663 }
21664
21665
21666 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
21667 PyObject *resultobj;
21668 wxDateTime *arg1 = (wxDateTime *) 0 ;
21669 wxDateTime *arg2 = 0 ;
21670 bool result;
21671 PyObject * obj0 = 0 ;
21672 PyObject * obj1 = 0 ;
21673 char *kwnames[] = {
21674 (char *) "self",(char *) "datetime", NULL
21675 };
21676
21677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
21678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21679 if (SWIG_arg_fail(1)) SWIG_fail;
21680 {
21681 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21682 if (SWIG_arg_fail(2)) SWIG_fail;
21683 if (arg2 == NULL) {
21684 SWIG_null_ref("wxDateTime");
21685 }
21686 if (SWIG_arg_fail(2)) SWIG_fail;
21687 }
21688 {
21689 PyThreadState* __tstate = wxPyBeginAllowThreads();
21690 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
21691
21692 wxPyEndAllowThreads(__tstate);
21693 if (PyErr_Occurred()) SWIG_fail;
21694 }
21695 {
21696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21697 }
21698 return resultobj;
21699 fail:
21700 return NULL;
21701 }
21702
21703
21704 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21705 PyObject *resultobj;
21706 wxDateTime *arg1 = (wxDateTime *) 0 ;
21707 wxDateTime *arg2 = 0 ;
21708 wxDateTime *arg3 = 0 ;
21709 bool result;
21710 PyObject * obj0 = 0 ;
21711 PyObject * obj1 = 0 ;
21712 PyObject * obj2 = 0 ;
21713 char *kwnames[] = {
21714 (char *) "self",(char *) "t1",(char *) "t2", NULL
21715 };
21716
21717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21719 if (SWIG_arg_fail(1)) SWIG_fail;
21720 {
21721 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21722 if (SWIG_arg_fail(2)) SWIG_fail;
21723 if (arg2 == NULL) {
21724 SWIG_null_ref("wxDateTime");
21725 }
21726 if (SWIG_arg_fail(2)) SWIG_fail;
21727 }
21728 {
21729 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21730 if (SWIG_arg_fail(3)) SWIG_fail;
21731 if (arg3 == NULL) {
21732 SWIG_null_ref("wxDateTime");
21733 }
21734 if (SWIG_arg_fail(3)) SWIG_fail;
21735 }
21736 {
21737 PyThreadState* __tstate = wxPyBeginAllowThreads();
21738 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21739
21740 wxPyEndAllowThreads(__tstate);
21741 if (PyErr_Occurred()) SWIG_fail;
21742 }
21743 {
21744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21745 }
21746 return resultobj;
21747 fail:
21748 return NULL;
21749 }
21750
21751
21752 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
21753 PyObject *resultobj;
21754 wxDateTime *arg1 = (wxDateTime *) 0 ;
21755 wxDateTime *arg2 = 0 ;
21756 wxDateTime *arg3 = 0 ;
21757 bool result;
21758 PyObject * obj0 = 0 ;
21759 PyObject * obj1 = 0 ;
21760 PyObject * obj2 = 0 ;
21761 char *kwnames[] = {
21762 (char *) "self",(char *) "t1",(char *) "t2", NULL
21763 };
21764
21765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
21766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21767 if (SWIG_arg_fail(1)) SWIG_fail;
21768 {
21769 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21770 if (SWIG_arg_fail(2)) SWIG_fail;
21771 if (arg2 == NULL) {
21772 SWIG_null_ref("wxDateTime");
21773 }
21774 if (SWIG_arg_fail(2)) SWIG_fail;
21775 }
21776 {
21777 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21778 if (SWIG_arg_fail(3)) SWIG_fail;
21779 if (arg3 == NULL) {
21780 SWIG_null_ref("wxDateTime");
21781 }
21782 if (SWIG_arg_fail(3)) SWIG_fail;
21783 }
21784 {
21785 PyThreadState* __tstate = wxPyBeginAllowThreads();
21786 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
21787
21788 wxPyEndAllowThreads(__tstate);
21789 if (PyErr_Occurred()) SWIG_fail;
21790 }
21791 {
21792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21793 }
21794 return resultobj;
21795 fail:
21796 return NULL;
21797 }
21798
21799
21800 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
21801 PyObject *resultobj;
21802 wxDateTime *arg1 = (wxDateTime *) 0 ;
21803 wxDateTime *arg2 = 0 ;
21804 bool result;
21805 PyObject * obj0 = 0 ;
21806 PyObject * obj1 = 0 ;
21807 char *kwnames[] = {
21808 (char *) "self",(char *) "dt", NULL
21809 };
21810
21811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
21812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21813 if (SWIG_arg_fail(1)) SWIG_fail;
21814 {
21815 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21816 if (SWIG_arg_fail(2)) SWIG_fail;
21817 if (arg2 == NULL) {
21818 SWIG_null_ref("wxDateTime");
21819 }
21820 if (SWIG_arg_fail(2)) SWIG_fail;
21821 }
21822 {
21823 PyThreadState* __tstate = wxPyBeginAllowThreads();
21824 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
21825
21826 wxPyEndAllowThreads(__tstate);
21827 if (PyErr_Occurred()) SWIG_fail;
21828 }
21829 {
21830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21831 }
21832 return resultobj;
21833 fail:
21834 return NULL;
21835 }
21836
21837
21838 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
21839 PyObject *resultobj;
21840 wxDateTime *arg1 = (wxDateTime *) 0 ;
21841 wxDateTime *arg2 = 0 ;
21842 bool result;
21843 PyObject * obj0 = 0 ;
21844 PyObject * obj1 = 0 ;
21845 char *kwnames[] = {
21846 (char *) "self",(char *) "dt", NULL
21847 };
21848
21849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
21850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21851 if (SWIG_arg_fail(1)) SWIG_fail;
21852 {
21853 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21854 if (SWIG_arg_fail(2)) SWIG_fail;
21855 if (arg2 == NULL) {
21856 SWIG_null_ref("wxDateTime");
21857 }
21858 if (SWIG_arg_fail(2)) SWIG_fail;
21859 }
21860 {
21861 PyThreadState* __tstate = wxPyBeginAllowThreads();
21862 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
21863
21864 wxPyEndAllowThreads(__tstate);
21865 if (PyErr_Occurred()) SWIG_fail;
21866 }
21867 {
21868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21869 }
21870 return resultobj;
21871 fail:
21872 return NULL;
21873 }
21874
21875
21876 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
21877 PyObject *resultobj;
21878 wxDateTime *arg1 = (wxDateTime *) 0 ;
21879 wxDateTime *arg2 = 0 ;
21880 wxTimeSpan *arg3 = 0 ;
21881 bool result;
21882 PyObject * obj0 = 0 ;
21883 PyObject * obj1 = 0 ;
21884 PyObject * obj2 = 0 ;
21885 char *kwnames[] = {
21886 (char *) "self",(char *) "dt",(char *) "ts", NULL
21887 };
21888
21889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
21890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21891 if (SWIG_arg_fail(1)) SWIG_fail;
21892 {
21893 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21894 if (SWIG_arg_fail(2)) SWIG_fail;
21895 if (arg2 == NULL) {
21896 SWIG_null_ref("wxDateTime");
21897 }
21898 if (SWIG_arg_fail(2)) SWIG_fail;
21899 }
21900 {
21901 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
21902 if (SWIG_arg_fail(3)) SWIG_fail;
21903 if (arg3 == NULL) {
21904 SWIG_null_ref("wxTimeSpan");
21905 }
21906 if (SWIG_arg_fail(3)) SWIG_fail;
21907 }
21908 {
21909 PyThreadState* __tstate = wxPyBeginAllowThreads();
21910 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
21911
21912 wxPyEndAllowThreads(__tstate);
21913 if (PyErr_Occurred()) SWIG_fail;
21914 }
21915 {
21916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21917 }
21918 return resultobj;
21919 fail:
21920 return NULL;
21921 }
21922
21923
21924 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
21925 PyObject *resultobj;
21926 wxDateTime *arg1 = (wxDateTime *) 0 ;
21927 wxTimeSpan *arg2 = 0 ;
21928 wxDateTime *result;
21929 PyObject * obj0 = 0 ;
21930 PyObject * obj1 = 0 ;
21931 char *kwnames[] = {
21932 (char *) "self",(char *) "diff", NULL
21933 };
21934
21935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
21936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21937 if (SWIG_arg_fail(1)) SWIG_fail;
21938 {
21939 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
21940 if (SWIG_arg_fail(2)) SWIG_fail;
21941 if (arg2 == NULL) {
21942 SWIG_null_ref("wxTimeSpan");
21943 }
21944 if (SWIG_arg_fail(2)) SWIG_fail;
21945 }
21946 {
21947 PyThreadState* __tstate = wxPyBeginAllowThreads();
21948 {
21949 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
21950 result = (wxDateTime *) &_result_ref;
21951 }
21952
21953 wxPyEndAllowThreads(__tstate);
21954 if (PyErr_Occurred()) SWIG_fail;
21955 }
21956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21957 return resultobj;
21958 fail:
21959 return NULL;
21960 }
21961
21962
21963 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
21964 PyObject *resultobj;
21965 wxDateTime *arg1 = (wxDateTime *) 0 ;
21966 wxDateSpan *arg2 = 0 ;
21967 wxDateTime *result;
21968 PyObject * obj0 = 0 ;
21969 PyObject * obj1 = 0 ;
21970 char *kwnames[] = {
21971 (char *) "self",(char *) "diff", NULL
21972 };
21973
21974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
21975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21976 if (SWIG_arg_fail(1)) SWIG_fail;
21977 {
21978 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
21979 if (SWIG_arg_fail(2)) SWIG_fail;
21980 if (arg2 == NULL) {
21981 SWIG_null_ref("wxDateSpan");
21982 }
21983 if (SWIG_arg_fail(2)) SWIG_fail;
21984 }
21985 {
21986 PyThreadState* __tstate = wxPyBeginAllowThreads();
21987 {
21988 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
21989 result = (wxDateTime *) &_result_ref;
21990 }
21991
21992 wxPyEndAllowThreads(__tstate);
21993 if (PyErr_Occurred()) SWIG_fail;
21994 }
21995 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21996 return resultobj;
21997 fail:
21998 return NULL;
21999 }
22000
22001
22002 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22003 PyObject *resultobj;
22004 wxDateTime *arg1 = (wxDateTime *) 0 ;
22005 wxTimeSpan *arg2 = 0 ;
22006 wxDateTime *result;
22007 PyObject * obj0 = 0 ;
22008 PyObject * obj1 = 0 ;
22009 char *kwnames[] = {
22010 (char *) "self",(char *) "diff", NULL
22011 };
22012
22013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22015 if (SWIG_arg_fail(1)) SWIG_fail;
22016 {
22017 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22018 if (SWIG_arg_fail(2)) SWIG_fail;
22019 if (arg2 == NULL) {
22020 SWIG_null_ref("wxTimeSpan");
22021 }
22022 if (SWIG_arg_fail(2)) SWIG_fail;
22023 }
22024 {
22025 PyThreadState* __tstate = wxPyBeginAllowThreads();
22026 {
22027 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22028 result = (wxDateTime *) &_result_ref;
22029 }
22030
22031 wxPyEndAllowThreads(__tstate);
22032 if (PyErr_Occurred()) SWIG_fail;
22033 }
22034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22035 return resultobj;
22036 fail:
22037 return NULL;
22038 }
22039
22040
22041 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22042 PyObject *resultobj;
22043 wxDateTime *arg1 = (wxDateTime *) 0 ;
22044 wxDateSpan *arg2 = 0 ;
22045 wxDateTime *result;
22046 PyObject * obj0 = 0 ;
22047 PyObject * obj1 = 0 ;
22048 char *kwnames[] = {
22049 (char *) "self",(char *) "diff", NULL
22050 };
22051
22052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22054 if (SWIG_arg_fail(1)) SWIG_fail;
22055 {
22056 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22057 if (SWIG_arg_fail(2)) SWIG_fail;
22058 if (arg2 == NULL) {
22059 SWIG_null_ref("wxDateSpan");
22060 }
22061 if (SWIG_arg_fail(2)) SWIG_fail;
22062 }
22063 {
22064 PyThreadState* __tstate = wxPyBeginAllowThreads();
22065 {
22066 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22067 result = (wxDateTime *) &_result_ref;
22068 }
22069
22070 wxPyEndAllowThreads(__tstate);
22071 if (PyErr_Occurred()) SWIG_fail;
22072 }
22073 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22074 return resultobj;
22075 fail:
22076 return NULL;
22077 }
22078
22079
22080 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22081 PyObject *resultobj;
22082 wxDateTime *arg1 = (wxDateTime *) 0 ;
22083 wxDateTime *arg2 = 0 ;
22084 wxTimeSpan result;
22085 PyObject * obj0 = 0 ;
22086 PyObject * obj1 = 0 ;
22087 char *kwnames[] = {
22088 (char *) "self",(char *) "dt", NULL
22089 };
22090
22091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22093 if (SWIG_arg_fail(1)) SWIG_fail;
22094 {
22095 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22096 if (SWIG_arg_fail(2)) SWIG_fail;
22097 if (arg2 == NULL) {
22098 SWIG_null_ref("wxDateTime");
22099 }
22100 if (SWIG_arg_fail(2)) SWIG_fail;
22101 }
22102 {
22103 PyThreadState* __tstate = wxPyBeginAllowThreads();
22104 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22105
22106 wxPyEndAllowThreads(__tstate);
22107 if (PyErr_Occurred()) SWIG_fail;
22108 }
22109 {
22110 wxTimeSpan * resultptr;
22111 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22112 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22113 }
22114 return resultobj;
22115 fail:
22116 return NULL;
22117 }
22118
22119
22120 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22121 PyObject *resultobj;
22122 wxDateTime *arg1 = (wxDateTime *) 0 ;
22123 wxTimeSpan *arg2 = 0 ;
22124 wxDateTime *result;
22125 PyObject * obj0 = 0 ;
22126 PyObject * obj1 = 0 ;
22127
22128 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22130 if (SWIG_arg_fail(1)) SWIG_fail;
22131 {
22132 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22133 if (SWIG_arg_fail(2)) SWIG_fail;
22134 if (arg2 == NULL) {
22135 SWIG_null_ref("wxTimeSpan");
22136 }
22137 if (SWIG_arg_fail(2)) SWIG_fail;
22138 }
22139 {
22140 PyThreadState* __tstate = wxPyBeginAllowThreads();
22141 {
22142 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22143 result = (wxDateTime *) &_result_ref;
22144 }
22145
22146 wxPyEndAllowThreads(__tstate);
22147 if (PyErr_Occurred()) SWIG_fail;
22148 }
22149 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22150 return resultobj;
22151 fail:
22152 return NULL;
22153 }
22154
22155
22156 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22157 PyObject *resultobj;
22158 wxDateTime *arg1 = (wxDateTime *) 0 ;
22159 wxDateSpan *arg2 = 0 ;
22160 wxDateTime *result;
22161 PyObject * obj0 = 0 ;
22162 PyObject * obj1 = 0 ;
22163
22164 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22166 if (SWIG_arg_fail(1)) SWIG_fail;
22167 {
22168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22169 if (SWIG_arg_fail(2)) SWIG_fail;
22170 if (arg2 == NULL) {
22171 SWIG_null_ref("wxDateSpan");
22172 }
22173 if (SWIG_arg_fail(2)) SWIG_fail;
22174 }
22175 {
22176 PyThreadState* __tstate = wxPyBeginAllowThreads();
22177 {
22178 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22179 result = (wxDateTime *) &_result_ref;
22180 }
22181
22182 wxPyEndAllowThreads(__tstate);
22183 if (PyErr_Occurred()) SWIG_fail;
22184 }
22185 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22186 return resultobj;
22187 fail:
22188 return NULL;
22189 }
22190
22191
22192 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22193 int argc;
22194 PyObject *argv[3];
22195 int ii;
22196
22197 argc = PyObject_Length(args);
22198 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22199 argv[ii] = PyTuple_GetItem(args,ii);
22200 }
22201 if (argc == 2) {
22202 int _v;
22203 {
22204 void *ptr;
22205 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22206 _v = 0;
22207 PyErr_Clear();
22208 } else {
22209 _v = 1;
22210 }
22211 }
22212 if (_v) {
22213 {
22214 void *ptr = 0;
22215 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22216 _v = 0;
22217 PyErr_Clear();
22218 } else {
22219 _v = (ptr != 0);
22220 }
22221 }
22222 if (_v) {
22223 return _wrap_DateTime___iadd____SWIG_0(self,args);
22224 }
22225 }
22226 }
22227 if (argc == 2) {
22228 int _v;
22229 {
22230 void *ptr;
22231 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22232 _v = 0;
22233 PyErr_Clear();
22234 } else {
22235 _v = 1;
22236 }
22237 }
22238 if (_v) {
22239 {
22240 void *ptr = 0;
22241 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22242 _v = 0;
22243 PyErr_Clear();
22244 } else {
22245 _v = (ptr != 0);
22246 }
22247 }
22248 if (_v) {
22249 return _wrap_DateTime___iadd____SWIG_1(self,args);
22250 }
22251 }
22252 }
22253
22254 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22255 return NULL;
22256 }
22257
22258
22259 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22260 PyObject *resultobj;
22261 wxDateTime *arg1 = (wxDateTime *) 0 ;
22262 wxTimeSpan *arg2 = 0 ;
22263 wxDateTime *result;
22264 PyObject * obj0 = 0 ;
22265 PyObject * obj1 = 0 ;
22266
22267 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22269 if (SWIG_arg_fail(1)) SWIG_fail;
22270 {
22271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22272 if (SWIG_arg_fail(2)) SWIG_fail;
22273 if (arg2 == NULL) {
22274 SWIG_null_ref("wxTimeSpan");
22275 }
22276 if (SWIG_arg_fail(2)) SWIG_fail;
22277 }
22278 {
22279 PyThreadState* __tstate = wxPyBeginAllowThreads();
22280 {
22281 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22282 result = (wxDateTime *) &_result_ref;
22283 }
22284
22285 wxPyEndAllowThreads(__tstate);
22286 if (PyErr_Occurred()) SWIG_fail;
22287 }
22288 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22289 return resultobj;
22290 fail:
22291 return NULL;
22292 }
22293
22294
22295 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22296 PyObject *resultobj;
22297 wxDateTime *arg1 = (wxDateTime *) 0 ;
22298 wxDateSpan *arg2 = 0 ;
22299 wxDateTime *result;
22300 PyObject * obj0 = 0 ;
22301 PyObject * obj1 = 0 ;
22302
22303 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22305 if (SWIG_arg_fail(1)) SWIG_fail;
22306 {
22307 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22308 if (SWIG_arg_fail(2)) SWIG_fail;
22309 if (arg2 == NULL) {
22310 SWIG_null_ref("wxDateSpan");
22311 }
22312 if (SWIG_arg_fail(2)) SWIG_fail;
22313 }
22314 {
22315 PyThreadState* __tstate = wxPyBeginAllowThreads();
22316 {
22317 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22318 result = (wxDateTime *) &_result_ref;
22319 }
22320
22321 wxPyEndAllowThreads(__tstate);
22322 if (PyErr_Occurred()) SWIG_fail;
22323 }
22324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22325 return resultobj;
22326 fail:
22327 return NULL;
22328 }
22329
22330
22331 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22332 int argc;
22333 PyObject *argv[3];
22334 int ii;
22335
22336 argc = PyObject_Length(args);
22337 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22338 argv[ii] = PyTuple_GetItem(args,ii);
22339 }
22340 if (argc == 2) {
22341 int _v;
22342 {
22343 void *ptr;
22344 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22345 _v = 0;
22346 PyErr_Clear();
22347 } else {
22348 _v = 1;
22349 }
22350 }
22351 if (_v) {
22352 {
22353 void *ptr = 0;
22354 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22355 _v = 0;
22356 PyErr_Clear();
22357 } else {
22358 _v = (ptr != 0);
22359 }
22360 }
22361 if (_v) {
22362 return _wrap_DateTime___isub____SWIG_0(self,args);
22363 }
22364 }
22365 }
22366 if (argc == 2) {
22367 int _v;
22368 {
22369 void *ptr;
22370 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22371 _v = 0;
22372 PyErr_Clear();
22373 } else {
22374 _v = 1;
22375 }
22376 }
22377 if (_v) {
22378 {
22379 void *ptr = 0;
22380 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22381 _v = 0;
22382 PyErr_Clear();
22383 } else {
22384 _v = (ptr != 0);
22385 }
22386 }
22387 if (_v) {
22388 return _wrap_DateTime___isub____SWIG_1(self,args);
22389 }
22390 }
22391 }
22392
22393 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22394 return NULL;
22395 }
22396
22397
22398 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22399 PyObject *resultobj;
22400 wxDateTime *arg1 = (wxDateTime *) 0 ;
22401 wxTimeSpan *arg2 = 0 ;
22402 wxDateTime result;
22403 PyObject * obj0 = 0 ;
22404 PyObject * obj1 = 0 ;
22405
22406 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22408 if (SWIG_arg_fail(1)) SWIG_fail;
22409 {
22410 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22411 if (SWIG_arg_fail(2)) SWIG_fail;
22412 if (arg2 == NULL) {
22413 SWIG_null_ref("wxTimeSpan");
22414 }
22415 if (SWIG_arg_fail(2)) SWIG_fail;
22416 }
22417 {
22418 PyThreadState* __tstate = wxPyBeginAllowThreads();
22419 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22420
22421 wxPyEndAllowThreads(__tstate);
22422 if (PyErr_Occurred()) SWIG_fail;
22423 }
22424 {
22425 wxDateTime * resultptr;
22426 resultptr = new wxDateTime((wxDateTime &)(result));
22427 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22428 }
22429 return resultobj;
22430 fail:
22431 return NULL;
22432 }
22433
22434
22435 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22436 PyObject *resultobj;
22437 wxDateTime *arg1 = (wxDateTime *) 0 ;
22438 wxDateSpan *arg2 = 0 ;
22439 wxDateTime result;
22440 PyObject * obj0 = 0 ;
22441 PyObject * obj1 = 0 ;
22442
22443 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22445 if (SWIG_arg_fail(1)) SWIG_fail;
22446 {
22447 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22448 if (SWIG_arg_fail(2)) SWIG_fail;
22449 if (arg2 == NULL) {
22450 SWIG_null_ref("wxDateSpan");
22451 }
22452 if (SWIG_arg_fail(2)) SWIG_fail;
22453 }
22454 {
22455 PyThreadState* __tstate = wxPyBeginAllowThreads();
22456 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22457
22458 wxPyEndAllowThreads(__tstate);
22459 if (PyErr_Occurred()) SWIG_fail;
22460 }
22461 {
22462 wxDateTime * resultptr;
22463 resultptr = new wxDateTime((wxDateTime &)(result));
22464 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22465 }
22466 return resultobj;
22467 fail:
22468 return NULL;
22469 }
22470
22471
22472 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22473 int argc;
22474 PyObject *argv[3];
22475 int ii;
22476
22477 argc = PyObject_Length(args);
22478 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22479 argv[ii] = PyTuple_GetItem(args,ii);
22480 }
22481 if (argc == 2) {
22482 int _v;
22483 {
22484 void *ptr;
22485 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22486 _v = 0;
22487 PyErr_Clear();
22488 } else {
22489 _v = 1;
22490 }
22491 }
22492 if (_v) {
22493 {
22494 void *ptr = 0;
22495 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22496 _v = 0;
22497 PyErr_Clear();
22498 } else {
22499 _v = (ptr != 0);
22500 }
22501 }
22502 if (_v) {
22503 return _wrap_DateTime___add____SWIG_0(self,args);
22504 }
22505 }
22506 }
22507 if (argc == 2) {
22508 int _v;
22509 {
22510 void *ptr;
22511 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22512 _v = 0;
22513 PyErr_Clear();
22514 } else {
22515 _v = 1;
22516 }
22517 }
22518 if (_v) {
22519 {
22520 void *ptr = 0;
22521 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22522 _v = 0;
22523 PyErr_Clear();
22524 } else {
22525 _v = (ptr != 0);
22526 }
22527 }
22528 if (_v) {
22529 return _wrap_DateTime___add____SWIG_1(self,args);
22530 }
22531 }
22532 }
22533
22534 Py_INCREF(Py_NotImplemented);
22535 return Py_NotImplemented;
22536 }
22537
22538
22539 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22540 PyObject *resultobj;
22541 wxDateTime *arg1 = (wxDateTime *) 0 ;
22542 wxDateTime *arg2 = 0 ;
22543 wxTimeSpan result;
22544 PyObject * obj0 = 0 ;
22545 PyObject * obj1 = 0 ;
22546
22547 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22549 if (SWIG_arg_fail(1)) SWIG_fail;
22550 {
22551 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22552 if (SWIG_arg_fail(2)) SWIG_fail;
22553 if (arg2 == NULL) {
22554 SWIG_null_ref("wxDateTime");
22555 }
22556 if (SWIG_arg_fail(2)) SWIG_fail;
22557 }
22558 {
22559 PyThreadState* __tstate = wxPyBeginAllowThreads();
22560 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22561
22562 wxPyEndAllowThreads(__tstate);
22563 if (PyErr_Occurred()) SWIG_fail;
22564 }
22565 {
22566 wxTimeSpan * resultptr;
22567 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22568 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22569 }
22570 return resultobj;
22571 fail:
22572 return NULL;
22573 }
22574
22575
22576 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22577 PyObject *resultobj;
22578 wxDateTime *arg1 = (wxDateTime *) 0 ;
22579 wxTimeSpan *arg2 = 0 ;
22580 wxDateTime result;
22581 PyObject * obj0 = 0 ;
22582 PyObject * obj1 = 0 ;
22583
22584 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22586 if (SWIG_arg_fail(1)) SWIG_fail;
22587 {
22588 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22589 if (SWIG_arg_fail(2)) SWIG_fail;
22590 if (arg2 == NULL) {
22591 SWIG_null_ref("wxTimeSpan");
22592 }
22593 if (SWIG_arg_fail(2)) SWIG_fail;
22594 }
22595 {
22596 PyThreadState* __tstate = wxPyBeginAllowThreads();
22597 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22598
22599 wxPyEndAllowThreads(__tstate);
22600 if (PyErr_Occurred()) SWIG_fail;
22601 }
22602 {
22603 wxDateTime * resultptr;
22604 resultptr = new wxDateTime((wxDateTime &)(result));
22605 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22606 }
22607 return resultobj;
22608 fail:
22609 return NULL;
22610 }
22611
22612
22613 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22614 PyObject *resultobj;
22615 wxDateTime *arg1 = (wxDateTime *) 0 ;
22616 wxDateSpan *arg2 = 0 ;
22617 wxDateTime result;
22618 PyObject * obj0 = 0 ;
22619 PyObject * obj1 = 0 ;
22620
22621 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22623 if (SWIG_arg_fail(1)) SWIG_fail;
22624 {
22625 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22626 if (SWIG_arg_fail(2)) SWIG_fail;
22627 if (arg2 == NULL) {
22628 SWIG_null_ref("wxDateSpan");
22629 }
22630 if (SWIG_arg_fail(2)) SWIG_fail;
22631 }
22632 {
22633 PyThreadState* __tstate = wxPyBeginAllowThreads();
22634 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22635
22636 wxPyEndAllowThreads(__tstate);
22637 if (PyErr_Occurred()) SWIG_fail;
22638 }
22639 {
22640 wxDateTime * resultptr;
22641 resultptr = new wxDateTime((wxDateTime &)(result));
22642 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22643 }
22644 return resultobj;
22645 fail:
22646 return NULL;
22647 }
22648
22649
22650 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22651 int argc;
22652 PyObject *argv[3];
22653 int ii;
22654
22655 argc = PyObject_Length(args);
22656 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22657 argv[ii] = PyTuple_GetItem(args,ii);
22658 }
22659 if (argc == 2) {
22660 int _v;
22661 {
22662 void *ptr;
22663 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22664 _v = 0;
22665 PyErr_Clear();
22666 } else {
22667 _v = 1;
22668 }
22669 }
22670 if (_v) {
22671 {
22672 void *ptr = 0;
22673 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22674 _v = 0;
22675 PyErr_Clear();
22676 } else {
22677 _v = (ptr != 0);
22678 }
22679 }
22680 if (_v) {
22681 return _wrap_DateTime___sub____SWIG_0(self,args);
22682 }
22683 }
22684 }
22685 if (argc == 2) {
22686 int _v;
22687 {
22688 void *ptr;
22689 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22690 _v = 0;
22691 PyErr_Clear();
22692 } else {
22693 _v = 1;
22694 }
22695 }
22696 if (_v) {
22697 {
22698 void *ptr = 0;
22699 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22700 _v = 0;
22701 PyErr_Clear();
22702 } else {
22703 _v = (ptr != 0);
22704 }
22705 }
22706 if (_v) {
22707 return _wrap_DateTime___sub____SWIG_1(self,args);
22708 }
22709 }
22710 }
22711 if (argc == 2) {
22712 int _v;
22713 {
22714 void *ptr;
22715 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22716 _v = 0;
22717 PyErr_Clear();
22718 } else {
22719 _v = 1;
22720 }
22721 }
22722 if (_v) {
22723 {
22724 void *ptr = 0;
22725 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22726 _v = 0;
22727 PyErr_Clear();
22728 } else {
22729 _v = (ptr != 0);
22730 }
22731 }
22732 if (_v) {
22733 return _wrap_DateTime___sub____SWIG_2(self,args);
22734 }
22735 }
22736 }
22737
22738 Py_INCREF(Py_NotImplemented);
22739 return Py_NotImplemented;
22740 }
22741
22742
22743 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
22744 PyObject *resultobj;
22745 wxDateTime *arg1 = (wxDateTime *) 0 ;
22746 wxDateTime *arg2 = (wxDateTime *) 0 ;
22747 bool result;
22748 PyObject * obj0 = 0 ;
22749 PyObject * obj1 = 0 ;
22750 char *kwnames[] = {
22751 (char *) "self",(char *) "other", NULL
22752 };
22753
22754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
22755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22756 if (SWIG_arg_fail(1)) SWIG_fail;
22757 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22758 if (SWIG_arg_fail(2)) SWIG_fail;
22759 {
22760 PyThreadState* __tstate = wxPyBeginAllowThreads();
22761 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
22762
22763 wxPyEndAllowThreads(__tstate);
22764 if (PyErr_Occurred()) SWIG_fail;
22765 }
22766 {
22767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22768 }
22769 return resultobj;
22770 fail:
22771 return NULL;
22772 }
22773
22774
22775 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
22776 PyObject *resultobj;
22777 wxDateTime *arg1 = (wxDateTime *) 0 ;
22778 wxDateTime *arg2 = (wxDateTime *) 0 ;
22779 bool result;
22780 PyObject * obj0 = 0 ;
22781 PyObject * obj1 = 0 ;
22782 char *kwnames[] = {
22783 (char *) "self",(char *) "other", NULL
22784 };
22785
22786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
22787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22788 if (SWIG_arg_fail(1)) SWIG_fail;
22789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22790 if (SWIG_arg_fail(2)) SWIG_fail;
22791 {
22792 PyThreadState* __tstate = wxPyBeginAllowThreads();
22793 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
22794
22795 wxPyEndAllowThreads(__tstate);
22796 if (PyErr_Occurred()) SWIG_fail;
22797 }
22798 {
22799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22800 }
22801 return resultobj;
22802 fail:
22803 return NULL;
22804 }
22805
22806
22807 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
22808 PyObject *resultobj;
22809 wxDateTime *arg1 = (wxDateTime *) 0 ;
22810 wxDateTime *arg2 = (wxDateTime *) 0 ;
22811 bool result;
22812 PyObject * obj0 = 0 ;
22813 PyObject * obj1 = 0 ;
22814 char *kwnames[] = {
22815 (char *) "self",(char *) "other", NULL
22816 };
22817
22818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
22819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22820 if (SWIG_arg_fail(1)) SWIG_fail;
22821 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22822 if (SWIG_arg_fail(2)) SWIG_fail;
22823 {
22824 PyThreadState* __tstate = wxPyBeginAllowThreads();
22825 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
22826
22827 wxPyEndAllowThreads(__tstate);
22828 if (PyErr_Occurred()) SWIG_fail;
22829 }
22830 {
22831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22832 }
22833 return resultobj;
22834 fail:
22835 return NULL;
22836 }
22837
22838
22839 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
22840 PyObject *resultobj;
22841 wxDateTime *arg1 = (wxDateTime *) 0 ;
22842 wxDateTime *arg2 = (wxDateTime *) 0 ;
22843 bool result;
22844 PyObject * obj0 = 0 ;
22845 PyObject * obj1 = 0 ;
22846 char *kwnames[] = {
22847 (char *) "self",(char *) "other", NULL
22848 };
22849
22850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
22851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22852 if (SWIG_arg_fail(1)) SWIG_fail;
22853 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22854 if (SWIG_arg_fail(2)) SWIG_fail;
22855 {
22856 PyThreadState* __tstate = wxPyBeginAllowThreads();
22857 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
22858
22859 wxPyEndAllowThreads(__tstate);
22860 if (PyErr_Occurred()) SWIG_fail;
22861 }
22862 {
22863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22864 }
22865 return resultobj;
22866 fail:
22867 return NULL;
22868 }
22869
22870
22871 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
22872 PyObject *resultobj;
22873 wxDateTime *arg1 = (wxDateTime *) 0 ;
22874 wxDateTime *arg2 = (wxDateTime *) 0 ;
22875 bool result;
22876 PyObject * obj0 = 0 ;
22877 PyObject * obj1 = 0 ;
22878 char *kwnames[] = {
22879 (char *) "self",(char *) "other", NULL
22880 };
22881
22882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
22883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22884 if (SWIG_arg_fail(1)) SWIG_fail;
22885 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22886 if (SWIG_arg_fail(2)) SWIG_fail;
22887 {
22888 PyThreadState* __tstate = wxPyBeginAllowThreads();
22889 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
22890
22891 wxPyEndAllowThreads(__tstate);
22892 if (PyErr_Occurred()) SWIG_fail;
22893 }
22894 {
22895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22896 }
22897 return resultobj;
22898 fail:
22899 return NULL;
22900 }
22901
22902
22903 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
22904 PyObject *resultobj;
22905 wxDateTime *arg1 = (wxDateTime *) 0 ;
22906 wxDateTime *arg2 = (wxDateTime *) 0 ;
22907 bool result;
22908 PyObject * obj0 = 0 ;
22909 PyObject * obj1 = 0 ;
22910 char *kwnames[] = {
22911 (char *) "self",(char *) "other", NULL
22912 };
22913
22914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
22915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22916 if (SWIG_arg_fail(1)) SWIG_fail;
22917 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22918 if (SWIG_arg_fail(2)) SWIG_fail;
22919 {
22920 PyThreadState* __tstate = wxPyBeginAllowThreads();
22921 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
22922
22923 wxPyEndAllowThreads(__tstate);
22924 if (PyErr_Occurred()) SWIG_fail;
22925 }
22926 {
22927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22928 }
22929 return resultobj;
22930 fail:
22931 return NULL;
22932 }
22933
22934
22935 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
22936 PyObject *resultobj;
22937 wxDateTime *arg1 = (wxDateTime *) 0 ;
22938 wxString *arg2 = 0 ;
22939 int result;
22940 bool temp2 = false ;
22941 PyObject * obj0 = 0 ;
22942 PyObject * obj1 = 0 ;
22943 char *kwnames[] = {
22944 (char *) "self",(char *) "date", NULL
22945 };
22946
22947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
22948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22949 if (SWIG_arg_fail(1)) SWIG_fail;
22950 {
22951 arg2 = wxString_in_helper(obj1);
22952 if (arg2 == NULL) SWIG_fail;
22953 temp2 = true;
22954 }
22955 {
22956 PyThreadState* __tstate = wxPyBeginAllowThreads();
22957 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
22958
22959 wxPyEndAllowThreads(__tstate);
22960 if (PyErr_Occurred()) SWIG_fail;
22961 }
22962 {
22963 resultobj = SWIG_From_int((int)(result));
22964 }
22965 {
22966 if (temp2)
22967 delete arg2;
22968 }
22969 return resultobj;
22970 fail:
22971 {
22972 if (temp2)
22973 delete arg2;
22974 }
22975 return NULL;
22976 }
22977
22978
22979 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
22980 PyObject *resultobj;
22981 wxDateTime *arg1 = (wxDateTime *) 0 ;
22982 wxString *arg2 = 0 ;
22983 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
22984 wxString *arg3 = (wxString *) &arg3_defvalue ;
22985 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
22986 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
22987 int result;
22988 bool temp2 = false ;
22989 bool temp3 = false ;
22990 PyObject * obj0 = 0 ;
22991 PyObject * obj1 = 0 ;
22992 PyObject * obj2 = 0 ;
22993 PyObject * obj3 = 0 ;
22994 char *kwnames[] = {
22995 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
22996 };
22997
22998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23000 if (SWIG_arg_fail(1)) SWIG_fail;
23001 {
23002 arg2 = wxString_in_helper(obj1);
23003 if (arg2 == NULL) SWIG_fail;
23004 temp2 = true;
23005 }
23006 if (obj2) {
23007 {
23008 arg3 = wxString_in_helper(obj2);
23009 if (arg3 == NULL) SWIG_fail;
23010 temp3 = true;
23011 }
23012 }
23013 if (obj3) {
23014 {
23015 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23016 if (SWIG_arg_fail(4)) SWIG_fail;
23017 if (arg4 == NULL) {
23018 SWIG_null_ref("wxDateTime");
23019 }
23020 if (SWIG_arg_fail(4)) SWIG_fail;
23021 }
23022 }
23023 {
23024 PyThreadState* __tstate = wxPyBeginAllowThreads();
23025 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23026
23027 wxPyEndAllowThreads(__tstate);
23028 if (PyErr_Occurred()) SWIG_fail;
23029 }
23030 {
23031 resultobj = SWIG_From_int((int)(result));
23032 }
23033 {
23034 if (temp2)
23035 delete arg2;
23036 }
23037 {
23038 if (temp3)
23039 delete arg3;
23040 }
23041 return resultobj;
23042 fail:
23043 {
23044 if (temp2)
23045 delete arg2;
23046 }
23047 {
23048 if (temp3)
23049 delete arg3;
23050 }
23051 return NULL;
23052 }
23053
23054
23055 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23056 PyObject *resultobj;
23057 wxDateTime *arg1 = (wxDateTime *) 0 ;
23058 wxString *arg2 = 0 ;
23059 int result;
23060 bool temp2 = false ;
23061 PyObject * obj0 = 0 ;
23062 PyObject * obj1 = 0 ;
23063 char *kwnames[] = {
23064 (char *) "self",(char *) "datetime", NULL
23065 };
23066
23067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23069 if (SWIG_arg_fail(1)) SWIG_fail;
23070 {
23071 arg2 = wxString_in_helper(obj1);
23072 if (arg2 == NULL) SWIG_fail;
23073 temp2 = true;
23074 }
23075 {
23076 PyThreadState* __tstate = wxPyBeginAllowThreads();
23077 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23078
23079 wxPyEndAllowThreads(__tstate);
23080 if (PyErr_Occurred()) SWIG_fail;
23081 }
23082 {
23083 resultobj = SWIG_From_int((int)(result));
23084 }
23085 {
23086 if (temp2)
23087 delete arg2;
23088 }
23089 return resultobj;
23090 fail:
23091 {
23092 if (temp2)
23093 delete arg2;
23094 }
23095 return NULL;
23096 }
23097
23098
23099 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23100 PyObject *resultobj;
23101 wxDateTime *arg1 = (wxDateTime *) 0 ;
23102 wxString *arg2 = 0 ;
23103 int result;
23104 bool temp2 = false ;
23105 PyObject * obj0 = 0 ;
23106 PyObject * obj1 = 0 ;
23107 char *kwnames[] = {
23108 (char *) "self",(char *) "date", NULL
23109 };
23110
23111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23113 if (SWIG_arg_fail(1)) SWIG_fail;
23114 {
23115 arg2 = wxString_in_helper(obj1);
23116 if (arg2 == NULL) SWIG_fail;
23117 temp2 = true;
23118 }
23119 {
23120 PyThreadState* __tstate = wxPyBeginAllowThreads();
23121 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23122
23123 wxPyEndAllowThreads(__tstate);
23124 if (PyErr_Occurred()) SWIG_fail;
23125 }
23126 {
23127 resultobj = SWIG_From_int((int)(result));
23128 }
23129 {
23130 if (temp2)
23131 delete arg2;
23132 }
23133 return resultobj;
23134 fail:
23135 {
23136 if (temp2)
23137 delete arg2;
23138 }
23139 return NULL;
23140 }
23141
23142
23143 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23144 PyObject *resultobj;
23145 wxDateTime *arg1 = (wxDateTime *) 0 ;
23146 wxString *arg2 = 0 ;
23147 int result;
23148 bool temp2 = false ;
23149 PyObject * obj0 = 0 ;
23150 PyObject * obj1 = 0 ;
23151 char *kwnames[] = {
23152 (char *) "self",(char *) "time", NULL
23153 };
23154
23155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23157 if (SWIG_arg_fail(1)) SWIG_fail;
23158 {
23159 arg2 = wxString_in_helper(obj1);
23160 if (arg2 == NULL) SWIG_fail;
23161 temp2 = true;
23162 }
23163 {
23164 PyThreadState* __tstate = wxPyBeginAllowThreads();
23165 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23166
23167 wxPyEndAllowThreads(__tstate);
23168 if (PyErr_Occurred()) SWIG_fail;
23169 }
23170 {
23171 resultobj = SWIG_From_int((int)(result));
23172 }
23173 {
23174 if (temp2)
23175 delete arg2;
23176 }
23177 return resultobj;
23178 fail:
23179 {
23180 if (temp2)
23181 delete arg2;
23182 }
23183 return NULL;
23184 }
23185
23186
23187 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23188 PyObject *resultobj;
23189 wxDateTime *arg1 = (wxDateTime *) 0 ;
23190 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23191 wxString *arg2 = (wxString *) &arg2_defvalue ;
23192 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23193 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23194 wxString result;
23195 bool temp2 = false ;
23196 bool temp3 = false ;
23197 PyObject * obj0 = 0 ;
23198 PyObject * obj1 = 0 ;
23199 PyObject * obj2 = 0 ;
23200 char *kwnames[] = {
23201 (char *) "self",(char *) "format",(char *) "tz", NULL
23202 };
23203
23204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23206 if (SWIG_arg_fail(1)) SWIG_fail;
23207 if (obj1) {
23208 {
23209 arg2 = wxString_in_helper(obj1);
23210 if (arg2 == NULL) SWIG_fail;
23211 temp2 = true;
23212 }
23213 }
23214 if (obj2) {
23215 {
23216 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23217 temp3 = true;
23218 }
23219 }
23220 {
23221 PyThreadState* __tstate = wxPyBeginAllowThreads();
23222 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23223
23224 wxPyEndAllowThreads(__tstate);
23225 if (PyErr_Occurred()) SWIG_fail;
23226 }
23227 {
23228 #if wxUSE_UNICODE
23229 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23230 #else
23231 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23232 #endif
23233 }
23234 {
23235 if (temp2)
23236 delete arg2;
23237 }
23238 {
23239 if (temp3) delete arg3;
23240 }
23241 return resultobj;
23242 fail:
23243 {
23244 if (temp2)
23245 delete arg2;
23246 }
23247 {
23248 if (temp3) delete arg3;
23249 }
23250 return NULL;
23251 }
23252
23253
23254 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23255 PyObject *resultobj;
23256 wxDateTime *arg1 = (wxDateTime *) 0 ;
23257 wxString result;
23258 PyObject * obj0 = 0 ;
23259 char *kwnames[] = {
23260 (char *) "self", NULL
23261 };
23262
23263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23265 if (SWIG_arg_fail(1)) SWIG_fail;
23266 {
23267 PyThreadState* __tstate = wxPyBeginAllowThreads();
23268 result = ((wxDateTime const *)arg1)->FormatDate();
23269
23270 wxPyEndAllowThreads(__tstate);
23271 if (PyErr_Occurred()) SWIG_fail;
23272 }
23273 {
23274 #if wxUSE_UNICODE
23275 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23276 #else
23277 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23278 #endif
23279 }
23280 return resultobj;
23281 fail:
23282 return NULL;
23283 }
23284
23285
23286 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23287 PyObject *resultobj;
23288 wxDateTime *arg1 = (wxDateTime *) 0 ;
23289 wxString result;
23290 PyObject * obj0 = 0 ;
23291 char *kwnames[] = {
23292 (char *) "self", NULL
23293 };
23294
23295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23297 if (SWIG_arg_fail(1)) SWIG_fail;
23298 {
23299 PyThreadState* __tstate = wxPyBeginAllowThreads();
23300 result = ((wxDateTime const *)arg1)->FormatTime();
23301
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 {
23306 #if wxUSE_UNICODE
23307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23308 #else
23309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23310 #endif
23311 }
23312 return resultobj;
23313 fail:
23314 return NULL;
23315 }
23316
23317
23318 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23319 PyObject *resultobj;
23320 wxDateTime *arg1 = (wxDateTime *) 0 ;
23321 wxString result;
23322 PyObject * obj0 = 0 ;
23323 char *kwnames[] = {
23324 (char *) "self", NULL
23325 };
23326
23327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23329 if (SWIG_arg_fail(1)) SWIG_fail;
23330 {
23331 PyThreadState* __tstate = wxPyBeginAllowThreads();
23332 result = ((wxDateTime const *)arg1)->FormatISODate();
23333
23334 wxPyEndAllowThreads(__tstate);
23335 if (PyErr_Occurred()) SWIG_fail;
23336 }
23337 {
23338 #if wxUSE_UNICODE
23339 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23340 #else
23341 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23342 #endif
23343 }
23344 return resultobj;
23345 fail:
23346 return NULL;
23347 }
23348
23349
23350 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23351 PyObject *resultobj;
23352 wxDateTime *arg1 = (wxDateTime *) 0 ;
23353 wxString result;
23354 PyObject * obj0 = 0 ;
23355 char *kwnames[] = {
23356 (char *) "self", NULL
23357 };
23358
23359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23361 if (SWIG_arg_fail(1)) SWIG_fail;
23362 {
23363 PyThreadState* __tstate = wxPyBeginAllowThreads();
23364 result = ((wxDateTime const *)arg1)->FormatISOTime();
23365
23366 wxPyEndAllowThreads(__tstate);
23367 if (PyErr_Occurred()) SWIG_fail;
23368 }
23369 {
23370 #if wxUSE_UNICODE
23371 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23372 #else
23373 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23374 #endif
23375 }
23376 return resultobj;
23377 fail:
23378 return NULL;
23379 }
23380
23381
23382 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23383 PyObject *obj;
23384 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23385 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23386 Py_INCREF(obj);
23387 return Py_BuildValue((char *)"");
23388 }
23389 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23390 PyObject *resultobj;
23391 long arg1 ;
23392 wxTimeSpan result;
23393 PyObject * obj0 = 0 ;
23394 char *kwnames[] = {
23395 (char *) "sec", NULL
23396 };
23397
23398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23399 {
23400 arg1 = (long)(SWIG_As_long(obj0));
23401 if (SWIG_arg_fail(1)) SWIG_fail;
23402 }
23403 {
23404 PyThreadState* __tstate = wxPyBeginAllowThreads();
23405 result = wxTimeSpan::Seconds(arg1);
23406
23407 wxPyEndAllowThreads(__tstate);
23408 if (PyErr_Occurred()) SWIG_fail;
23409 }
23410 {
23411 wxTimeSpan * resultptr;
23412 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23413 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23414 }
23415 return resultobj;
23416 fail:
23417 return NULL;
23418 }
23419
23420
23421 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23422 PyObject *resultobj;
23423 wxTimeSpan result;
23424 char *kwnames[] = {
23425 NULL
23426 };
23427
23428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23429 {
23430 PyThreadState* __tstate = wxPyBeginAllowThreads();
23431 result = wxTimeSpan::Second();
23432
23433 wxPyEndAllowThreads(__tstate);
23434 if (PyErr_Occurred()) SWIG_fail;
23435 }
23436 {
23437 wxTimeSpan * resultptr;
23438 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23439 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23440 }
23441 return resultobj;
23442 fail:
23443 return NULL;
23444 }
23445
23446
23447 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23448 PyObject *resultobj;
23449 long arg1 ;
23450 wxTimeSpan result;
23451 PyObject * obj0 = 0 ;
23452 char *kwnames[] = {
23453 (char *) "min", NULL
23454 };
23455
23456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23457 {
23458 arg1 = (long)(SWIG_As_long(obj0));
23459 if (SWIG_arg_fail(1)) SWIG_fail;
23460 }
23461 {
23462 PyThreadState* __tstate = wxPyBeginAllowThreads();
23463 result = wxTimeSpan::Minutes(arg1);
23464
23465 wxPyEndAllowThreads(__tstate);
23466 if (PyErr_Occurred()) SWIG_fail;
23467 }
23468 {
23469 wxTimeSpan * resultptr;
23470 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23471 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23472 }
23473 return resultobj;
23474 fail:
23475 return NULL;
23476 }
23477
23478
23479 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23480 PyObject *resultobj;
23481 wxTimeSpan result;
23482 char *kwnames[] = {
23483 NULL
23484 };
23485
23486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23487 {
23488 PyThreadState* __tstate = wxPyBeginAllowThreads();
23489 result = wxTimeSpan::Minute();
23490
23491 wxPyEndAllowThreads(__tstate);
23492 if (PyErr_Occurred()) SWIG_fail;
23493 }
23494 {
23495 wxTimeSpan * resultptr;
23496 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23497 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23498 }
23499 return resultobj;
23500 fail:
23501 return NULL;
23502 }
23503
23504
23505 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23506 PyObject *resultobj;
23507 long arg1 ;
23508 wxTimeSpan result;
23509 PyObject * obj0 = 0 ;
23510 char *kwnames[] = {
23511 (char *) "hours", NULL
23512 };
23513
23514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23515 {
23516 arg1 = (long)(SWIG_As_long(obj0));
23517 if (SWIG_arg_fail(1)) SWIG_fail;
23518 }
23519 {
23520 PyThreadState* __tstate = wxPyBeginAllowThreads();
23521 result = wxTimeSpan::Hours(arg1);
23522
23523 wxPyEndAllowThreads(__tstate);
23524 if (PyErr_Occurred()) SWIG_fail;
23525 }
23526 {
23527 wxTimeSpan * resultptr;
23528 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23529 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23530 }
23531 return resultobj;
23532 fail:
23533 return NULL;
23534 }
23535
23536
23537 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23538 PyObject *resultobj;
23539 wxTimeSpan result;
23540 char *kwnames[] = {
23541 NULL
23542 };
23543
23544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23545 {
23546 PyThreadState* __tstate = wxPyBeginAllowThreads();
23547 result = wxTimeSpan::Hour();
23548
23549 wxPyEndAllowThreads(__tstate);
23550 if (PyErr_Occurred()) SWIG_fail;
23551 }
23552 {
23553 wxTimeSpan * resultptr;
23554 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23555 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23556 }
23557 return resultobj;
23558 fail:
23559 return NULL;
23560 }
23561
23562
23563 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23564 PyObject *resultobj;
23565 long arg1 ;
23566 wxTimeSpan result;
23567 PyObject * obj0 = 0 ;
23568 char *kwnames[] = {
23569 (char *) "days", NULL
23570 };
23571
23572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23573 {
23574 arg1 = (long)(SWIG_As_long(obj0));
23575 if (SWIG_arg_fail(1)) SWIG_fail;
23576 }
23577 {
23578 PyThreadState* __tstate = wxPyBeginAllowThreads();
23579 result = wxTimeSpan::Days(arg1);
23580
23581 wxPyEndAllowThreads(__tstate);
23582 if (PyErr_Occurred()) SWIG_fail;
23583 }
23584 {
23585 wxTimeSpan * resultptr;
23586 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23587 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23588 }
23589 return resultobj;
23590 fail:
23591 return NULL;
23592 }
23593
23594
23595 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23596 PyObject *resultobj;
23597 wxTimeSpan result;
23598 char *kwnames[] = {
23599 NULL
23600 };
23601
23602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23603 {
23604 PyThreadState* __tstate = wxPyBeginAllowThreads();
23605 result = wxTimeSpan::Day();
23606
23607 wxPyEndAllowThreads(__tstate);
23608 if (PyErr_Occurred()) SWIG_fail;
23609 }
23610 {
23611 wxTimeSpan * resultptr;
23612 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23613 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23614 }
23615 return resultobj;
23616 fail:
23617 return NULL;
23618 }
23619
23620
23621 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23622 PyObject *resultobj;
23623 long arg1 ;
23624 wxTimeSpan result;
23625 PyObject * obj0 = 0 ;
23626 char *kwnames[] = {
23627 (char *) "days", NULL
23628 };
23629
23630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23631 {
23632 arg1 = (long)(SWIG_As_long(obj0));
23633 if (SWIG_arg_fail(1)) SWIG_fail;
23634 }
23635 {
23636 PyThreadState* __tstate = wxPyBeginAllowThreads();
23637 result = wxTimeSpan::Weeks(arg1);
23638
23639 wxPyEndAllowThreads(__tstate);
23640 if (PyErr_Occurred()) SWIG_fail;
23641 }
23642 {
23643 wxTimeSpan * resultptr;
23644 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23645 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23646 }
23647 return resultobj;
23648 fail:
23649 return NULL;
23650 }
23651
23652
23653 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23654 PyObject *resultobj;
23655 wxTimeSpan result;
23656 char *kwnames[] = {
23657 NULL
23658 };
23659
23660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
23661 {
23662 PyThreadState* __tstate = wxPyBeginAllowThreads();
23663 result = wxTimeSpan::Week();
23664
23665 wxPyEndAllowThreads(__tstate);
23666 if (PyErr_Occurred()) SWIG_fail;
23667 }
23668 {
23669 wxTimeSpan * resultptr;
23670 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23671 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23672 }
23673 return resultobj;
23674 fail:
23675 return NULL;
23676 }
23677
23678
23679 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23680 PyObject *resultobj;
23681 long arg1 = (long) 0 ;
23682 long arg2 = (long) 0 ;
23683 long arg3 = (long) 0 ;
23684 long arg4 = (long) 0 ;
23685 wxTimeSpan *result;
23686 PyObject * obj0 = 0 ;
23687 PyObject * obj1 = 0 ;
23688 PyObject * obj2 = 0 ;
23689 PyObject * obj3 = 0 ;
23690 char *kwnames[] = {
23691 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
23692 };
23693
23694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23695 if (obj0) {
23696 {
23697 arg1 = (long)(SWIG_As_long(obj0));
23698 if (SWIG_arg_fail(1)) SWIG_fail;
23699 }
23700 }
23701 if (obj1) {
23702 {
23703 arg2 = (long)(SWIG_As_long(obj1));
23704 if (SWIG_arg_fail(2)) SWIG_fail;
23705 }
23706 }
23707 if (obj2) {
23708 {
23709 arg3 = (long)(SWIG_As_long(obj2));
23710 if (SWIG_arg_fail(3)) SWIG_fail;
23711 }
23712 }
23713 if (obj3) {
23714 {
23715 arg4 = (long)(SWIG_As_long(obj3));
23716 if (SWIG_arg_fail(4)) SWIG_fail;
23717 }
23718 }
23719 {
23720 PyThreadState* __tstate = wxPyBeginAllowThreads();
23721 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
23722
23723 wxPyEndAllowThreads(__tstate);
23724 if (PyErr_Occurred()) SWIG_fail;
23725 }
23726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23727 return resultobj;
23728 fail:
23729 return NULL;
23730 }
23731
23732
23733 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
23734 PyObject *resultobj;
23735 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23736 PyObject * obj0 = 0 ;
23737 char *kwnames[] = {
23738 (char *) "self", NULL
23739 };
23740
23741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
23742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23743 if (SWIG_arg_fail(1)) SWIG_fail;
23744 {
23745 PyThreadState* __tstate = wxPyBeginAllowThreads();
23746 delete arg1;
23747
23748 wxPyEndAllowThreads(__tstate);
23749 if (PyErr_Occurred()) SWIG_fail;
23750 }
23751 Py_INCREF(Py_None); resultobj = Py_None;
23752 return resultobj;
23753 fail:
23754 return NULL;
23755 }
23756
23757
23758 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
23759 PyObject *resultobj;
23760 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23761 wxTimeSpan *arg2 = 0 ;
23762 wxTimeSpan *result;
23763 PyObject * obj0 = 0 ;
23764 PyObject * obj1 = 0 ;
23765 char *kwnames[] = {
23766 (char *) "self",(char *) "diff", NULL
23767 };
23768
23769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
23770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23771 if (SWIG_arg_fail(1)) SWIG_fail;
23772 {
23773 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23774 if (SWIG_arg_fail(2)) SWIG_fail;
23775 if (arg2 == NULL) {
23776 SWIG_null_ref("wxTimeSpan");
23777 }
23778 if (SWIG_arg_fail(2)) SWIG_fail;
23779 }
23780 {
23781 PyThreadState* __tstate = wxPyBeginAllowThreads();
23782 {
23783 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
23784 result = (wxTimeSpan *) &_result_ref;
23785 }
23786
23787 wxPyEndAllowThreads(__tstate);
23788 if (PyErr_Occurred()) SWIG_fail;
23789 }
23790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23791 return resultobj;
23792 fail:
23793 return NULL;
23794 }
23795
23796
23797 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
23798 PyObject *resultobj;
23799 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23800 wxTimeSpan *arg2 = 0 ;
23801 wxTimeSpan *result;
23802 PyObject * obj0 = 0 ;
23803 PyObject * obj1 = 0 ;
23804 char *kwnames[] = {
23805 (char *) "self",(char *) "diff", NULL
23806 };
23807
23808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
23809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23810 if (SWIG_arg_fail(1)) SWIG_fail;
23811 {
23812 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23813 if (SWIG_arg_fail(2)) SWIG_fail;
23814 if (arg2 == NULL) {
23815 SWIG_null_ref("wxTimeSpan");
23816 }
23817 if (SWIG_arg_fail(2)) SWIG_fail;
23818 }
23819 {
23820 PyThreadState* __tstate = wxPyBeginAllowThreads();
23821 {
23822 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
23823 result = (wxTimeSpan *) &_result_ref;
23824 }
23825
23826 wxPyEndAllowThreads(__tstate);
23827 if (PyErr_Occurred()) SWIG_fail;
23828 }
23829 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23830 return resultobj;
23831 fail:
23832 return NULL;
23833 }
23834
23835
23836 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
23837 PyObject *resultobj;
23838 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23839 int arg2 ;
23840 wxTimeSpan *result;
23841 PyObject * obj0 = 0 ;
23842 PyObject * obj1 = 0 ;
23843 char *kwnames[] = {
23844 (char *) "self",(char *) "n", NULL
23845 };
23846
23847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
23848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23849 if (SWIG_arg_fail(1)) SWIG_fail;
23850 {
23851 arg2 = (int)(SWIG_As_int(obj1));
23852 if (SWIG_arg_fail(2)) SWIG_fail;
23853 }
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 {
23857 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
23858 result = (wxTimeSpan *) &_result_ref;
23859 }
23860
23861 wxPyEndAllowThreads(__tstate);
23862 if (PyErr_Occurred()) SWIG_fail;
23863 }
23864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23865 return resultobj;
23866 fail:
23867 return NULL;
23868 }
23869
23870
23871 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
23872 PyObject *resultobj;
23873 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23874 wxTimeSpan *result;
23875 PyObject * obj0 = 0 ;
23876 char *kwnames[] = {
23877 (char *) "self", NULL
23878 };
23879
23880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
23881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23882 if (SWIG_arg_fail(1)) SWIG_fail;
23883 {
23884 PyThreadState* __tstate = wxPyBeginAllowThreads();
23885 {
23886 wxTimeSpan &_result_ref = (arg1)->Neg();
23887 result = (wxTimeSpan *) &_result_ref;
23888 }
23889
23890 wxPyEndAllowThreads(__tstate);
23891 if (PyErr_Occurred()) SWIG_fail;
23892 }
23893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
23894 return resultobj;
23895 fail:
23896 return NULL;
23897 }
23898
23899
23900 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
23901 PyObject *resultobj;
23902 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23903 wxTimeSpan result;
23904 PyObject * obj0 = 0 ;
23905 char *kwnames[] = {
23906 (char *) "self", NULL
23907 };
23908
23909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
23910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23911 if (SWIG_arg_fail(1)) SWIG_fail;
23912 {
23913 PyThreadState* __tstate = wxPyBeginAllowThreads();
23914 result = ((wxTimeSpan const *)arg1)->Abs();
23915
23916 wxPyEndAllowThreads(__tstate);
23917 if (PyErr_Occurred()) SWIG_fail;
23918 }
23919 {
23920 wxTimeSpan * resultptr;
23921 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23922 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23923 }
23924 return resultobj;
23925 fail:
23926 return NULL;
23927 }
23928
23929
23930 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
23931 PyObject *resultobj;
23932 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23933 wxTimeSpan *arg2 = 0 ;
23934 wxTimeSpan *result;
23935 PyObject * obj0 = 0 ;
23936 PyObject * obj1 = 0 ;
23937 char *kwnames[] = {
23938 (char *) "self",(char *) "diff", NULL
23939 };
23940
23941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
23942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23943 if (SWIG_arg_fail(1)) SWIG_fail;
23944 {
23945 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23946 if (SWIG_arg_fail(2)) SWIG_fail;
23947 if (arg2 == NULL) {
23948 SWIG_null_ref("wxTimeSpan");
23949 }
23950 if (SWIG_arg_fail(2)) SWIG_fail;
23951 }
23952 {
23953 PyThreadState* __tstate = wxPyBeginAllowThreads();
23954 {
23955 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
23956 result = (wxTimeSpan *) &_result_ref;
23957 }
23958
23959 wxPyEndAllowThreads(__tstate);
23960 if (PyErr_Occurred()) SWIG_fail;
23961 }
23962 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
23963 return resultobj;
23964 fail:
23965 return NULL;
23966 }
23967
23968
23969 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
23970 PyObject *resultobj;
23971 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
23972 wxTimeSpan *arg2 = 0 ;
23973 wxTimeSpan *result;
23974 PyObject * obj0 = 0 ;
23975 PyObject * obj1 = 0 ;
23976 char *kwnames[] = {
23977 (char *) "self",(char *) "diff", NULL
23978 };
23979
23980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
23981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
23982 if (SWIG_arg_fail(1)) SWIG_fail;
23983 {
23984 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23985 if (SWIG_arg_fail(2)) SWIG_fail;
23986 if (arg2 == NULL) {
23987 SWIG_null_ref("wxTimeSpan");
23988 }
23989 if (SWIG_arg_fail(2)) SWIG_fail;
23990 }
23991 {
23992 PyThreadState* __tstate = wxPyBeginAllowThreads();
23993 {
23994 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
23995 result = (wxTimeSpan *) &_result_ref;
23996 }
23997
23998 wxPyEndAllowThreads(__tstate);
23999 if (PyErr_Occurred()) SWIG_fail;
24000 }
24001 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24002 return resultobj;
24003 fail:
24004 return NULL;
24005 }
24006
24007
24008 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24009 PyObject *resultobj;
24010 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24011 int arg2 ;
24012 wxTimeSpan *result;
24013 PyObject * obj0 = 0 ;
24014 PyObject * obj1 = 0 ;
24015 char *kwnames[] = {
24016 (char *) "self",(char *) "n", NULL
24017 };
24018
24019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24021 if (SWIG_arg_fail(1)) SWIG_fail;
24022 {
24023 arg2 = (int)(SWIG_As_int(obj1));
24024 if (SWIG_arg_fail(2)) SWIG_fail;
24025 }
24026 {
24027 PyThreadState* __tstate = wxPyBeginAllowThreads();
24028 {
24029 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24030 result = (wxTimeSpan *) &_result_ref;
24031 }
24032
24033 wxPyEndAllowThreads(__tstate);
24034 if (PyErr_Occurred()) SWIG_fail;
24035 }
24036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24037 return resultobj;
24038 fail:
24039 return NULL;
24040 }
24041
24042
24043 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24044 PyObject *resultobj;
24045 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24046 wxTimeSpan *result;
24047 PyObject * obj0 = 0 ;
24048 char *kwnames[] = {
24049 (char *) "self", NULL
24050 };
24051
24052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24054 if (SWIG_arg_fail(1)) SWIG_fail;
24055 {
24056 PyThreadState* __tstate = wxPyBeginAllowThreads();
24057 {
24058 wxTimeSpan &_result_ref = (arg1)->operator -();
24059 result = (wxTimeSpan *) &_result_ref;
24060 }
24061
24062 wxPyEndAllowThreads(__tstate);
24063 if (PyErr_Occurred()) SWIG_fail;
24064 }
24065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24066 return resultobj;
24067 fail:
24068 return NULL;
24069 }
24070
24071
24072 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24073 PyObject *resultobj;
24074 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24075 wxTimeSpan *arg2 = 0 ;
24076 wxTimeSpan result;
24077 PyObject * obj0 = 0 ;
24078 PyObject * obj1 = 0 ;
24079 char *kwnames[] = {
24080 (char *) "self",(char *) "other", NULL
24081 };
24082
24083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24085 if (SWIG_arg_fail(1)) SWIG_fail;
24086 {
24087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24088 if (SWIG_arg_fail(2)) SWIG_fail;
24089 if (arg2 == NULL) {
24090 SWIG_null_ref("wxTimeSpan");
24091 }
24092 if (SWIG_arg_fail(2)) SWIG_fail;
24093 }
24094 {
24095 PyThreadState* __tstate = wxPyBeginAllowThreads();
24096 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24097
24098 wxPyEndAllowThreads(__tstate);
24099 if (PyErr_Occurred()) SWIG_fail;
24100 }
24101 {
24102 wxTimeSpan * resultptr;
24103 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24104 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24105 }
24106 return resultobj;
24107 fail:
24108 return NULL;
24109 }
24110
24111
24112 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24113 PyObject *resultobj;
24114 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24115 wxTimeSpan *arg2 = 0 ;
24116 wxTimeSpan result;
24117 PyObject * obj0 = 0 ;
24118 PyObject * obj1 = 0 ;
24119 char *kwnames[] = {
24120 (char *) "self",(char *) "other", NULL
24121 };
24122
24123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24125 if (SWIG_arg_fail(1)) SWIG_fail;
24126 {
24127 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24128 if (SWIG_arg_fail(2)) SWIG_fail;
24129 if (arg2 == NULL) {
24130 SWIG_null_ref("wxTimeSpan");
24131 }
24132 if (SWIG_arg_fail(2)) SWIG_fail;
24133 }
24134 {
24135 PyThreadState* __tstate = wxPyBeginAllowThreads();
24136 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24137
24138 wxPyEndAllowThreads(__tstate);
24139 if (PyErr_Occurred()) SWIG_fail;
24140 }
24141 {
24142 wxTimeSpan * resultptr;
24143 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24144 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24145 }
24146 return resultobj;
24147 fail:
24148 return NULL;
24149 }
24150
24151
24152 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24153 PyObject *resultobj;
24154 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24155 int arg2 ;
24156 wxTimeSpan result;
24157 PyObject * obj0 = 0 ;
24158 PyObject * obj1 = 0 ;
24159 char *kwnames[] = {
24160 (char *) "self",(char *) "n", NULL
24161 };
24162
24163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24165 if (SWIG_arg_fail(1)) SWIG_fail;
24166 {
24167 arg2 = (int)(SWIG_As_int(obj1));
24168 if (SWIG_arg_fail(2)) SWIG_fail;
24169 }
24170 {
24171 PyThreadState* __tstate = wxPyBeginAllowThreads();
24172 result = wxTimeSpan___mul__(arg1,arg2);
24173
24174 wxPyEndAllowThreads(__tstate);
24175 if (PyErr_Occurred()) SWIG_fail;
24176 }
24177 {
24178 wxTimeSpan * resultptr;
24179 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24181 }
24182 return resultobj;
24183 fail:
24184 return NULL;
24185 }
24186
24187
24188 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24189 PyObject *resultobj;
24190 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24191 int arg2 ;
24192 wxTimeSpan result;
24193 PyObject * obj0 = 0 ;
24194 PyObject * obj1 = 0 ;
24195 char *kwnames[] = {
24196 (char *) "self",(char *) "n", NULL
24197 };
24198
24199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24201 if (SWIG_arg_fail(1)) SWIG_fail;
24202 {
24203 arg2 = (int)(SWIG_As_int(obj1));
24204 if (SWIG_arg_fail(2)) SWIG_fail;
24205 }
24206 {
24207 PyThreadState* __tstate = wxPyBeginAllowThreads();
24208 result = wxTimeSpan___rmul__(arg1,arg2);
24209
24210 wxPyEndAllowThreads(__tstate);
24211 if (PyErr_Occurred()) SWIG_fail;
24212 }
24213 {
24214 wxTimeSpan * resultptr;
24215 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24216 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24217 }
24218 return resultobj;
24219 fail:
24220 return NULL;
24221 }
24222
24223
24224 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24225 PyObject *resultobj;
24226 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24227 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24228 bool result;
24229 PyObject * obj0 = 0 ;
24230 PyObject * obj1 = 0 ;
24231 char *kwnames[] = {
24232 (char *) "self",(char *) "other", NULL
24233 };
24234
24235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24237 if (SWIG_arg_fail(1)) SWIG_fail;
24238 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24239 if (SWIG_arg_fail(2)) SWIG_fail;
24240 {
24241 PyThreadState* __tstate = wxPyBeginAllowThreads();
24242 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24243
24244 wxPyEndAllowThreads(__tstate);
24245 if (PyErr_Occurred()) SWIG_fail;
24246 }
24247 {
24248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24249 }
24250 return resultobj;
24251 fail:
24252 return NULL;
24253 }
24254
24255
24256 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24257 PyObject *resultobj;
24258 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24259 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24260 bool result;
24261 PyObject * obj0 = 0 ;
24262 PyObject * obj1 = 0 ;
24263 char *kwnames[] = {
24264 (char *) "self",(char *) "other", NULL
24265 };
24266
24267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24269 if (SWIG_arg_fail(1)) SWIG_fail;
24270 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24271 if (SWIG_arg_fail(2)) SWIG_fail;
24272 {
24273 PyThreadState* __tstate = wxPyBeginAllowThreads();
24274 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24275
24276 wxPyEndAllowThreads(__tstate);
24277 if (PyErr_Occurred()) SWIG_fail;
24278 }
24279 {
24280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24281 }
24282 return resultobj;
24283 fail:
24284 return NULL;
24285 }
24286
24287
24288 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24289 PyObject *resultobj;
24290 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24291 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24292 bool result;
24293 PyObject * obj0 = 0 ;
24294 PyObject * obj1 = 0 ;
24295 char *kwnames[] = {
24296 (char *) "self",(char *) "other", NULL
24297 };
24298
24299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24301 if (SWIG_arg_fail(1)) SWIG_fail;
24302 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24303 if (SWIG_arg_fail(2)) SWIG_fail;
24304 {
24305 PyThreadState* __tstate = wxPyBeginAllowThreads();
24306 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24307
24308 wxPyEndAllowThreads(__tstate);
24309 if (PyErr_Occurred()) SWIG_fail;
24310 }
24311 {
24312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24313 }
24314 return resultobj;
24315 fail:
24316 return NULL;
24317 }
24318
24319
24320 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24321 PyObject *resultobj;
24322 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24323 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24324 bool result;
24325 PyObject * obj0 = 0 ;
24326 PyObject * obj1 = 0 ;
24327 char *kwnames[] = {
24328 (char *) "self",(char *) "other", NULL
24329 };
24330
24331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24333 if (SWIG_arg_fail(1)) SWIG_fail;
24334 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24335 if (SWIG_arg_fail(2)) SWIG_fail;
24336 {
24337 PyThreadState* __tstate = wxPyBeginAllowThreads();
24338 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24339
24340 wxPyEndAllowThreads(__tstate);
24341 if (PyErr_Occurred()) SWIG_fail;
24342 }
24343 {
24344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24345 }
24346 return resultobj;
24347 fail:
24348 return NULL;
24349 }
24350
24351
24352 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24353 PyObject *resultobj;
24354 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24355 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24356 bool result;
24357 PyObject * obj0 = 0 ;
24358 PyObject * obj1 = 0 ;
24359 char *kwnames[] = {
24360 (char *) "self",(char *) "other", NULL
24361 };
24362
24363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24365 if (SWIG_arg_fail(1)) SWIG_fail;
24366 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24367 if (SWIG_arg_fail(2)) SWIG_fail;
24368 {
24369 PyThreadState* __tstate = wxPyBeginAllowThreads();
24370 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24371
24372 wxPyEndAllowThreads(__tstate);
24373 if (PyErr_Occurred()) SWIG_fail;
24374 }
24375 {
24376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24377 }
24378 return resultobj;
24379 fail:
24380 return NULL;
24381 }
24382
24383
24384 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24385 PyObject *resultobj;
24386 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24387 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24388 bool result;
24389 PyObject * obj0 = 0 ;
24390 PyObject * obj1 = 0 ;
24391 char *kwnames[] = {
24392 (char *) "self",(char *) "other", NULL
24393 };
24394
24395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24397 if (SWIG_arg_fail(1)) SWIG_fail;
24398 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24399 if (SWIG_arg_fail(2)) SWIG_fail;
24400 {
24401 PyThreadState* __tstate = wxPyBeginAllowThreads();
24402 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24403
24404 wxPyEndAllowThreads(__tstate);
24405 if (PyErr_Occurred()) SWIG_fail;
24406 }
24407 {
24408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24409 }
24410 return resultobj;
24411 fail:
24412 return NULL;
24413 }
24414
24415
24416 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24417 PyObject *resultobj;
24418 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24419 bool result;
24420 PyObject * obj0 = 0 ;
24421 char *kwnames[] = {
24422 (char *) "self", NULL
24423 };
24424
24425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24427 if (SWIG_arg_fail(1)) SWIG_fail;
24428 {
24429 PyThreadState* __tstate = wxPyBeginAllowThreads();
24430 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24431
24432 wxPyEndAllowThreads(__tstate);
24433 if (PyErr_Occurred()) SWIG_fail;
24434 }
24435 {
24436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24437 }
24438 return resultobj;
24439 fail:
24440 return NULL;
24441 }
24442
24443
24444 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24445 PyObject *resultobj;
24446 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24447 bool result;
24448 PyObject * obj0 = 0 ;
24449 char *kwnames[] = {
24450 (char *) "self", NULL
24451 };
24452
24453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24455 if (SWIG_arg_fail(1)) SWIG_fail;
24456 {
24457 PyThreadState* __tstate = wxPyBeginAllowThreads();
24458 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24459
24460 wxPyEndAllowThreads(__tstate);
24461 if (PyErr_Occurred()) SWIG_fail;
24462 }
24463 {
24464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24465 }
24466 return resultobj;
24467 fail:
24468 return NULL;
24469 }
24470
24471
24472 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24473 PyObject *resultobj;
24474 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24475 bool result;
24476 PyObject * obj0 = 0 ;
24477 char *kwnames[] = {
24478 (char *) "self", NULL
24479 };
24480
24481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24483 if (SWIG_arg_fail(1)) SWIG_fail;
24484 {
24485 PyThreadState* __tstate = wxPyBeginAllowThreads();
24486 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24487
24488 wxPyEndAllowThreads(__tstate);
24489 if (PyErr_Occurred()) SWIG_fail;
24490 }
24491 {
24492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24493 }
24494 return resultobj;
24495 fail:
24496 return NULL;
24497 }
24498
24499
24500 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24501 PyObject *resultobj;
24502 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24503 wxTimeSpan *arg2 = 0 ;
24504 bool result;
24505 PyObject * obj0 = 0 ;
24506 PyObject * obj1 = 0 ;
24507 char *kwnames[] = {
24508 (char *) "self",(char *) "ts", NULL
24509 };
24510
24511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24513 if (SWIG_arg_fail(1)) SWIG_fail;
24514 {
24515 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24516 if (SWIG_arg_fail(2)) SWIG_fail;
24517 if (arg2 == NULL) {
24518 SWIG_null_ref("wxTimeSpan");
24519 }
24520 if (SWIG_arg_fail(2)) SWIG_fail;
24521 }
24522 {
24523 PyThreadState* __tstate = wxPyBeginAllowThreads();
24524 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24525
24526 wxPyEndAllowThreads(__tstate);
24527 if (PyErr_Occurred()) SWIG_fail;
24528 }
24529 {
24530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24531 }
24532 return resultobj;
24533 fail:
24534 return NULL;
24535 }
24536
24537
24538 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24539 PyObject *resultobj;
24540 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24541 wxTimeSpan *arg2 = 0 ;
24542 bool result;
24543 PyObject * obj0 = 0 ;
24544 PyObject * obj1 = 0 ;
24545 char *kwnames[] = {
24546 (char *) "self",(char *) "ts", NULL
24547 };
24548
24549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24551 if (SWIG_arg_fail(1)) SWIG_fail;
24552 {
24553 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24554 if (SWIG_arg_fail(2)) SWIG_fail;
24555 if (arg2 == NULL) {
24556 SWIG_null_ref("wxTimeSpan");
24557 }
24558 if (SWIG_arg_fail(2)) SWIG_fail;
24559 }
24560 {
24561 PyThreadState* __tstate = wxPyBeginAllowThreads();
24562 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24563
24564 wxPyEndAllowThreads(__tstate);
24565 if (PyErr_Occurred()) SWIG_fail;
24566 }
24567 {
24568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24569 }
24570 return resultobj;
24571 fail:
24572 return NULL;
24573 }
24574
24575
24576 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24577 PyObject *resultobj;
24578 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24579 wxTimeSpan *arg2 = 0 ;
24580 bool result;
24581 PyObject * obj0 = 0 ;
24582 PyObject * obj1 = 0 ;
24583 char *kwnames[] = {
24584 (char *) "self",(char *) "t", NULL
24585 };
24586
24587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24589 if (SWIG_arg_fail(1)) SWIG_fail;
24590 {
24591 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24592 if (SWIG_arg_fail(2)) SWIG_fail;
24593 if (arg2 == NULL) {
24594 SWIG_null_ref("wxTimeSpan");
24595 }
24596 if (SWIG_arg_fail(2)) SWIG_fail;
24597 }
24598 {
24599 PyThreadState* __tstate = wxPyBeginAllowThreads();
24600 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24601
24602 wxPyEndAllowThreads(__tstate);
24603 if (PyErr_Occurred()) SWIG_fail;
24604 }
24605 {
24606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24607 }
24608 return resultobj;
24609 fail:
24610 return NULL;
24611 }
24612
24613
24614 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24615 PyObject *resultobj;
24616 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24617 int result;
24618 PyObject * obj0 = 0 ;
24619 char *kwnames[] = {
24620 (char *) "self", NULL
24621 };
24622
24623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24625 if (SWIG_arg_fail(1)) SWIG_fail;
24626 {
24627 PyThreadState* __tstate = wxPyBeginAllowThreads();
24628 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24629
24630 wxPyEndAllowThreads(__tstate);
24631 if (PyErr_Occurred()) SWIG_fail;
24632 }
24633 {
24634 resultobj = SWIG_From_int((int)(result));
24635 }
24636 return resultobj;
24637 fail:
24638 return NULL;
24639 }
24640
24641
24642 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24643 PyObject *resultobj;
24644 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24645 int result;
24646 PyObject * obj0 = 0 ;
24647 char *kwnames[] = {
24648 (char *) "self", NULL
24649 };
24650
24651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24653 if (SWIG_arg_fail(1)) SWIG_fail;
24654 {
24655 PyThreadState* __tstate = wxPyBeginAllowThreads();
24656 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24657
24658 wxPyEndAllowThreads(__tstate);
24659 if (PyErr_Occurred()) SWIG_fail;
24660 }
24661 {
24662 resultobj = SWIG_From_int((int)(result));
24663 }
24664 return resultobj;
24665 fail:
24666 return NULL;
24667 }
24668
24669
24670 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
24671 PyObject *resultobj;
24672 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24673 int result;
24674 PyObject * obj0 = 0 ;
24675 char *kwnames[] = {
24676 (char *) "self", NULL
24677 };
24678
24679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
24680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24681 if (SWIG_arg_fail(1)) SWIG_fail;
24682 {
24683 PyThreadState* __tstate = wxPyBeginAllowThreads();
24684 result = (int)((wxTimeSpan const *)arg1)->GetHours();
24685
24686 wxPyEndAllowThreads(__tstate);
24687 if (PyErr_Occurred()) SWIG_fail;
24688 }
24689 {
24690 resultobj = SWIG_From_int((int)(result));
24691 }
24692 return resultobj;
24693 fail:
24694 return NULL;
24695 }
24696
24697
24698 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
24699 PyObject *resultobj;
24700 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24701 int result;
24702 PyObject * obj0 = 0 ;
24703 char *kwnames[] = {
24704 (char *) "self", NULL
24705 };
24706
24707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
24708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24709 if (SWIG_arg_fail(1)) SWIG_fail;
24710 {
24711 PyThreadState* __tstate = wxPyBeginAllowThreads();
24712 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
24713
24714 wxPyEndAllowThreads(__tstate);
24715 if (PyErr_Occurred()) SWIG_fail;
24716 }
24717 {
24718 resultobj = SWIG_From_int((int)(result));
24719 }
24720 return resultobj;
24721 fail:
24722 return NULL;
24723 }
24724
24725
24726 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
24727 PyObject *resultobj;
24728 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24729 wxLongLong result;
24730 PyObject * obj0 = 0 ;
24731 char *kwnames[] = {
24732 (char *) "self", NULL
24733 };
24734
24735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
24736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24737 if (SWIG_arg_fail(1)) SWIG_fail;
24738 {
24739 PyThreadState* __tstate = wxPyBeginAllowThreads();
24740 result = ((wxTimeSpan const *)arg1)->GetSeconds();
24741
24742 wxPyEndAllowThreads(__tstate);
24743 if (PyErr_Occurred()) SWIG_fail;
24744 }
24745 {
24746 PyObject *hi, *lo, *shifter, *shifted;
24747 hi = PyLong_FromLong( (&result)->GetHi() );
24748 lo = PyLong_FromLong( (&result)->GetLo() );
24749 shifter = PyLong_FromLong(32);
24750 shifted = PyNumber_Lshift(hi, shifter);
24751 resultobj = PyNumber_Or(shifted, lo);
24752 Py_DECREF(hi);
24753 Py_DECREF(lo);
24754 Py_DECREF(shifter);
24755 Py_DECREF(shifted);
24756 }
24757 return resultobj;
24758 fail:
24759 return NULL;
24760 }
24761
24762
24763 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
24764 PyObject *resultobj;
24765 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24766 wxLongLong result;
24767 PyObject * obj0 = 0 ;
24768 char *kwnames[] = {
24769 (char *) "self", NULL
24770 };
24771
24772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
24773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24774 if (SWIG_arg_fail(1)) SWIG_fail;
24775 {
24776 PyThreadState* __tstate = wxPyBeginAllowThreads();
24777 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
24778
24779 wxPyEndAllowThreads(__tstate);
24780 if (PyErr_Occurred()) SWIG_fail;
24781 }
24782 {
24783 PyObject *hi, *lo, *shifter, *shifted;
24784 hi = PyLong_FromLong( (&result)->GetHi() );
24785 lo = PyLong_FromLong( (&result)->GetLo() );
24786 shifter = PyLong_FromLong(32);
24787 shifted = PyNumber_Lshift(hi, shifter);
24788 resultobj = PyNumber_Or(shifted, lo);
24789 Py_DECREF(hi);
24790 Py_DECREF(lo);
24791 Py_DECREF(shifter);
24792 Py_DECREF(shifted);
24793 }
24794 return resultobj;
24795 fail:
24796 return NULL;
24797 }
24798
24799
24800 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
24801 PyObject *resultobj;
24802 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24803 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
24804 wxString *arg2 = (wxString *) &arg2_defvalue ;
24805 wxString result;
24806 bool temp2 = false ;
24807 PyObject * obj0 = 0 ;
24808 PyObject * obj1 = 0 ;
24809 char *kwnames[] = {
24810 (char *) "self",(char *) "format", NULL
24811 };
24812
24813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
24814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24815 if (SWIG_arg_fail(1)) SWIG_fail;
24816 if (obj1) {
24817 {
24818 arg2 = wxString_in_helper(obj1);
24819 if (arg2 == NULL) SWIG_fail;
24820 temp2 = true;
24821 }
24822 }
24823 {
24824 PyThreadState* __tstate = wxPyBeginAllowThreads();
24825 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
24826
24827 wxPyEndAllowThreads(__tstate);
24828 if (PyErr_Occurred()) SWIG_fail;
24829 }
24830 {
24831 #if wxUSE_UNICODE
24832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24833 #else
24834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24835 #endif
24836 }
24837 {
24838 if (temp2)
24839 delete arg2;
24840 }
24841 return resultobj;
24842 fail:
24843 {
24844 if (temp2)
24845 delete arg2;
24846 }
24847 return NULL;
24848 }
24849
24850
24851 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
24852 PyObject *obj;
24853 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24854 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
24855 Py_INCREF(obj);
24856 return Py_BuildValue((char *)"");
24857 }
24858 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24859 PyObject *resultobj;
24860 int arg1 = (int) 0 ;
24861 int arg2 = (int) 0 ;
24862 int arg3 = (int) 0 ;
24863 int arg4 = (int) 0 ;
24864 wxDateSpan *result;
24865 PyObject * obj0 = 0 ;
24866 PyObject * obj1 = 0 ;
24867 PyObject * obj2 = 0 ;
24868 PyObject * obj3 = 0 ;
24869 char *kwnames[] = {
24870 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
24871 };
24872
24873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24874 if (obj0) {
24875 {
24876 arg1 = (int)(SWIG_As_int(obj0));
24877 if (SWIG_arg_fail(1)) SWIG_fail;
24878 }
24879 }
24880 if (obj1) {
24881 {
24882 arg2 = (int)(SWIG_As_int(obj1));
24883 if (SWIG_arg_fail(2)) SWIG_fail;
24884 }
24885 }
24886 if (obj2) {
24887 {
24888 arg3 = (int)(SWIG_As_int(obj2));
24889 if (SWIG_arg_fail(3)) SWIG_fail;
24890 }
24891 }
24892 if (obj3) {
24893 {
24894 arg4 = (int)(SWIG_As_int(obj3));
24895 if (SWIG_arg_fail(4)) SWIG_fail;
24896 }
24897 }
24898 {
24899 PyThreadState* __tstate = wxPyBeginAllowThreads();
24900 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
24901
24902 wxPyEndAllowThreads(__tstate);
24903 if (PyErr_Occurred()) SWIG_fail;
24904 }
24905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
24906 return resultobj;
24907 fail:
24908 return NULL;
24909 }
24910
24911
24912 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24913 PyObject *resultobj;
24914 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
24915 PyObject * obj0 = 0 ;
24916 char *kwnames[] = {
24917 (char *) "self", NULL
24918 };
24919
24920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
24921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
24922 if (SWIG_arg_fail(1)) SWIG_fail;
24923 {
24924 PyThreadState* __tstate = wxPyBeginAllowThreads();
24925 delete arg1;
24926
24927 wxPyEndAllowThreads(__tstate);
24928 if (PyErr_Occurred()) SWIG_fail;
24929 }
24930 Py_INCREF(Py_None); resultobj = Py_None;
24931 return resultobj;
24932 fail:
24933 return NULL;
24934 }
24935
24936
24937 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24938 PyObject *resultobj;
24939 int arg1 ;
24940 wxDateSpan result;
24941 PyObject * obj0 = 0 ;
24942 char *kwnames[] = {
24943 (char *) "days", NULL
24944 };
24945
24946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
24947 {
24948 arg1 = (int)(SWIG_As_int(obj0));
24949 if (SWIG_arg_fail(1)) SWIG_fail;
24950 }
24951 {
24952 PyThreadState* __tstate = wxPyBeginAllowThreads();
24953 result = wxDateSpan::Days(arg1);
24954
24955 wxPyEndAllowThreads(__tstate);
24956 if (PyErr_Occurred()) SWIG_fail;
24957 }
24958 {
24959 wxDateSpan * resultptr;
24960 resultptr = new wxDateSpan((wxDateSpan &)(result));
24961 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
24962 }
24963 return resultobj;
24964 fail:
24965 return NULL;
24966 }
24967
24968
24969 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24970 PyObject *resultobj;
24971 wxDateSpan result;
24972 char *kwnames[] = {
24973 NULL
24974 };
24975
24976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
24977 {
24978 PyThreadState* __tstate = wxPyBeginAllowThreads();
24979 result = wxDateSpan::Day();
24980
24981 wxPyEndAllowThreads(__tstate);
24982 if (PyErr_Occurred()) SWIG_fail;
24983 }
24984 {
24985 wxDateSpan * resultptr;
24986 resultptr = new wxDateSpan((wxDateSpan &)(result));
24987 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
24988 }
24989 return resultobj;
24990 fail:
24991 return NULL;
24992 }
24993
24994
24995 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24996 PyObject *resultobj;
24997 int arg1 ;
24998 wxDateSpan result;
24999 PyObject * obj0 = 0 ;
25000 char *kwnames[] = {
25001 (char *) "weeks", NULL
25002 };
25003
25004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25005 {
25006 arg1 = (int)(SWIG_As_int(obj0));
25007 if (SWIG_arg_fail(1)) SWIG_fail;
25008 }
25009 {
25010 PyThreadState* __tstate = wxPyBeginAllowThreads();
25011 result = wxDateSpan::Weeks(arg1);
25012
25013 wxPyEndAllowThreads(__tstate);
25014 if (PyErr_Occurred()) SWIG_fail;
25015 }
25016 {
25017 wxDateSpan * resultptr;
25018 resultptr = new wxDateSpan((wxDateSpan &)(result));
25019 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25020 }
25021 return resultobj;
25022 fail:
25023 return NULL;
25024 }
25025
25026
25027 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25028 PyObject *resultobj;
25029 wxDateSpan result;
25030 char *kwnames[] = {
25031 NULL
25032 };
25033
25034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25035 {
25036 PyThreadState* __tstate = wxPyBeginAllowThreads();
25037 result = wxDateSpan::Week();
25038
25039 wxPyEndAllowThreads(__tstate);
25040 if (PyErr_Occurred()) SWIG_fail;
25041 }
25042 {
25043 wxDateSpan * resultptr;
25044 resultptr = new wxDateSpan((wxDateSpan &)(result));
25045 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25046 }
25047 return resultobj;
25048 fail:
25049 return NULL;
25050 }
25051
25052
25053 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25054 PyObject *resultobj;
25055 int arg1 ;
25056 wxDateSpan result;
25057 PyObject * obj0 = 0 ;
25058 char *kwnames[] = {
25059 (char *) "mon", NULL
25060 };
25061
25062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25063 {
25064 arg1 = (int)(SWIG_As_int(obj0));
25065 if (SWIG_arg_fail(1)) SWIG_fail;
25066 }
25067 {
25068 PyThreadState* __tstate = wxPyBeginAllowThreads();
25069 result = wxDateSpan::Months(arg1);
25070
25071 wxPyEndAllowThreads(__tstate);
25072 if (PyErr_Occurred()) SWIG_fail;
25073 }
25074 {
25075 wxDateSpan * resultptr;
25076 resultptr = new wxDateSpan((wxDateSpan &)(result));
25077 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25078 }
25079 return resultobj;
25080 fail:
25081 return NULL;
25082 }
25083
25084
25085 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25086 PyObject *resultobj;
25087 wxDateSpan result;
25088 char *kwnames[] = {
25089 NULL
25090 };
25091
25092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25093 {
25094 PyThreadState* __tstate = wxPyBeginAllowThreads();
25095 result = wxDateSpan::Month();
25096
25097 wxPyEndAllowThreads(__tstate);
25098 if (PyErr_Occurred()) SWIG_fail;
25099 }
25100 {
25101 wxDateSpan * resultptr;
25102 resultptr = new wxDateSpan((wxDateSpan &)(result));
25103 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25104 }
25105 return resultobj;
25106 fail:
25107 return NULL;
25108 }
25109
25110
25111 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25112 PyObject *resultobj;
25113 int arg1 ;
25114 wxDateSpan result;
25115 PyObject * obj0 = 0 ;
25116 char *kwnames[] = {
25117 (char *) "years", NULL
25118 };
25119
25120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25121 {
25122 arg1 = (int)(SWIG_As_int(obj0));
25123 if (SWIG_arg_fail(1)) SWIG_fail;
25124 }
25125 {
25126 PyThreadState* __tstate = wxPyBeginAllowThreads();
25127 result = wxDateSpan::Years(arg1);
25128
25129 wxPyEndAllowThreads(__tstate);
25130 if (PyErr_Occurred()) SWIG_fail;
25131 }
25132 {
25133 wxDateSpan * resultptr;
25134 resultptr = new wxDateSpan((wxDateSpan &)(result));
25135 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25136 }
25137 return resultobj;
25138 fail:
25139 return NULL;
25140 }
25141
25142
25143 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25144 PyObject *resultobj;
25145 wxDateSpan result;
25146 char *kwnames[] = {
25147 NULL
25148 };
25149
25150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25151 {
25152 PyThreadState* __tstate = wxPyBeginAllowThreads();
25153 result = wxDateSpan::Year();
25154
25155 wxPyEndAllowThreads(__tstate);
25156 if (PyErr_Occurred()) SWIG_fail;
25157 }
25158 {
25159 wxDateSpan * resultptr;
25160 resultptr = new wxDateSpan((wxDateSpan &)(result));
25161 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25162 }
25163 return resultobj;
25164 fail:
25165 return NULL;
25166 }
25167
25168
25169 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25170 PyObject *resultobj;
25171 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25172 int arg2 ;
25173 wxDateSpan *result;
25174 PyObject * obj0 = 0 ;
25175 PyObject * obj1 = 0 ;
25176 char *kwnames[] = {
25177 (char *) "self",(char *) "n", NULL
25178 };
25179
25180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25182 if (SWIG_arg_fail(1)) SWIG_fail;
25183 {
25184 arg2 = (int)(SWIG_As_int(obj1));
25185 if (SWIG_arg_fail(2)) SWIG_fail;
25186 }
25187 {
25188 PyThreadState* __tstate = wxPyBeginAllowThreads();
25189 {
25190 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25191 result = (wxDateSpan *) &_result_ref;
25192 }
25193
25194 wxPyEndAllowThreads(__tstate);
25195 if (PyErr_Occurred()) SWIG_fail;
25196 }
25197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25198 return resultobj;
25199 fail:
25200 return NULL;
25201 }
25202
25203
25204 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25205 PyObject *resultobj;
25206 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25207 int arg2 ;
25208 wxDateSpan *result;
25209 PyObject * obj0 = 0 ;
25210 PyObject * obj1 = 0 ;
25211 char *kwnames[] = {
25212 (char *) "self",(char *) "n", NULL
25213 };
25214
25215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25217 if (SWIG_arg_fail(1)) SWIG_fail;
25218 {
25219 arg2 = (int)(SWIG_As_int(obj1));
25220 if (SWIG_arg_fail(2)) SWIG_fail;
25221 }
25222 {
25223 PyThreadState* __tstate = wxPyBeginAllowThreads();
25224 {
25225 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25226 result = (wxDateSpan *) &_result_ref;
25227 }
25228
25229 wxPyEndAllowThreads(__tstate);
25230 if (PyErr_Occurred()) SWIG_fail;
25231 }
25232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25233 return resultobj;
25234 fail:
25235 return NULL;
25236 }
25237
25238
25239 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25240 PyObject *resultobj;
25241 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25242 int arg2 ;
25243 wxDateSpan *result;
25244 PyObject * obj0 = 0 ;
25245 PyObject * obj1 = 0 ;
25246 char *kwnames[] = {
25247 (char *) "self",(char *) "n", NULL
25248 };
25249
25250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25252 if (SWIG_arg_fail(1)) SWIG_fail;
25253 {
25254 arg2 = (int)(SWIG_As_int(obj1));
25255 if (SWIG_arg_fail(2)) SWIG_fail;
25256 }
25257 {
25258 PyThreadState* __tstate = wxPyBeginAllowThreads();
25259 {
25260 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25261 result = (wxDateSpan *) &_result_ref;
25262 }
25263
25264 wxPyEndAllowThreads(__tstate);
25265 if (PyErr_Occurred()) SWIG_fail;
25266 }
25267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25268 return resultobj;
25269 fail:
25270 return NULL;
25271 }
25272
25273
25274 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25275 PyObject *resultobj;
25276 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25277 int arg2 ;
25278 wxDateSpan *result;
25279 PyObject * obj0 = 0 ;
25280 PyObject * obj1 = 0 ;
25281 char *kwnames[] = {
25282 (char *) "self",(char *) "n", NULL
25283 };
25284
25285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25287 if (SWIG_arg_fail(1)) SWIG_fail;
25288 {
25289 arg2 = (int)(SWIG_As_int(obj1));
25290 if (SWIG_arg_fail(2)) SWIG_fail;
25291 }
25292 {
25293 PyThreadState* __tstate = wxPyBeginAllowThreads();
25294 {
25295 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25296 result = (wxDateSpan *) &_result_ref;
25297 }
25298
25299 wxPyEndAllowThreads(__tstate);
25300 if (PyErr_Occurred()) SWIG_fail;
25301 }
25302 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25303 return resultobj;
25304 fail:
25305 return NULL;
25306 }
25307
25308
25309 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25310 PyObject *resultobj;
25311 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25312 int result;
25313 PyObject * obj0 = 0 ;
25314 char *kwnames[] = {
25315 (char *) "self", NULL
25316 };
25317
25318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25320 if (SWIG_arg_fail(1)) SWIG_fail;
25321 {
25322 PyThreadState* __tstate = wxPyBeginAllowThreads();
25323 result = (int)((wxDateSpan const *)arg1)->GetYears();
25324
25325 wxPyEndAllowThreads(__tstate);
25326 if (PyErr_Occurred()) SWIG_fail;
25327 }
25328 {
25329 resultobj = SWIG_From_int((int)(result));
25330 }
25331 return resultobj;
25332 fail:
25333 return NULL;
25334 }
25335
25336
25337 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25338 PyObject *resultobj;
25339 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25340 int result;
25341 PyObject * obj0 = 0 ;
25342 char *kwnames[] = {
25343 (char *) "self", NULL
25344 };
25345
25346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25348 if (SWIG_arg_fail(1)) SWIG_fail;
25349 {
25350 PyThreadState* __tstate = wxPyBeginAllowThreads();
25351 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25352
25353 wxPyEndAllowThreads(__tstate);
25354 if (PyErr_Occurred()) SWIG_fail;
25355 }
25356 {
25357 resultobj = SWIG_From_int((int)(result));
25358 }
25359 return resultobj;
25360 fail:
25361 return NULL;
25362 }
25363
25364
25365 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25366 PyObject *resultobj;
25367 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25368 int result;
25369 PyObject * obj0 = 0 ;
25370 char *kwnames[] = {
25371 (char *) "self", NULL
25372 };
25373
25374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25376 if (SWIG_arg_fail(1)) SWIG_fail;
25377 {
25378 PyThreadState* __tstate = wxPyBeginAllowThreads();
25379 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25380
25381 wxPyEndAllowThreads(__tstate);
25382 if (PyErr_Occurred()) SWIG_fail;
25383 }
25384 {
25385 resultobj = SWIG_From_int((int)(result));
25386 }
25387 return resultobj;
25388 fail:
25389 return NULL;
25390 }
25391
25392
25393 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25394 PyObject *resultobj;
25395 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25396 int result;
25397 PyObject * obj0 = 0 ;
25398 char *kwnames[] = {
25399 (char *) "self", NULL
25400 };
25401
25402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25404 if (SWIG_arg_fail(1)) SWIG_fail;
25405 {
25406 PyThreadState* __tstate = wxPyBeginAllowThreads();
25407 result = (int)((wxDateSpan const *)arg1)->GetDays();
25408
25409 wxPyEndAllowThreads(__tstate);
25410 if (PyErr_Occurred()) SWIG_fail;
25411 }
25412 {
25413 resultobj = SWIG_From_int((int)(result));
25414 }
25415 return resultobj;
25416 fail:
25417 return NULL;
25418 }
25419
25420
25421 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25422 PyObject *resultobj;
25423 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25424 int result;
25425 PyObject * obj0 = 0 ;
25426 char *kwnames[] = {
25427 (char *) "self", NULL
25428 };
25429
25430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25432 if (SWIG_arg_fail(1)) SWIG_fail;
25433 {
25434 PyThreadState* __tstate = wxPyBeginAllowThreads();
25435 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25436
25437 wxPyEndAllowThreads(__tstate);
25438 if (PyErr_Occurred()) SWIG_fail;
25439 }
25440 {
25441 resultobj = SWIG_From_int((int)(result));
25442 }
25443 return resultobj;
25444 fail:
25445 return NULL;
25446 }
25447
25448
25449 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25450 PyObject *resultobj;
25451 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25452 wxDateSpan *arg2 = 0 ;
25453 wxDateSpan *result;
25454 PyObject * obj0 = 0 ;
25455 PyObject * obj1 = 0 ;
25456 char *kwnames[] = {
25457 (char *) "self",(char *) "other", NULL
25458 };
25459
25460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25462 if (SWIG_arg_fail(1)) SWIG_fail;
25463 {
25464 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25465 if (SWIG_arg_fail(2)) SWIG_fail;
25466 if (arg2 == NULL) {
25467 SWIG_null_ref("wxDateSpan");
25468 }
25469 if (SWIG_arg_fail(2)) SWIG_fail;
25470 }
25471 {
25472 PyThreadState* __tstate = wxPyBeginAllowThreads();
25473 {
25474 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25475 result = (wxDateSpan *) &_result_ref;
25476 }
25477
25478 wxPyEndAllowThreads(__tstate);
25479 if (PyErr_Occurred()) SWIG_fail;
25480 }
25481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25482 return resultobj;
25483 fail:
25484 return NULL;
25485 }
25486
25487
25488 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25489 PyObject *resultobj;
25490 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25491 wxDateSpan *arg2 = 0 ;
25492 wxDateSpan *result;
25493 PyObject * obj0 = 0 ;
25494 PyObject * obj1 = 0 ;
25495 char *kwnames[] = {
25496 (char *) "self",(char *) "other", NULL
25497 };
25498
25499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25501 if (SWIG_arg_fail(1)) SWIG_fail;
25502 {
25503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25504 if (SWIG_arg_fail(2)) SWIG_fail;
25505 if (arg2 == NULL) {
25506 SWIG_null_ref("wxDateSpan");
25507 }
25508 if (SWIG_arg_fail(2)) SWIG_fail;
25509 }
25510 {
25511 PyThreadState* __tstate = wxPyBeginAllowThreads();
25512 {
25513 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25514 result = (wxDateSpan *) &_result_ref;
25515 }
25516
25517 wxPyEndAllowThreads(__tstate);
25518 if (PyErr_Occurred()) SWIG_fail;
25519 }
25520 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25521 return resultobj;
25522 fail:
25523 return NULL;
25524 }
25525
25526
25527 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25528 PyObject *resultobj;
25529 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25530 wxDateSpan *result;
25531 PyObject * obj0 = 0 ;
25532 char *kwnames[] = {
25533 (char *) "self", NULL
25534 };
25535
25536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25538 if (SWIG_arg_fail(1)) SWIG_fail;
25539 {
25540 PyThreadState* __tstate = wxPyBeginAllowThreads();
25541 {
25542 wxDateSpan &_result_ref = (arg1)->Neg();
25543 result = (wxDateSpan *) &_result_ref;
25544 }
25545
25546 wxPyEndAllowThreads(__tstate);
25547 if (PyErr_Occurred()) SWIG_fail;
25548 }
25549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25550 return resultobj;
25551 fail:
25552 return NULL;
25553 }
25554
25555
25556 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25557 PyObject *resultobj;
25558 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25559 int arg2 ;
25560 wxDateSpan *result;
25561 PyObject * obj0 = 0 ;
25562 PyObject * obj1 = 0 ;
25563 char *kwnames[] = {
25564 (char *) "self",(char *) "factor", NULL
25565 };
25566
25567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25569 if (SWIG_arg_fail(1)) SWIG_fail;
25570 {
25571 arg2 = (int)(SWIG_As_int(obj1));
25572 if (SWIG_arg_fail(2)) SWIG_fail;
25573 }
25574 {
25575 PyThreadState* __tstate = wxPyBeginAllowThreads();
25576 {
25577 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25578 result = (wxDateSpan *) &_result_ref;
25579 }
25580
25581 wxPyEndAllowThreads(__tstate);
25582 if (PyErr_Occurred()) SWIG_fail;
25583 }
25584 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25585 return resultobj;
25586 fail:
25587 return NULL;
25588 }
25589
25590
25591 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25592 PyObject *resultobj;
25593 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25594 wxDateSpan *arg2 = 0 ;
25595 wxDateSpan *result;
25596 PyObject * obj0 = 0 ;
25597 PyObject * obj1 = 0 ;
25598 char *kwnames[] = {
25599 (char *) "self",(char *) "other", NULL
25600 };
25601
25602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25604 if (SWIG_arg_fail(1)) SWIG_fail;
25605 {
25606 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25607 if (SWIG_arg_fail(2)) SWIG_fail;
25608 if (arg2 == NULL) {
25609 SWIG_null_ref("wxDateSpan");
25610 }
25611 if (SWIG_arg_fail(2)) SWIG_fail;
25612 }
25613 {
25614 PyThreadState* __tstate = wxPyBeginAllowThreads();
25615 {
25616 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25617 result = (wxDateSpan *) &_result_ref;
25618 }
25619
25620 wxPyEndAllowThreads(__tstate);
25621 if (PyErr_Occurred()) SWIG_fail;
25622 }
25623 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25624 return resultobj;
25625 fail:
25626 return NULL;
25627 }
25628
25629
25630 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25631 PyObject *resultobj;
25632 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25633 wxDateSpan *arg2 = 0 ;
25634 wxDateSpan *result;
25635 PyObject * obj0 = 0 ;
25636 PyObject * obj1 = 0 ;
25637 char *kwnames[] = {
25638 (char *) "self",(char *) "other", NULL
25639 };
25640
25641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25643 if (SWIG_arg_fail(1)) SWIG_fail;
25644 {
25645 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25646 if (SWIG_arg_fail(2)) SWIG_fail;
25647 if (arg2 == NULL) {
25648 SWIG_null_ref("wxDateSpan");
25649 }
25650 if (SWIG_arg_fail(2)) SWIG_fail;
25651 }
25652 {
25653 PyThreadState* __tstate = wxPyBeginAllowThreads();
25654 {
25655 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25656 result = (wxDateSpan *) &_result_ref;
25657 }
25658
25659 wxPyEndAllowThreads(__tstate);
25660 if (PyErr_Occurred()) SWIG_fail;
25661 }
25662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25663 return resultobj;
25664 fail:
25665 return NULL;
25666 }
25667
25668
25669 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
25670 PyObject *resultobj;
25671 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25672 wxDateSpan *result;
25673 PyObject * obj0 = 0 ;
25674 char *kwnames[] = {
25675 (char *) "self", NULL
25676 };
25677
25678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
25679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25680 if (SWIG_arg_fail(1)) SWIG_fail;
25681 {
25682 PyThreadState* __tstate = wxPyBeginAllowThreads();
25683 {
25684 wxDateSpan &_result_ref = (arg1)->operator -();
25685 result = (wxDateSpan *) &_result_ref;
25686 }
25687
25688 wxPyEndAllowThreads(__tstate);
25689 if (PyErr_Occurred()) SWIG_fail;
25690 }
25691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25692 return resultobj;
25693 fail:
25694 return NULL;
25695 }
25696
25697
25698 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
25699 PyObject *resultobj;
25700 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25701 int arg2 ;
25702 wxDateSpan *result;
25703 PyObject * obj0 = 0 ;
25704 PyObject * obj1 = 0 ;
25705 char *kwnames[] = {
25706 (char *) "self",(char *) "factor", NULL
25707 };
25708
25709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
25710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25711 if (SWIG_arg_fail(1)) SWIG_fail;
25712 {
25713 arg2 = (int)(SWIG_As_int(obj1));
25714 if (SWIG_arg_fail(2)) SWIG_fail;
25715 }
25716 {
25717 PyThreadState* __tstate = wxPyBeginAllowThreads();
25718 {
25719 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
25720 result = (wxDateSpan *) &_result_ref;
25721 }
25722
25723 wxPyEndAllowThreads(__tstate);
25724 if (PyErr_Occurred()) SWIG_fail;
25725 }
25726 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25727 return resultobj;
25728 fail:
25729 return NULL;
25730 }
25731
25732
25733 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
25734 PyObject *resultobj;
25735 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25736 wxDateSpan *arg2 = 0 ;
25737 wxDateSpan result;
25738 PyObject * obj0 = 0 ;
25739 PyObject * obj1 = 0 ;
25740 char *kwnames[] = {
25741 (char *) "self",(char *) "other", NULL
25742 };
25743
25744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
25745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25746 if (SWIG_arg_fail(1)) SWIG_fail;
25747 {
25748 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25749 if (SWIG_arg_fail(2)) SWIG_fail;
25750 if (arg2 == NULL) {
25751 SWIG_null_ref("wxDateSpan");
25752 }
25753 if (SWIG_arg_fail(2)) SWIG_fail;
25754 }
25755 {
25756 PyThreadState* __tstate = wxPyBeginAllowThreads();
25757 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
25758
25759 wxPyEndAllowThreads(__tstate);
25760 if (PyErr_Occurred()) SWIG_fail;
25761 }
25762 {
25763 wxDateSpan * resultptr;
25764 resultptr = new wxDateSpan((wxDateSpan &)(result));
25765 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25766 }
25767 return resultobj;
25768 fail:
25769 return NULL;
25770 }
25771
25772
25773 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
25774 PyObject *resultobj;
25775 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25776 wxDateSpan *arg2 = 0 ;
25777 wxDateSpan result;
25778 PyObject * obj0 = 0 ;
25779 PyObject * obj1 = 0 ;
25780 char *kwnames[] = {
25781 (char *) "self",(char *) "other", NULL
25782 };
25783
25784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
25785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25786 if (SWIG_arg_fail(1)) SWIG_fail;
25787 {
25788 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25789 if (SWIG_arg_fail(2)) SWIG_fail;
25790 if (arg2 == NULL) {
25791 SWIG_null_ref("wxDateSpan");
25792 }
25793 if (SWIG_arg_fail(2)) SWIG_fail;
25794 }
25795 {
25796 PyThreadState* __tstate = wxPyBeginAllowThreads();
25797 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
25798
25799 wxPyEndAllowThreads(__tstate);
25800 if (PyErr_Occurred()) SWIG_fail;
25801 }
25802 {
25803 wxDateSpan * resultptr;
25804 resultptr = new wxDateSpan((wxDateSpan &)(result));
25805 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25806 }
25807 return resultobj;
25808 fail:
25809 return NULL;
25810 }
25811
25812
25813 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
25814 PyObject *resultobj;
25815 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25816 int arg2 ;
25817 wxDateSpan result;
25818 PyObject * obj0 = 0 ;
25819 PyObject * obj1 = 0 ;
25820 char *kwnames[] = {
25821 (char *) "self",(char *) "n", NULL
25822 };
25823
25824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
25825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25826 if (SWIG_arg_fail(1)) SWIG_fail;
25827 {
25828 arg2 = (int)(SWIG_As_int(obj1));
25829 if (SWIG_arg_fail(2)) SWIG_fail;
25830 }
25831 {
25832 PyThreadState* __tstate = wxPyBeginAllowThreads();
25833 result = wxDateSpan___mul__(arg1,arg2);
25834
25835 wxPyEndAllowThreads(__tstate);
25836 if (PyErr_Occurred()) SWIG_fail;
25837 }
25838 {
25839 wxDateSpan * resultptr;
25840 resultptr = new wxDateSpan((wxDateSpan &)(result));
25841 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25842 }
25843 return resultobj;
25844 fail:
25845 return NULL;
25846 }
25847
25848
25849 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
25850 PyObject *resultobj;
25851 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25852 int arg2 ;
25853 wxDateSpan result;
25854 PyObject * obj0 = 0 ;
25855 PyObject * obj1 = 0 ;
25856 char *kwnames[] = {
25857 (char *) "self",(char *) "n", NULL
25858 };
25859
25860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
25861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25862 if (SWIG_arg_fail(1)) SWIG_fail;
25863 {
25864 arg2 = (int)(SWIG_As_int(obj1));
25865 if (SWIG_arg_fail(2)) SWIG_fail;
25866 }
25867 {
25868 PyThreadState* __tstate = wxPyBeginAllowThreads();
25869 result = wxDateSpan___rmul__(arg1,arg2);
25870
25871 wxPyEndAllowThreads(__tstate);
25872 if (PyErr_Occurred()) SWIG_fail;
25873 }
25874 {
25875 wxDateSpan * resultptr;
25876 resultptr = new wxDateSpan((wxDateSpan &)(result));
25877 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25878 }
25879 return resultobj;
25880 fail:
25881 return NULL;
25882 }
25883
25884
25885 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
25886 PyObject *resultobj;
25887 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25888 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
25889 bool result;
25890 PyObject * obj0 = 0 ;
25891 PyObject * obj1 = 0 ;
25892 char *kwnames[] = {
25893 (char *) "self",(char *) "other", NULL
25894 };
25895
25896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
25897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25898 if (SWIG_arg_fail(1)) SWIG_fail;
25899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25900 if (SWIG_arg_fail(2)) SWIG_fail;
25901 {
25902 PyThreadState* __tstate = wxPyBeginAllowThreads();
25903 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
25904
25905 wxPyEndAllowThreads(__tstate);
25906 if (PyErr_Occurred()) SWIG_fail;
25907 }
25908 {
25909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25910 }
25911 return resultobj;
25912 fail:
25913 return NULL;
25914 }
25915
25916
25917 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
25918 PyObject *resultobj;
25919 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25920 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
25921 bool result;
25922 PyObject * obj0 = 0 ;
25923 PyObject * obj1 = 0 ;
25924 char *kwnames[] = {
25925 (char *) "self",(char *) "other", NULL
25926 };
25927
25928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
25929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25930 if (SWIG_arg_fail(1)) SWIG_fail;
25931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25932 if (SWIG_arg_fail(2)) SWIG_fail;
25933 {
25934 PyThreadState* __tstate = wxPyBeginAllowThreads();
25935 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
25936
25937 wxPyEndAllowThreads(__tstate);
25938 if (PyErr_Occurred()) SWIG_fail;
25939 }
25940 {
25941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25942 }
25943 return resultobj;
25944 fail:
25945 return NULL;
25946 }
25947
25948
25949 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
25950 PyObject *obj;
25951 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25952 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
25953 Py_INCREF(obj);
25954 return Py_BuildValue((char *)"");
25955 }
25956 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
25957 PyObject *resultobj;
25958 long result;
25959 char *kwnames[] = {
25960 NULL
25961 };
25962
25963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
25964 {
25965 PyThreadState* __tstate = wxPyBeginAllowThreads();
25966 result = (long)wxGetLocalTime();
25967
25968 wxPyEndAllowThreads(__tstate);
25969 if (PyErr_Occurred()) SWIG_fail;
25970 }
25971 {
25972 resultobj = SWIG_From_long((long)(result));
25973 }
25974 return resultobj;
25975 fail:
25976 return NULL;
25977 }
25978
25979
25980 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
25981 PyObject *resultobj;
25982 long result;
25983 char *kwnames[] = {
25984 NULL
25985 };
25986
25987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
25988 {
25989 PyThreadState* __tstate = wxPyBeginAllowThreads();
25990 result = (long)wxGetUTCTime();
25991
25992 wxPyEndAllowThreads(__tstate);
25993 if (PyErr_Occurred()) SWIG_fail;
25994 }
25995 {
25996 resultobj = SWIG_From_long((long)(result));
25997 }
25998 return resultobj;
25999 fail:
26000 return NULL;
26001 }
26002
26003
26004 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26005 PyObject *resultobj;
26006 long result;
26007 char *kwnames[] = {
26008 NULL
26009 };
26010
26011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26012 {
26013 PyThreadState* __tstate = wxPyBeginAllowThreads();
26014 result = (long)wxGetCurrentTime();
26015
26016 wxPyEndAllowThreads(__tstate);
26017 if (PyErr_Occurred()) SWIG_fail;
26018 }
26019 {
26020 resultobj = SWIG_From_long((long)(result));
26021 }
26022 return resultobj;
26023 fail:
26024 return NULL;
26025 }
26026
26027
26028 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26029 PyObject *resultobj;
26030 wxLongLong result;
26031 char *kwnames[] = {
26032 NULL
26033 };
26034
26035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26036 {
26037 PyThreadState* __tstate = wxPyBeginAllowThreads();
26038 result = wxGetLocalTimeMillis();
26039
26040 wxPyEndAllowThreads(__tstate);
26041 if (PyErr_Occurred()) SWIG_fail;
26042 }
26043 {
26044 PyObject *hi, *lo, *shifter, *shifted;
26045 hi = PyLong_FromLong( (&result)->GetHi() );
26046 lo = PyLong_FromLong( (&result)->GetLo() );
26047 shifter = PyLong_FromLong(32);
26048 shifted = PyNumber_Lshift(hi, shifter);
26049 resultobj = PyNumber_Or(shifted, lo);
26050 Py_DECREF(hi);
26051 Py_DECREF(lo);
26052 Py_DECREF(shifter);
26053 Py_DECREF(shifted);
26054 }
26055 return resultobj;
26056 fail:
26057 return NULL;
26058 }
26059
26060
26061 static int _wrap_DefaultDateTime_set(PyObject *) {
26062 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26063 return 1;
26064 }
26065
26066
26067 static PyObject *_wrap_DefaultDateTime_get(void) {
26068 PyObject *pyobj;
26069
26070 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26071 return pyobj;
26072 }
26073
26074
26075 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26076 PyObject *resultobj;
26077 wxDataFormatId arg1 ;
26078 wxDataFormat *result;
26079 PyObject * obj0 = 0 ;
26080 char *kwnames[] = {
26081 (char *) "type", NULL
26082 };
26083
26084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26085 {
26086 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26087 if (SWIG_arg_fail(1)) SWIG_fail;
26088 }
26089 {
26090 PyThreadState* __tstate = wxPyBeginAllowThreads();
26091 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26092
26093 wxPyEndAllowThreads(__tstate);
26094 if (PyErr_Occurred()) SWIG_fail;
26095 }
26096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26097 return resultobj;
26098 fail:
26099 return NULL;
26100 }
26101
26102
26103 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26104 PyObject *resultobj;
26105 wxString *arg1 = 0 ;
26106 wxDataFormat *result;
26107 bool temp1 = false ;
26108 PyObject * obj0 = 0 ;
26109 char *kwnames[] = {
26110 (char *) "format", NULL
26111 };
26112
26113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26114 {
26115 arg1 = wxString_in_helper(obj0);
26116 if (arg1 == NULL) SWIG_fail;
26117 temp1 = true;
26118 }
26119 {
26120 PyThreadState* __tstate = wxPyBeginAllowThreads();
26121 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26122
26123 wxPyEndAllowThreads(__tstate);
26124 if (PyErr_Occurred()) SWIG_fail;
26125 }
26126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26127 {
26128 if (temp1)
26129 delete arg1;
26130 }
26131 return resultobj;
26132 fail:
26133 {
26134 if (temp1)
26135 delete arg1;
26136 }
26137 return NULL;
26138 }
26139
26140
26141 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26142 PyObject *resultobj;
26143 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26144 PyObject * obj0 = 0 ;
26145 char *kwnames[] = {
26146 (char *) "self", NULL
26147 };
26148
26149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26151 if (SWIG_arg_fail(1)) SWIG_fail;
26152 {
26153 PyThreadState* __tstate = wxPyBeginAllowThreads();
26154 delete arg1;
26155
26156 wxPyEndAllowThreads(__tstate);
26157 if (PyErr_Occurred()) SWIG_fail;
26158 }
26159 Py_INCREF(Py_None); resultobj = Py_None;
26160 return resultobj;
26161 fail:
26162 return NULL;
26163 }
26164
26165
26166 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26167 PyObject *resultobj;
26168 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26169 wxDataFormatId arg2 ;
26170 bool result;
26171 PyObject * obj0 = 0 ;
26172 PyObject * obj1 = 0 ;
26173
26174 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26176 if (SWIG_arg_fail(1)) SWIG_fail;
26177 {
26178 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26179 if (SWIG_arg_fail(2)) SWIG_fail;
26180 }
26181 {
26182 PyThreadState* __tstate = wxPyBeginAllowThreads();
26183 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26184
26185 wxPyEndAllowThreads(__tstate);
26186 if (PyErr_Occurred()) SWIG_fail;
26187 }
26188 {
26189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26190 }
26191 return resultobj;
26192 fail:
26193 return NULL;
26194 }
26195
26196
26197 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26198 PyObject *resultobj;
26199 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26200 wxDataFormatId arg2 ;
26201 bool result;
26202 PyObject * obj0 = 0 ;
26203 PyObject * obj1 = 0 ;
26204
26205 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26207 if (SWIG_arg_fail(1)) SWIG_fail;
26208 {
26209 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26210 if (SWIG_arg_fail(2)) SWIG_fail;
26211 }
26212 {
26213 PyThreadState* __tstate = wxPyBeginAllowThreads();
26214 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26215
26216 wxPyEndAllowThreads(__tstate);
26217 if (PyErr_Occurred()) SWIG_fail;
26218 }
26219 {
26220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26221 }
26222 return resultobj;
26223 fail:
26224 return NULL;
26225 }
26226
26227
26228 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26229 PyObject *resultobj;
26230 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26231 wxDataFormat *arg2 = 0 ;
26232 bool result;
26233 PyObject * obj0 = 0 ;
26234 PyObject * obj1 = 0 ;
26235
26236 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26238 if (SWIG_arg_fail(1)) SWIG_fail;
26239 {
26240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26241 if (SWIG_arg_fail(2)) SWIG_fail;
26242 if (arg2 == NULL) {
26243 SWIG_null_ref("wxDataFormat");
26244 }
26245 if (SWIG_arg_fail(2)) SWIG_fail;
26246 }
26247 {
26248 PyThreadState* __tstate = wxPyBeginAllowThreads();
26249 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26250
26251 wxPyEndAllowThreads(__tstate);
26252 if (PyErr_Occurred()) SWIG_fail;
26253 }
26254 {
26255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26256 }
26257 return resultobj;
26258 fail:
26259 return NULL;
26260 }
26261
26262
26263 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26264 int argc;
26265 PyObject *argv[3];
26266 int ii;
26267
26268 argc = PyObject_Length(args);
26269 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26270 argv[ii] = PyTuple_GetItem(args,ii);
26271 }
26272 if (argc == 2) {
26273 int _v;
26274 {
26275 void *ptr;
26276 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26277 _v = 0;
26278 PyErr_Clear();
26279 } else {
26280 _v = 1;
26281 }
26282 }
26283 if (_v) {
26284 {
26285 void *ptr = 0;
26286 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26287 _v = 0;
26288 PyErr_Clear();
26289 } else {
26290 _v = (ptr != 0);
26291 }
26292 }
26293 if (_v) {
26294 return _wrap_DataFormat___eq____SWIG_1(self,args);
26295 }
26296 }
26297 }
26298 if (argc == 2) {
26299 int _v;
26300 {
26301 void *ptr;
26302 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26303 _v = 0;
26304 PyErr_Clear();
26305 } else {
26306 _v = 1;
26307 }
26308 }
26309 if (_v) {
26310 _v = SWIG_Check_int(argv[1]);
26311 if (_v) {
26312 return _wrap_DataFormat___eq____SWIG_0(self,args);
26313 }
26314 }
26315 }
26316
26317 Py_INCREF(Py_NotImplemented);
26318 return Py_NotImplemented;
26319 }
26320
26321
26322 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26323 PyObject *resultobj;
26324 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26325 wxDataFormat *arg2 = 0 ;
26326 bool result;
26327 PyObject * obj0 = 0 ;
26328 PyObject * obj1 = 0 ;
26329
26330 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26332 if (SWIG_arg_fail(1)) SWIG_fail;
26333 {
26334 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26335 if (SWIG_arg_fail(2)) SWIG_fail;
26336 if (arg2 == NULL) {
26337 SWIG_null_ref("wxDataFormat");
26338 }
26339 if (SWIG_arg_fail(2)) SWIG_fail;
26340 }
26341 {
26342 PyThreadState* __tstate = wxPyBeginAllowThreads();
26343 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26344
26345 wxPyEndAllowThreads(__tstate);
26346 if (PyErr_Occurred()) SWIG_fail;
26347 }
26348 {
26349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26350 }
26351 return resultobj;
26352 fail:
26353 return NULL;
26354 }
26355
26356
26357 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26358 int argc;
26359 PyObject *argv[3];
26360 int ii;
26361
26362 argc = PyObject_Length(args);
26363 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26364 argv[ii] = PyTuple_GetItem(args,ii);
26365 }
26366 if (argc == 2) {
26367 int _v;
26368 {
26369 void *ptr;
26370 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26371 _v = 0;
26372 PyErr_Clear();
26373 } else {
26374 _v = 1;
26375 }
26376 }
26377 if (_v) {
26378 {
26379 void *ptr = 0;
26380 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26381 _v = 0;
26382 PyErr_Clear();
26383 } else {
26384 _v = (ptr != 0);
26385 }
26386 }
26387 if (_v) {
26388 return _wrap_DataFormat___ne____SWIG_1(self,args);
26389 }
26390 }
26391 }
26392 if (argc == 2) {
26393 int _v;
26394 {
26395 void *ptr;
26396 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26397 _v = 0;
26398 PyErr_Clear();
26399 } else {
26400 _v = 1;
26401 }
26402 }
26403 if (_v) {
26404 _v = SWIG_Check_int(argv[1]);
26405 if (_v) {
26406 return _wrap_DataFormat___ne____SWIG_0(self,args);
26407 }
26408 }
26409 }
26410
26411 Py_INCREF(Py_NotImplemented);
26412 return Py_NotImplemented;
26413 }
26414
26415
26416 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26417 PyObject *resultobj;
26418 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26419 wxDataFormatId arg2 ;
26420 PyObject * obj0 = 0 ;
26421 PyObject * obj1 = 0 ;
26422 char *kwnames[] = {
26423 (char *) "self",(char *) "format", NULL
26424 };
26425
26426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26428 if (SWIG_arg_fail(1)) SWIG_fail;
26429 {
26430 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26431 if (SWIG_arg_fail(2)) SWIG_fail;
26432 }
26433 {
26434 PyThreadState* __tstate = wxPyBeginAllowThreads();
26435 (arg1)->SetType((wxDataFormatId )arg2);
26436
26437 wxPyEndAllowThreads(__tstate);
26438 if (PyErr_Occurred()) SWIG_fail;
26439 }
26440 Py_INCREF(Py_None); resultobj = Py_None;
26441 return resultobj;
26442 fail:
26443 return NULL;
26444 }
26445
26446
26447 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26448 PyObject *resultobj;
26449 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26450 wxDataFormatId result;
26451 PyObject * obj0 = 0 ;
26452 char *kwnames[] = {
26453 (char *) "self", NULL
26454 };
26455
26456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26458 if (SWIG_arg_fail(1)) SWIG_fail;
26459 {
26460 PyThreadState* __tstate = wxPyBeginAllowThreads();
26461 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26462
26463 wxPyEndAllowThreads(__tstate);
26464 if (PyErr_Occurred()) SWIG_fail;
26465 }
26466 resultobj = SWIG_From_int((result));
26467 return resultobj;
26468 fail:
26469 return NULL;
26470 }
26471
26472
26473 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26474 PyObject *resultobj;
26475 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26476 wxString result;
26477 PyObject * obj0 = 0 ;
26478 char *kwnames[] = {
26479 (char *) "self", NULL
26480 };
26481
26482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26484 if (SWIG_arg_fail(1)) SWIG_fail;
26485 {
26486 PyThreadState* __tstate = wxPyBeginAllowThreads();
26487 result = ((wxDataFormat const *)arg1)->GetId();
26488
26489 wxPyEndAllowThreads(__tstate);
26490 if (PyErr_Occurred()) SWIG_fail;
26491 }
26492 {
26493 #if wxUSE_UNICODE
26494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26495 #else
26496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26497 #endif
26498 }
26499 return resultobj;
26500 fail:
26501 return NULL;
26502 }
26503
26504
26505 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26506 PyObject *resultobj;
26507 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26508 wxString *arg2 = 0 ;
26509 bool temp2 = false ;
26510 PyObject * obj0 = 0 ;
26511 PyObject * obj1 = 0 ;
26512 char *kwnames[] = {
26513 (char *) "self",(char *) "format", NULL
26514 };
26515
26516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26518 if (SWIG_arg_fail(1)) SWIG_fail;
26519 {
26520 arg2 = wxString_in_helper(obj1);
26521 if (arg2 == NULL) SWIG_fail;
26522 temp2 = true;
26523 }
26524 {
26525 PyThreadState* __tstate = wxPyBeginAllowThreads();
26526 (arg1)->SetId((wxString const &)*arg2);
26527
26528 wxPyEndAllowThreads(__tstate);
26529 if (PyErr_Occurred()) SWIG_fail;
26530 }
26531 Py_INCREF(Py_None); resultobj = Py_None;
26532 {
26533 if (temp2)
26534 delete arg2;
26535 }
26536 return resultobj;
26537 fail:
26538 {
26539 if (temp2)
26540 delete arg2;
26541 }
26542 return NULL;
26543 }
26544
26545
26546 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26547 PyObject *obj;
26548 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26549 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26550 Py_INCREF(obj);
26551 return Py_BuildValue((char *)"");
26552 }
26553 static int _wrap_FormatInvalid_set(PyObject *) {
26554 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26555 return 1;
26556 }
26557
26558
26559 static PyObject *_wrap_FormatInvalid_get(void) {
26560 PyObject *pyobj;
26561
26562 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26563 return pyobj;
26564 }
26565
26566
26567 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26568 PyObject *resultobj;
26569 wxDataObject *arg1 = (wxDataObject *) 0 ;
26570 PyObject * obj0 = 0 ;
26571 char *kwnames[] = {
26572 (char *) "self", NULL
26573 };
26574
26575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26577 if (SWIG_arg_fail(1)) SWIG_fail;
26578 {
26579 PyThreadState* __tstate = wxPyBeginAllowThreads();
26580 delete arg1;
26581
26582 wxPyEndAllowThreads(__tstate);
26583 if (PyErr_Occurred()) SWIG_fail;
26584 }
26585 Py_INCREF(Py_None); resultobj = Py_None;
26586 return resultobj;
26587 fail:
26588 return NULL;
26589 }
26590
26591
26592 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26593 PyObject *resultobj;
26594 wxDataObject *arg1 = (wxDataObject *) 0 ;
26595 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26596 SwigValueWrapper<wxDataFormat > result;
26597 PyObject * obj0 = 0 ;
26598 PyObject * obj1 = 0 ;
26599 char *kwnames[] = {
26600 (char *) "self",(char *) "dir", NULL
26601 };
26602
26603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26605 if (SWIG_arg_fail(1)) SWIG_fail;
26606 if (obj1) {
26607 {
26608 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26609 if (SWIG_arg_fail(2)) SWIG_fail;
26610 }
26611 }
26612 {
26613 PyThreadState* __tstate = wxPyBeginAllowThreads();
26614 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26615
26616 wxPyEndAllowThreads(__tstate);
26617 if (PyErr_Occurred()) SWIG_fail;
26618 }
26619 {
26620 wxDataFormat * resultptr;
26621 resultptr = new wxDataFormat((wxDataFormat &)(result));
26622 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26623 }
26624 return resultobj;
26625 fail:
26626 return NULL;
26627 }
26628
26629
26630 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26631 PyObject *resultobj;
26632 wxDataObject *arg1 = (wxDataObject *) 0 ;
26633 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26634 size_t result;
26635 PyObject * obj0 = 0 ;
26636 PyObject * obj1 = 0 ;
26637 char *kwnames[] = {
26638 (char *) "self",(char *) "dir", NULL
26639 };
26640
26641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26643 if (SWIG_arg_fail(1)) SWIG_fail;
26644 if (obj1) {
26645 {
26646 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26647 if (SWIG_arg_fail(2)) SWIG_fail;
26648 }
26649 }
26650 {
26651 PyThreadState* __tstate = wxPyBeginAllowThreads();
26652 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26653
26654 wxPyEndAllowThreads(__tstate);
26655 if (PyErr_Occurred()) SWIG_fail;
26656 }
26657 {
26658 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26659 }
26660 return resultobj;
26661 fail:
26662 return NULL;
26663 }
26664
26665
26666 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
26667 PyObject *resultobj;
26668 wxDataObject *arg1 = (wxDataObject *) 0 ;
26669 wxDataFormat *arg2 = 0 ;
26670 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
26671 bool result;
26672 PyObject * obj0 = 0 ;
26673 PyObject * obj1 = 0 ;
26674 PyObject * obj2 = 0 ;
26675 char *kwnames[] = {
26676 (char *) "self",(char *) "format",(char *) "dir", NULL
26677 };
26678
26679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
26680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26681 if (SWIG_arg_fail(1)) SWIG_fail;
26682 {
26683 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26684 if (SWIG_arg_fail(2)) SWIG_fail;
26685 if (arg2 == NULL) {
26686 SWIG_null_ref("wxDataFormat");
26687 }
26688 if (SWIG_arg_fail(2)) SWIG_fail;
26689 }
26690 if (obj2) {
26691 {
26692 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
26693 if (SWIG_arg_fail(3)) SWIG_fail;
26694 }
26695 }
26696 {
26697 PyThreadState* __tstate = wxPyBeginAllowThreads();
26698 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
26699
26700 wxPyEndAllowThreads(__tstate);
26701 if (PyErr_Occurred()) SWIG_fail;
26702 }
26703 {
26704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26705 }
26706 return resultobj;
26707 fail:
26708 return NULL;
26709 }
26710
26711
26712 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26713 PyObject *resultobj;
26714 wxDataObject *arg1 = (wxDataObject *) 0 ;
26715 wxDataFormat *arg2 = 0 ;
26716 size_t result;
26717 PyObject * obj0 = 0 ;
26718 PyObject * obj1 = 0 ;
26719 char *kwnames[] = {
26720 (char *) "self",(char *) "format", NULL
26721 };
26722
26723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
26724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26725 if (SWIG_arg_fail(1)) SWIG_fail;
26726 {
26727 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26728 if (SWIG_arg_fail(2)) SWIG_fail;
26729 if (arg2 == NULL) {
26730 SWIG_null_ref("wxDataFormat");
26731 }
26732 if (SWIG_arg_fail(2)) SWIG_fail;
26733 }
26734 {
26735 PyThreadState* __tstate = wxPyBeginAllowThreads();
26736 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
26737
26738 wxPyEndAllowThreads(__tstate);
26739 if (PyErr_Occurred()) SWIG_fail;
26740 }
26741 {
26742 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26743 }
26744 return resultobj;
26745 fail:
26746 return NULL;
26747 }
26748
26749
26750 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
26751 PyObject *resultobj;
26752 wxDataObject *arg1 = (wxDataObject *) 0 ;
26753 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26754 PyObject *result;
26755 PyObject * obj0 = 0 ;
26756 PyObject * obj1 = 0 ;
26757 char *kwnames[] = {
26758 (char *) "self",(char *) "dir", NULL
26759 };
26760
26761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
26762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26763 if (SWIG_arg_fail(1)) SWIG_fail;
26764 if (obj1) {
26765 {
26766 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26767 if (SWIG_arg_fail(2)) SWIG_fail;
26768 }
26769 }
26770 {
26771 PyThreadState* __tstate = wxPyBeginAllowThreads();
26772 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
26773
26774 wxPyEndAllowThreads(__tstate);
26775 if (PyErr_Occurred()) SWIG_fail;
26776 }
26777 resultobj = result;
26778 return resultobj;
26779 fail:
26780 return NULL;
26781 }
26782
26783
26784 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26785 PyObject *resultobj;
26786 wxDataObject *arg1 = (wxDataObject *) 0 ;
26787 wxDataFormat *arg2 = 0 ;
26788 PyObject *result;
26789 PyObject * obj0 = 0 ;
26790 PyObject * obj1 = 0 ;
26791 char *kwnames[] = {
26792 (char *) "self",(char *) "format", NULL
26793 };
26794
26795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
26796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26797 if (SWIG_arg_fail(1)) SWIG_fail;
26798 {
26799 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26800 if (SWIG_arg_fail(2)) SWIG_fail;
26801 if (arg2 == NULL) {
26802 SWIG_null_ref("wxDataFormat");
26803 }
26804 if (SWIG_arg_fail(2)) SWIG_fail;
26805 }
26806 {
26807 PyThreadState* __tstate = wxPyBeginAllowThreads();
26808 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
26809
26810 wxPyEndAllowThreads(__tstate);
26811 if (PyErr_Occurred()) SWIG_fail;
26812 }
26813 resultobj = result;
26814 return resultobj;
26815 fail:
26816 return NULL;
26817 }
26818
26819
26820 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
26821 PyObject *resultobj;
26822 wxDataObject *arg1 = (wxDataObject *) 0 ;
26823 wxDataFormat *arg2 = 0 ;
26824 PyObject *arg3 = (PyObject *) 0 ;
26825 bool result;
26826 PyObject * obj0 = 0 ;
26827 PyObject * obj1 = 0 ;
26828 PyObject * obj2 = 0 ;
26829 char *kwnames[] = {
26830 (char *) "self",(char *) "format",(char *) "data", NULL
26831 };
26832
26833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
26834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26835 if (SWIG_arg_fail(1)) SWIG_fail;
26836 {
26837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26838 if (SWIG_arg_fail(2)) SWIG_fail;
26839 if (arg2 == NULL) {
26840 SWIG_null_ref("wxDataFormat");
26841 }
26842 if (SWIG_arg_fail(2)) SWIG_fail;
26843 }
26844 arg3 = obj2;
26845 {
26846 PyThreadState* __tstate = wxPyBeginAllowThreads();
26847 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
26848
26849 wxPyEndAllowThreads(__tstate);
26850 if (PyErr_Occurred()) SWIG_fail;
26851 }
26852 {
26853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26854 }
26855 return resultobj;
26856 fail:
26857 return NULL;
26858 }
26859
26860
26861 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
26862 PyObject *obj;
26863 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26864 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
26865 Py_INCREF(obj);
26866 return Py_BuildValue((char *)"");
26867 }
26868 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
26869 PyObject *resultobj;
26870 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
26871 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
26872 wxDataObjectSimple *result;
26873 PyObject * obj0 = 0 ;
26874 char *kwnames[] = {
26875 (char *) "format", NULL
26876 };
26877
26878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
26879 if (obj0) {
26880 {
26881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26882 if (SWIG_arg_fail(1)) SWIG_fail;
26883 if (arg1 == NULL) {
26884 SWIG_null_ref("wxDataFormat");
26885 }
26886 if (SWIG_arg_fail(1)) SWIG_fail;
26887 }
26888 }
26889 {
26890 PyThreadState* __tstate = wxPyBeginAllowThreads();
26891 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
26892
26893 wxPyEndAllowThreads(__tstate);
26894 if (PyErr_Occurred()) SWIG_fail;
26895 }
26896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
26897 return resultobj;
26898 fail:
26899 return NULL;
26900 }
26901
26902
26903 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26904 PyObject *resultobj;
26905 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26906 wxDataFormat *result;
26907 PyObject * obj0 = 0 ;
26908 char *kwnames[] = {
26909 (char *) "self", NULL
26910 };
26911
26912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
26913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26914 if (SWIG_arg_fail(1)) SWIG_fail;
26915 {
26916 PyThreadState* __tstate = wxPyBeginAllowThreads();
26917 {
26918 wxDataFormat const &_result_ref = (arg1)->GetFormat();
26919 result = (wxDataFormat *) &_result_ref;
26920 }
26921
26922 wxPyEndAllowThreads(__tstate);
26923 if (PyErr_Occurred()) SWIG_fail;
26924 }
26925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
26926 return resultobj;
26927 fail:
26928 return NULL;
26929 }
26930
26931
26932 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26933 PyObject *resultobj;
26934 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26935 wxDataFormat *arg2 = 0 ;
26936 PyObject * obj0 = 0 ;
26937 PyObject * obj1 = 0 ;
26938 char *kwnames[] = {
26939 (char *) "self",(char *) "format", NULL
26940 };
26941
26942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
26943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26944 if (SWIG_arg_fail(1)) SWIG_fail;
26945 {
26946 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26947 if (SWIG_arg_fail(2)) SWIG_fail;
26948 if (arg2 == NULL) {
26949 SWIG_null_ref("wxDataFormat");
26950 }
26951 if (SWIG_arg_fail(2)) SWIG_fail;
26952 }
26953 {
26954 PyThreadState* __tstate = wxPyBeginAllowThreads();
26955 (arg1)->SetFormat((wxDataFormat const &)*arg2);
26956
26957 wxPyEndAllowThreads(__tstate);
26958 if (PyErr_Occurred()) SWIG_fail;
26959 }
26960 Py_INCREF(Py_None); resultobj = Py_None;
26961 return resultobj;
26962 fail:
26963 return NULL;
26964 }
26965
26966
26967 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
26968 PyObject *resultobj;
26969 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26970 size_t result;
26971 PyObject * obj0 = 0 ;
26972 char *kwnames[] = {
26973 (char *) "self", NULL
26974 };
26975
26976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
26977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
26978 if (SWIG_arg_fail(1)) SWIG_fail;
26979 {
26980 PyThreadState* __tstate = wxPyBeginAllowThreads();
26981 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
26982
26983 wxPyEndAllowThreads(__tstate);
26984 if (PyErr_Occurred()) SWIG_fail;
26985 }
26986 {
26987 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26988 }
26989 return resultobj;
26990 fail:
26991 return NULL;
26992 }
26993
26994
26995 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
26996 PyObject *resultobj;
26997 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
26998 PyObject *result;
26999 PyObject * obj0 = 0 ;
27000 char *kwnames[] = {
27001 (char *) "self", NULL
27002 };
27003
27004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27006 if (SWIG_arg_fail(1)) SWIG_fail;
27007 {
27008 PyThreadState* __tstate = wxPyBeginAllowThreads();
27009 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27010
27011 wxPyEndAllowThreads(__tstate);
27012 if (PyErr_Occurred()) SWIG_fail;
27013 }
27014 resultobj = result;
27015 return resultobj;
27016 fail:
27017 return NULL;
27018 }
27019
27020
27021 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27022 PyObject *resultobj;
27023 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27024 PyObject *arg2 = (PyObject *) 0 ;
27025 bool result;
27026 PyObject * obj0 = 0 ;
27027 PyObject * obj1 = 0 ;
27028 char *kwnames[] = {
27029 (char *) "self",(char *) "data", NULL
27030 };
27031
27032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27034 if (SWIG_arg_fail(1)) SWIG_fail;
27035 arg2 = obj1;
27036 {
27037 PyThreadState* __tstate = wxPyBeginAllowThreads();
27038 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27039
27040 wxPyEndAllowThreads(__tstate);
27041 if (PyErr_Occurred()) SWIG_fail;
27042 }
27043 {
27044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27045 }
27046 return resultobj;
27047 fail:
27048 return NULL;
27049 }
27050
27051
27052 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27053 PyObject *obj;
27054 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27055 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27056 Py_INCREF(obj);
27057 return Py_BuildValue((char *)"");
27058 }
27059 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27060 PyObject *resultobj;
27061 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27062 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27063 wxPyDataObjectSimple *result;
27064 PyObject * obj0 = 0 ;
27065 char *kwnames[] = {
27066 (char *) "format", NULL
27067 };
27068
27069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27070 if (obj0) {
27071 {
27072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27073 if (SWIG_arg_fail(1)) SWIG_fail;
27074 if (arg1 == NULL) {
27075 SWIG_null_ref("wxDataFormat");
27076 }
27077 if (SWIG_arg_fail(1)) SWIG_fail;
27078 }
27079 }
27080 {
27081 PyThreadState* __tstate = wxPyBeginAllowThreads();
27082 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27083
27084 wxPyEndAllowThreads(__tstate);
27085 if (PyErr_Occurred()) SWIG_fail;
27086 }
27087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27088 return resultobj;
27089 fail:
27090 return NULL;
27091 }
27092
27093
27094 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27095 PyObject *resultobj;
27096 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27097 PyObject *arg2 = (PyObject *) 0 ;
27098 PyObject *arg3 = (PyObject *) 0 ;
27099 PyObject * obj0 = 0 ;
27100 PyObject * obj1 = 0 ;
27101 PyObject * obj2 = 0 ;
27102 char *kwnames[] = {
27103 (char *) "self",(char *) "self",(char *) "_class", NULL
27104 };
27105
27106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27108 if (SWIG_arg_fail(1)) SWIG_fail;
27109 arg2 = obj1;
27110 arg3 = obj2;
27111 {
27112 PyThreadState* __tstate = wxPyBeginAllowThreads();
27113 (arg1)->_setCallbackInfo(arg2,arg3);
27114
27115 wxPyEndAllowThreads(__tstate);
27116 if (PyErr_Occurred()) SWIG_fail;
27117 }
27118 Py_INCREF(Py_None); resultobj = Py_None;
27119 return resultobj;
27120 fail:
27121 return NULL;
27122 }
27123
27124
27125 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27126 PyObject *obj;
27127 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27128 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27129 Py_INCREF(obj);
27130 return Py_BuildValue((char *)"");
27131 }
27132 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27133 PyObject *resultobj;
27134 wxDataObjectComposite *result;
27135 char *kwnames[] = {
27136 NULL
27137 };
27138
27139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27140 {
27141 PyThreadState* __tstate = wxPyBeginAllowThreads();
27142 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27143
27144 wxPyEndAllowThreads(__tstate);
27145 if (PyErr_Occurred()) SWIG_fail;
27146 }
27147 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27148 return resultobj;
27149 fail:
27150 return NULL;
27151 }
27152
27153
27154 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27155 PyObject *resultobj;
27156 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27157 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27158 bool arg3 = (bool) false ;
27159 PyObject * obj0 = 0 ;
27160 PyObject * obj1 = 0 ;
27161 PyObject * obj2 = 0 ;
27162 char *kwnames[] = {
27163 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27164 };
27165
27166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27168 if (SWIG_arg_fail(1)) SWIG_fail;
27169 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27170 if (SWIG_arg_fail(2)) SWIG_fail;
27171 if (obj2) {
27172 {
27173 arg3 = (bool)(SWIG_As_bool(obj2));
27174 if (SWIG_arg_fail(3)) SWIG_fail;
27175 }
27176 }
27177 {
27178 PyThreadState* __tstate = wxPyBeginAllowThreads();
27179 (arg1)->Add(arg2,arg3);
27180
27181 wxPyEndAllowThreads(__tstate);
27182 if (PyErr_Occurred()) SWIG_fail;
27183 }
27184 Py_INCREF(Py_None); resultobj = Py_None;
27185 return resultobj;
27186 fail:
27187 return NULL;
27188 }
27189
27190
27191 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27192 PyObject *obj;
27193 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27194 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27195 Py_INCREF(obj);
27196 return Py_BuildValue((char *)"");
27197 }
27198 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27199 PyObject *resultobj;
27200 wxString const &arg1_defvalue = wxPyEmptyString ;
27201 wxString *arg1 = (wxString *) &arg1_defvalue ;
27202 wxTextDataObject *result;
27203 bool temp1 = false ;
27204 PyObject * obj0 = 0 ;
27205 char *kwnames[] = {
27206 (char *) "text", NULL
27207 };
27208
27209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27210 if (obj0) {
27211 {
27212 arg1 = wxString_in_helper(obj0);
27213 if (arg1 == NULL) SWIG_fail;
27214 temp1 = true;
27215 }
27216 }
27217 {
27218 PyThreadState* __tstate = wxPyBeginAllowThreads();
27219 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27220
27221 wxPyEndAllowThreads(__tstate);
27222 if (PyErr_Occurred()) SWIG_fail;
27223 }
27224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27225 {
27226 if (temp1)
27227 delete arg1;
27228 }
27229 return resultobj;
27230 fail:
27231 {
27232 if (temp1)
27233 delete arg1;
27234 }
27235 return NULL;
27236 }
27237
27238
27239 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27240 PyObject *resultobj;
27241 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27242 size_t result;
27243 PyObject * obj0 = 0 ;
27244 char *kwnames[] = {
27245 (char *) "self", NULL
27246 };
27247
27248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27250 if (SWIG_arg_fail(1)) SWIG_fail;
27251 {
27252 PyThreadState* __tstate = wxPyBeginAllowThreads();
27253 result = (size_t)(arg1)->GetTextLength();
27254
27255 wxPyEndAllowThreads(__tstate);
27256 if (PyErr_Occurred()) SWIG_fail;
27257 }
27258 {
27259 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27260 }
27261 return resultobj;
27262 fail:
27263 return NULL;
27264 }
27265
27266
27267 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27268 PyObject *resultobj;
27269 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27270 wxString result;
27271 PyObject * obj0 = 0 ;
27272 char *kwnames[] = {
27273 (char *) "self", NULL
27274 };
27275
27276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27278 if (SWIG_arg_fail(1)) SWIG_fail;
27279 {
27280 PyThreadState* __tstate = wxPyBeginAllowThreads();
27281 result = (arg1)->GetText();
27282
27283 wxPyEndAllowThreads(__tstate);
27284 if (PyErr_Occurred()) SWIG_fail;
27285 }
27286 {
27287 #if wxUSE_UNICODE
27288 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27289 #else
27290 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27291 #endif
27292 }
27293 return resultobj;
27294 fail:
27295 return NULL;
27296 }
27297
27298
27299 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27300 PyObject *resultobj;
27301 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27302 wxString *arg2 = 0 ;
27303 bool temp2 = false ;
27304 PyObject * obj0 = 0 ;
27305 PyObject * obj1 = 0 ;
27306 char *kwnames[] = {
27307 (char *) "self",(char *) "text", NULL
27308 };
27309
27310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27312 if (SWIG_arg_fail(1)) SWIG_fail;
27313 {
27314 arg2 = wxString_in_helper(obj1);
27315 if (arg2 == NULL) SWIG_fail;
27316 temp2 = true;
27317 }
27318 {
27319 PyThreadState* __tstate = wxPyBeginAllowThreads();
27320 (arg1)->SetText((wxString const &)*arg2);
27321
27322 wxPyEndAllowThreads(__tstate);
27323 if (PyErr_Occurred()) SWIG_fail;
27324 }
27325 Py_INCREF(Py_None); resultobj = Py_None;
27326 {
27327 if (temp2)
27328 delete arg2;
27329 }
27330 return resultobj;
27331 fail:
27332 {
27333 if (temp2)
27334 delete arg2;
27335 }
27336 return NULL;
27337 }
27338
27339
27340 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27341 PyObject *obj;
27342 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27343 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27344 Py_INCREF(obj);
27345 return Py_BuildValue((char *)"");
27346 }
27347 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27348 PyObject *resultobj;
27349 wxString const &arg1_defvalue = wxPyEmptyString ;
27350 wxString *arg1 = (wxString *) &arg1_defvalue ;
27351 wxPyTextDataObject *result;
27352 bool temp1 = false ;
27353 PyObject * obj0 = 0 ;
27354 char *kwnames[] = {
27355 (char *) "text", NULL
27356 };
27357
27358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27359 if (obj0) {
27360 {
27361 arg1 = wxString_in_helper(obj0);
27362 if (arg1 == NULL) SWIG_fail;
27363 temp1 = true;
27364 }
27365 }
27366 {
27367 PyThreadState* __tstate = wxPyBeginAllowThreads();
27368 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27369
27370 wxPyEndAllowThreads(__tstate);
27371 if (PyErr_Occurred()) SWIG_fail;
27372 }
27373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27374 {
27375 if (temp1)
27376 delete arg1;
27377 }
27378 return resultobj;
27379 fail:
27380 {
27381 if (temp1)
27382 delete arg1;
27383 }
27384 return NULL;
27385 }
27386
27387
27388 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27389 PyObject *resultobj;
27390 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27391 PyObject *arg2 = (PyObject *) 0 ;
27392 PyObject *arg3 = (PyObject *) 0 ;
27393 PyObject * obj0 = 0 ;
27394 PyObject * obj1 = 0 ;
27395 PyObject * obj2 = 0 ;
27396 char *kwnames[] = {
27397 (char *) "self",(char *) "self",(char *) "_class", NULL
27398 };
27399
27400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27402 if (SWIG_arg_fail(1)) SWIG_fail;
27403 arg2 = obj1;
27404 arg3 = obj2;
27405 {
27406 PyThreadState* __tstate = wxPyBeginAllowThreads();
27407 (arg1)->_setCallbackInfo(arg2,arg3);
27408
27409 wxPyEndAllowThreads(__tstate);
27410 if (PyErr_Occurred()) SWIG_fail;
27411 }
27412 Py_INCREF(Py_None); resultobj = Py_None;
27413 return resultobj;
27414 fail:
27415 return NULL;
27416 }
27417
27418
27419 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27420 PyObject *obj;
27421 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27422 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27423 Py_INCREF(obj);
27424 return Py_BuildValue((char *)"");
27425 }
27426 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27427 PyObject *resultobj;
27428 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27429 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27430 wxBitmapDataObject *result;
27431 PyObject * obj0 = 0 ;
27432 char *kwnames[] = {
27433 (char *) "bitmap", NULL
27434 };
27435
27436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27437 if (obj0) {
27438 {
27439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27440 if (SWIG_arg_fail(1)) SWIG_fail;
27441 if (arg1 == NULL) {
27442 SWIG_null_ref("wxBitmap");
27443 }
27444 if (SWIG_arg_fail(1)) SWIG_fail;
27445 }
27446 }
27447 {
27448 PyThreadState* __tstate = wxPyBeginAllowThreads();
27449 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27450
27451 wxPyEndAllowThreads(__tstate);
27452 if (PyErr_Occurred()) SWIG_fail;
27453 }
27454 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27455 return resultobj;
27456 fail:
27457 return NULL;
27458 }
27459
27460
27461 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27462 PyObject *resultobj;
27463 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27464 wxBitmap result;
27465 PyObject * obj0 = 0 ;
27466 char *kwnames[] = {
27467 (char *) "self", NULL
27468 };
27469
27470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27472 if (SWIG_arg_fail(1)) SWIG_fail;
27473 {
27474 PyThreadState* __tstate = wxPyBeginAllowThreads();
27475 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27476
27477 wxPyEndAllowThreads(__tstate);
27478 if (PyErr_Occurred()) SWIG_fail;
27479 }
27480 {
27481 wxBitmap * resultptr;
27482 resultptr = new wxBitmap((wxBitmap &)(result));
27483 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27484 }
27485 return resultobj;
27486 fail:
27487 return NULL;
27488 }
27489
27490
27491 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27492 PyObject *resultobj;
27493 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27494 wxBitmap *arg2 = 0 ;
27495 PyObject * obj0 = 0 ;
27496 PyObject * obj1 = 0 ;
27497 char *kwnames[] = {
27498 (char *) "self",(char *) "bitmap", NULL
27499 };
27500
27501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27503 if (SWIG_arg_fail(1)) SWIG_fail;
27504 {
27505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27506 if (SWIG_arg_fail(2)) SWIG_fail;
27507 if (arg2 == NULL) {
27508 SWIG_null_ref("wxBitmap");
27509 }
27510 if (SWIG_arg_fail(2)) SWIG_fail;
27511 }
27512 {
27513 PyThreadState* __tstate = wxPyBeginAllowThreads();
27514 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27515
27516 wxPyEndAllowThreads(__tstate);
27517 if (PyErr_Occurred()) SWIG_fail;
27518 }
27519 Py_INCREF(Py_None); resultobj = Py_None;
27520 return resultobj;
27521 fail:
27522 return NULL;
27523 }
27524
27525
27526 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27527 PyObject *obj;
27528 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27529 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27530 Py_INCREF(obj);
27531 return Py_BuildValue((char *)"");
27532 }
27533 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27534 PyObject *resultobj;
27535 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27536 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27537 wxPyBitmapDataObject *result;
27538 PyObject * obj0 = 0 ;
27539 char *kwnames[] = {
27540 (char *) "bitmap", NULL
27541 };
27542
27543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27544 if (obj0) {
27545 {
27546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27547 if (SWIG_arg_fail(1)) SWIG_fail;
27548 if (arg1 == NULL) {
27549 SWIG_null_ref("wxBitmap");
27550 }
27551 if (SWIG_arg_fail(1)) SWIG_fail;
27552 }
27553 }
27554 {
27555 PyThreadState* __tstate = wxPyBeginAllowThreads();
27556 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27557
27558 wxPyEndAllowThreads(__tstate);
27559 if (PyErr_Occurred()) SWIG_fail;
27560 }
27561 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27562 return resultobj;
27563 fail:
27564 return NULL;
27565 }
27566
27567
27568 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27569 PyObject *resultobj;
27570 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27571 PyObject *arg2 = (PyObject *) 0 ;
27572 PyObject *arg3 = (PyObject *) 0 ;
27573 PyObject * obj0 = 0 ;
27574 PyObject * obj1 = 0 ;
27575 PyObject * obj2 = 0 ;
27576 char *kwnames[] = {
27577 (char *) "self",(char *) "self",(char *) "_class", NULL
27578 };
27579
27580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27582 if (SWIG_arg_fail(1)) SWIG_fail;
27583 arg2 = obj1;
27584 arg3 = obj2;
27585 {
27586 PyThreadState* __tstate = wxPyBeginAllowThreads();
27587 (arg1)->_setCallbackInfo(arg2,arg3);
27588
27589 wxPyEndAllowThreads(__tstate);
27590 if (PyErr_Occurred()) SWIG_fail;
27591 }
27592 Py_INCREF(Py_None); resultobj = Py_None;
27593 return resultobj;
27594 fail:
27595 return NULL;
27596 }
27597
27598
27599 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27600 PyObject *obj;
27601 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27602 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27603 Py_INCREF(obj);
27604 return Py_BuildValue((char *)"");
27605 }
27606 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27607 PyObject *resultobj;
27608 wxFileDataObject *result;
27609 char *kwnames[] = {
27610 NULL
27611 };
27612
27613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27614 {
27615 PyThreadState* __tstate = wxPyBeginAllowThreads();
27616 result = (wxFileDataObject *)new wxFileDataObject();
27617
27618 wxPyEndAllowThreads(__tstate);
27619 if (PyErr_Occurred()) SWIG_fail;
27620 }
27621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27622 return resultobj;
27623 fail:
27624 return NULL;
27625 }
27626
27627
27628 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27629 PyObject *resultobj;
27630 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27631 wxArrayString *result;
27632 PyObject * obj0 = 0 ;
27633 char *kwnames[] = {
27634 (char *) "self", NULL
27635 };
27636
27637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27639 if (SWIG_arg_fail(1)) SWIG_fail;
27640 {
27641 PyThreadState* __tstate = wxPyBeginAllowThreads();
27642 {
27643 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27644 result = (wxArrayString *) &_result_ref;
27645 }
27646
27647 wxPyEndAllowThreads(__tstate);
27648 if (PyErr_Occurred()) SWIG_fail;
27649 }
27650 {
27651 resultobj = wxArrayString2PyList_helper(*result);
27652 }
27653 return resultobj;
27654 fail:
27655 return NULL;
27656 }
27657
27658
27659 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27660 PyObject *resultobj;
27661 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27662 wxString *arg2 = 0 ;
27663 bool temp2 = false ;
27664 PyObject * obj0 = 0 ;
27665 PyObject * obj1 = 0 ;
27666 char *kwnames[] = {
27667 (char *) "self",(char *) "filename", NULL
27668 };
27669
27670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
27671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27672 if (SWIG_arg_fail(1)) SWIG_fail;
27673 {
27674 arg2 = wxString_in_helper(obj1);
27675 if (arg2 == NULL) SWIG_fail;
27676 temp2 = true;
27677 }
27678 {
27679 PyThreadState* __tstate = wxPyBeginAllowThreads();
27680 (arg1)->AddFile((wxString const &)*arg2);
27681
27682 wxPyEndAllowThreads(__tstate);
27683 if (PyErr_Occurred()) SWIG_fail;
27684 }
27685 Py_INCREF(Py_None); resultobj = Py_None;
27686 {
27687 if (temp2)
27688 delete arg2;
27689 }
27690 return resultobj;
27691 fail:
27692 {
27693 if (temp2)
27694 delete arg2;
27695 }
27696 return NULL;
27697 }
27698
27699
27700 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
27701 PyObject *obj;
27702 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27703 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
27704 Py_INCREF(obj);
27705 return Py_BuildValue((char *)"");
27706 }
27707 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
27708 PyObject *resultobj;
27709 wxDataFormat *arg1 = 0 ;
27710 wxCustomDataObject *result;
27711 PyObject * obj0 = 0 ;
27712
27713 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
27714 {
27715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27716 if (SWIG_arg_fail(1)) SWIG_fail;
27717 if (arg1 == NULL) {
27718 SWIG_null_ref("wxDataFormat");
27719 }
27720 if (SWIG_arg_fail(1)) SWIG_fail;
27721 }
27722 {
27723 PyThreadState* __tstate = wxPyBeginAllowThreads();
27724 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
27725
27726 wxPyEndAllowThreads(__tstate);
27727 if (PyErr_Occurred()) SWIG_fail;
27728 }
27729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27730 return resultobj;
27731 fail:
27732 return NULL;
27733 }
27734
27735
27736 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
27737 PyObject *resultobj;
27738 wxString *arg1 = 0 ;
27739 wxCustomDataObject *result;
27740 bool temp1 = false ;
27741 PyObject * obj0 = 0 ;
27742
27743 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
27744 {
27745 arg1 = wxString_in_helper(obj0);
27746 if (arg1 == NULL) SWIG_fail;
27747 temp1 = true;
27748 }
27749 {
27750 PyThreadState* __tstate = wxPyBeginAllowThreads();
27751 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
27752
27753 wxPyEndAllowThreads(__tstate);
27754 if (PyErr_Occurred()) SWIG_fail;
27755 }
27756 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27757 {
27758 if (temp1)
27759 delete arg1;
27760 }
27761 return resultobj;
27762 fail:
27763 {
27764 if (temp1)
27765 delete arg1;
27766 }
27767 return NULL;
27768 }
27769
27770
27771 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
27772 PyObject *resultobj;
27773 wxCustomDataObject *result;
27774
27775 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
27776 {
27777 PyThreadState* __tstate = wxPyBeginAllowThreads();
27778 result = (wxCustomDataObject *)new wxCustomDataObject();
27779
27780 wxPyEndAllowThreads(__tstate);
27781 if (PyErr_Occurred()) SWIG_fail;
27782 }
27783 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
27784 return resultobj;
27785 fail:
27786 return NULL;
27787 }
27788
27789
27790 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
27791 int argc;
27792 PyObject *argv[2];
27793 int ii;
27794
27795 argc = PyObject_Length(args);
27796 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
27797 argv[ii] = PyTuple_GetItem(args,ii);
27798 }
27799 if (argc == 0) {
27800 return _wrap_new_CustomDataObject__SWIG_2(self,args);
27801 }
27802 if (argc == 1) {
27803 int _v;
27804 {
27805 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
27806 }
27807 if (_v) {
27808 return _wrap_new_CustomDataObject__SWIG_1(self,args);
27809 }
27810 }
27811 if (argc == 1) {
27812 int _v;
27813 {
27814 void *ptr = 0;
27815 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
27816 _v = 0;
27817 PyErr_Clear();
27818 } else {
27819 _v = (ptr != 0);
27820 }
27821 }
27822 if (_v) {
27823 return _wrap_new_CustomDataObject__SWIG_0(self,args);
27824 }
27825 }
27826
27827 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
27828 return NULL;
27829 }
27830
27831
27832 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27833 PyObject *resultobj;
27834 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27835 PyObject *arg2 = (PyObject *) 0 ;
27836 bool result;
27837 PyObject * obj0 = 0 ;
27838 PyObject * obj1 = 0 ;
27839 char *kwnames[] = {
27840 (char *) "self",(char *) "data", NULL
27841 };
27842
27843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
27844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27845 if (SWIG_arg_fail(1)) SWIG_fail;
27846 arg2 = obj1;
27847 {
27848 PyThreadState* __tstate = wxPyBeginAllowThreads();
27849 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
27850
27851 wxPyEndAllowThreads(__tstate);
27852 if (PyErr_Occurred()) SWIG_fail;
27853 }
27854 {
27855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27856 }
27857 return resultobj;
27858 fail:
27859 return NULL;
27860 }
27861
27862
27863 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
27864 PyObject *resultobj;
27865 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27866 size_t result;
27867 PyObject * obj0 = 0 ;
27868 char *kwnames[] = {
27869 (char *) "self", NULL
27870 };
27871
27872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
27873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27874 if (SWIG_arg_fail(1)) SWIG_fail;
27875 {
27876 PyThreadState* __tstate = wxPyBeginAllowThreads();
27877 result = (size_t)(arg1)->GetSize();
27878
27879 wxPyEndAllowThreads(__tstate);
27880 if (PyErr_Occurred()) SWIG_fail;
27881 }
27882 {
27883 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27884 }
27885 return resultobj;
27886 fail:
27887 return NULL;
27888 }
27889
27890
27891 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
27892 PyObject *resultobj;
27893 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
27894 PyObject *result;
27895 PyObject * obj0 = 0 ;
27896 char *kwnames[] = {
27897 (char *) "self", NULL
27898 };
27899
27900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
27901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
27902 if (SWIG_arg_fail(1)) SWIG_fail;
27903 {
27904 PyThreadState* __tstate = wxPyBeginAllowThreads();
27905 result = (PyObject *)wxCustomDataObject_GetData(arg1);
27906
27907 wxPyEndAllowThreads(__tstate);
27908 if (PyErr_Occurred()) SWIG_fail;
27909 }
27910 resultobj = result;
27911 return resultobj;
27912 fail:
27913 return NULL;
27914 }
27915
27916
27917 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
27918 PyObject *obj;
27919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27920 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
27921 Py_INCREF(obj);
27922 return Py_BuildValue((char *)"");
27923 }
27924 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27925 PyObject *resultobj;
27926 wxURLDataObject *result;
27927 char *kwnames[] = {
27928 NULL
27929 };
27930
27931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
27932 {
27933 PyThreadState* __tstate = wxPyBeginAllowThreads();
27934 result = (wxURLDataObject *)new wxURLDataObject();
27935
27936 wxPyEndAllowThreads(__tstate);
27937 if (PyErr_Occurred()) SWIG_fail;
27938 }
27939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
27940 return resultobj;
27941 fail:
27942 return NULL;
27943 }
27944
27945
27946 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
27947 PyObject *resultobj;
27948 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
27949 wxString result;
27950 PyObject * obj0 = 0 ;
27951 char *kwnames[] = {
27952 (char *) "self", NULL
27953 };
27954
27955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
27956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
27957 if (SWIG_arg_fail(1)) SWIG_fail;
27958 {
27959 PyThreadState* __tstate = wxPyBeginAllowThreads();
27960 result = (arg1)->GetURL();
27961
27962 wxPyEndAllowThreads(__tstate);
27963 if (PyErr_Occurred()) SWIG_fail;
27964 }
27965 {
27966 #if wxUSE_UNICODE
27967 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27968 #else
27969 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27970 #endif
27971 }
27972 return resultobj;
27973 fail:
27974 return NULL;
27975 }
27976
27977
27978 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
27979 PyObject *resultobj;
27980 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
27981 wxString *arg2 = 0 ;
27982 bool temp2 = false ;
27983 PyObject * obj0 = 0 ;
27984 PyObject * obj1 = 0 ;
27985 char *kwnames[] = {
27986 (char *) "self",(char *) "url", NULL
27987 };
27988
27989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
27990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
27991 if (SWIG_arg_fail(1)) SWIG_fail;
27992 {
27993 arg2 = wxString_in_helper(obj1);
27994 if (arg2 == NULL) SWIG_fail;
27995 temp2 = true;
27996 }
27997 {
27998 PyThreadState* __tstate = wxPyBeginAllowThreads();
27999 (arg1)->SetURL((wxString const &)*arg2);
28000
28001 wxPyEndAllowThreads(__tstate);
28002 if (PyErr_Occurred()) SWIG_fail;
28003 }
28004 Py_INCREF(Py_None); resultobj = Py_None;
28005 {
28006 if (temp2)
28007 delete arg2;
28008 }
28009 return resultobj;
28010 fail:
28011 {
28012 if (temp2)
28013 delete arg2;
28014 }
28015 return NULL;
28016 }
28017
28018
28019 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28020 PyObject *obj;
28021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28022 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28023 Py_INCREF(obj);
28024 return Py_BuildValue((char *)"");
28025 }
28026 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28027 PyObject *resultobj;
28028 wxMetafileDataObject *result;
28029 char *kwnames[] = {
28030 NULL
28031 };
28032
28033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28034 {
28035 PyThreadState* __tstate = wxPyBeginAllowThreads();
28036 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28037
28038 wxPyEndAllowThreads(__tstate);
28039 if (PyErr_Occurred()) SWIG_fail;
28040 }
28041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28042 return resultobj;
28043 fail:
28044 return NULL;
28045 }
28046
28047
28048 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28049 PyObject *obj;
28050 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28051 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28052 Py_INCREF(obj);
28053 return Py_BuildValue((char *)"");
28054 }
28055 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28056 PyObject *resultobj;
28057 wxDragResult arg1 ;
28058 bool result;
28059 PyObject * obj0 = 0 ;
28060 char *kwnames[] = {
28061 (char *) "res", NULL
28062 };
28063
28064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28065 {
28066 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28067 if (SWIG_arg_fail(1)) SWIG_fail;
28068 }
28069 {
28070 PyThreadState* __tstate = wxPyBeginAllowThreads();
28071 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28072
28073 wxPyEndAllowThreads(__tstate);
28074 if (PyErr_Occurred()) SWIG_fail;
28075 }
28076 {
28077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28078 }
28079 return resultobj;
28080 fail:
28081 return NULL;
28082 }
28083
28084
28085 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28086 PyObject *resultobj;
28087 wxWindow *arg1 = (wxWindow *) 0 ;
28088 wxIcon const &arg2_defvalue = wxNullIcon ;
28089 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28090 wxIcon const &arg3_defvalue = wxNullIcon ;
28091 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28092 wxIcon const &arg4_defvalue = wxNullIcon ;
28093 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28094 wxPyDropSource *result;
28095 PyObject * obj0 = 0 ;
28096 PyObject * obj1 = 0 ;
28097 PyObject * obj2 = 0 ;
28098 PyObject * obj3 = 0 ;
28099 char *kwnames[] = {
28100 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28101 };
28102
28103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28105 if (SWIG_arg_fail(1)) SWIG_fail;
28106 if (obj1) {
28107 {
28108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28109 if (SWIG_arg_fail(2)) SWIG_fail;
28110 if (arg2 == NULL) {
28111 SWIG_null_ref("wxIcon");
28112 }
28113 if (SWIG_arg_fail(2)) SWIG_fail;
28114 }
28115 }
28116 if (obj2) {
28117 {
28118 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28119 if (SWIG_arg_fail(3)) SWIG_fail;
28120 if (arg3 == NULL) {
28121 SWIG_null_ref("wxIcon");
28122 }
28123 if (SWIG_arg_fail(3)) SWIG_fail;
28124 }
28125 }
28126 if (obj3) {
28127 {
28128 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28129 if (SWIG_arg_fail(4)) SWIG_fail;
28130 if (arg4 == NULL) {
28131 SWIG_null_ref("wxIcon");
28132 }
28133 if (SWIG_arg_fail(4)) SWIG_fail;
28134 }
28135 }
28136 {
28137 PyThreadState* __tstate = wxPyBeginAllowThreads();
28138 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28139
28140 wxPyEndAllowThreads(__tstate);
28141 if (PyErr_Occurred()) SWIG_fail;
28142 }
28143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28144 return resultobj;
28145 fail:
28146 return NULL;
28147 }
28148
28149
28150 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28151 PyObject *resultobj;
28152 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28153 PyObject *arg2 = (PyObject *) 0 ;
28154 PyObject *arg3 = (PyObject *) 0 ;
28155 int arg4 ;
28156 PyObject * obj0 = 0 ;
28157 PyObject * obj1 = 0 ;
28158 PyObject * obj2 = 0 ;
28159 PyObject * obj3 = 0 ;
28160 char *kwnames[] = {
28161 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28162 };
28163
28164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28166 if (SWIG_arg_fail(1)) SWIG_fail;
28167 arg2 = obj1;
28168 arg3 = obj2;
28169 {
28170 arg4 = (int)(SWIG_As_int(obj3));
28171 if (SWIG_arg_fail(4)) SWIG_fail;
28172 }
28173 {
28174 PyThreadState* __tstate = wxPyBeginAllowThreads();
28175 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28176
28177 wxPyEndAllowThreads(__tstate);
28178 if (PyErr_Occurred()) SWIG_fail;
28179 }
28180 Py_INCREF(Py_None); resultobj = Py_None;
28181 return resultobj;
28182 fail:
28183 return NULL;
28184 }
28185
28186
28187 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28188 PyObject *resultobj;
28189 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28190 PyObject * obj0 = 0 ;
28191 char *kwnames[] = {
28192 (char *) "self", NULL
28193 };
28194
28195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28197 if (SWIG_arg_fail(1)) SWIG_fail;
28198 {
28199 PyThreadState* __tstate = wxPyBeginAllowThreads();
28200 delete arg1;
28201
28202 wxPyEndAllowThreads(__tstate);
28203 if (PyErr_Occurred()) SWIG_fail;
28204 }
28205 Py_INCREF(Py_None); resultobj = Py_None;
28206 return resultobj;
28207 fail:
28208 return NULL;
28209 }
28210
28211
28212 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28213 PyObject *resultobj;
28214 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28215 wxDataObject *arg2 = 0 ;
28216 PyObject * obj0 = 0 ;
28217 PyObject * obj1 = 0 ;
28218 char *kwnames[] = {
28219 (char *) "self",(char *) "data", NULL
28220 };
28221
28222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28224 if (SWIG_arg_fail(1)) SWIG_fail;
28225 {
28226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28227 if (SWIG_arg_fail(2)) SWIG_fail;
28228 if (arg2 == NULL) {
28229 SWIG_null_ref("wxDataObject");
28230 }
28231 if (SWIG_arg_fail(2)) SWIG_fail;
28232 }
28233 {
28234 PyThreadState* __tstate = wxPyBeginAllowThreads();
28235 (arg1)->SetData(*arg2);
28236
28237 wxPyEndAllowThreads(__tstate);
28238 if (PyErr_Occurred()) SWIG_fail;
28239 }
28240 Py_INCREF(Py_None); resultobj = Py_None;
28241 return resultobj;
28242 fail:
28243 return NULL;
28244 }
28245
28246
28247 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28248 PyObject *resultobj;
28249 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28250 wxDataObject *result;
28251 PyObject * obj0 = 0 ;
28252 char *kwnames[] = {
28253 (char *) "self", NULL
28254 };
28255
28256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28258 if (SWIG_arg_fail(1)) SWIG_fail;
28259 {
28260 PyThreadState* __tstate = wxPyBeginAllowThreads();
28261 result = (wxDataObject *)(arg1)->GetDataObject();
28262
28263 wxPyEndAllowThreads(__tstate);
28264 if (PyErr_Occurred()) SWIG_fail;
28265 }
28266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28267 return resultobj;
28268 fail:
28269 return NULL;
28270 }
28271
28272
28273 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28274 PyObject *resultobj;
28275 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28276 wxDragResult arg2 ;
28277 wxCursor *arg3 = 0 ;
28278 PyObject * obj0 = 0 ;
28279 PyObject * obj1 = 0 ;
28280 PyObject * obj2 = 0 ;
28281 char *kwnames[] = {
28282 (char *) "self",(char *) "res",(char *) "cursor", NULL
28283 };
28284
28285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28287 if (SWIG_arg_fail(1)) SWIG_fail;
28288 {
28289 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28290 if (SWIG_arg_fail(2)) SWIG_fail;
28291 }
28292 {
28293 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28294 if (SWIG_arg_fail(3)) SWIG_fail;
28295 if (arg3 == NULL) {
28296 SWIG_null_ref("wxCursor");
28297 }
28298 if (SWIG_arg_fail(3)) SWIG_fail;
28299 }
28300 {
28301 PyThreadState* __tstate = wxPyBeginAllowThreads();
28302 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28303
28304 wxPyEndAllowThreads(__tstate);
28305 if (PyErr_Occurred()) SWIG_fail;
28306 }
28307 Py_INCREF(Py_None); resultobj = Py_None;
28308 return resultobj;
28309 fail:
28310 return NULL;
28311 }
28312
28313
28314 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28315 PyObject *resultobj;
28316 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28317 int arg2 = (int) wxDrag_CopyOnly ;
28318 wxDragResult result;
28319 PyObject * obj0 = 0 ;
28320 PyObject * obj1 = 0 ;
28321 char *kwnames[] = {
28322 (char *) "self",(char *) "flags", NULL
28323 };
28324
28325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28327 if (SWIG_arg_fail(1)) SWIG_fail;
28328 if (obj1) {
28329 {
28330 arg2 = (int)(SWIG_As_int(obj1));
28331 if (SWIG_arg_fail(2)) SWIG_fail;
28332 }
28333 }
28334 {
28335 PyThreadState* __tstate = wxPyBeginAllowThreads();
28336 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28337
28338 wxPyEndAllowThreads(__tstate);
28339 if (PyErr_Occurred()) SWIG_fail;
28340 }
28341 resultobj = SWIG_From_int((result));
28342 return resultobj;
28343 fail:
28344 return NULL;
28345 }
28346
28347
28348 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28349 PyObject *resultobj;
28350 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28351 wxDragResult arg2 ;
28352 bool result;
28353 PyObject * obj0 = 0 ;
28354 PyObject * obj1 = 0 ;
28355 char *kwnames[] = {
28356 (char *) "self",(char *) "effect", NULL
28357 };
28358
28359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28361 if (SWIG_arg_fail(1)) SWIG_fail;
28362 {
28363 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28364 if (SWIG_arg_fail(2)) SWIG_fail;
28365 }
28366 {
28367 PyThreadState* __tstate = wxPyBeginAllowThreads();
28368 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28369
28370 wxPyEndAllowThreads(__tstate);
28371 if (PyErr_Occurred()) SWIG_fail;
28372 }
28373 {
28374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28375 }
28376 return resultobj;
28377 fail:
28378 return NULL;
28379 }
28380
28381
28382 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28383 PyObject *obj;
28384 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28385 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28386 Py_INCREF(obj);
28387 return Py_BuildValue((char *)"");
28388 }
28389 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28390 PyObject *resultobj;
28391 wxDataObject *arg1 = (wxDataObject *) NULL ;
28392 wxPyDropTarget *result;
28393 PyObject * obj0 = 0 ;
28394 char *kwnames[] = {
28395 (char *) "dataObject", NULL
28396 };
28397
28398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28399 if (obj0) {
28400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28401 if (SWIG_arg_fail(1)) SWIG_fail;
28402 }
28403 {
28404 PyThreadState* __tstate = wxPyBeginAllowThreads();
28405 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28406
28407 wxPyEndAllowThreads(__tstate);
28408 if (PyErr_Occurred()) SWIG_fail;
28409 }
28410 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28411 return resultobj;
28412 fail:
28413 return NULL;
28414 }
28415
28416
28417 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28418 PyObject *resultobj;
28419 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28420 PyObject *arg2 = (PyObject *) 0 ;
28421 PyObject *arg3 = (PyObject *) 0 ;
28422 PyObject * obj0 = 0 ;
28423 PyObject * obj1 = 0 ;
28424 PyObject * obj2 = 0 ;
28425 char *kwnames[] = {
28426 (char *) "self",(char *) "self",(char *) "_class", NULL
28427 };
28428
28429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28431 if (SWIG_arg_fail(1)) SWIG_fail;
28432 arg2 = obj1;
28433 arg3 = obj2;
28434 {
28435 PyThreadState* __tstate = wxPyBeginAllowThreads();
28436 (arg1)->_setCallbackInfo(arg2,arg3);
28437
28438 wxPyEndAllowThreads(__tstate);
28439 if (PyErr_Occurred()) SWIG_fail;
28440 }
28441 Py_INCREF(Py_None); resultobj = Py_None;
28442 return resultobj;
28443 fail:
28444 return NULL;
28445 }
28446
28447
28448 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28449 PyObject *resultobj;
28450 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28451 PyObject * obj0 = 0 ;
28452 char *kwnames[] = {
28453 (char *) "self", NULL
28454 };
28455
28456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28458 if (SWIG_arg_fail(1)) SWIG_fail;
28459 {
28460 PyThreadState* __tstate = wxPyBeginAllowThreads();
28461 delete arg1;
28462
28463 wxPyEndAllowThreads(__tstate);
28464 if (PyErr_Occurred()) SWIG_fail;
28465 }
28466 Py_INCREF(Py_None); resultobj = Py_None;
28467 return resultobj;
28468 fail:
28469 return NULL;
28470 }
28471
28472
28473 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28474 PyObject *resultobj;
28475 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28476 wxDataObject *result;
28477 PyObject * obj0 = 0 ;
28478 char *kwnames[] = {
28479 (char *) "self", NULL
28480 };
28481
28482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28484 if (SWIG_arg_fail(1)) SWIG_fail;
28485 {
28486 PyThreadState* __tstate = wxPyBeginAllowThreads();
28487 result = (wxDataObject *)(arg1)->GetDataObject();
28488
28489 wxPyEndAllowThreads(__tstate);
28490 if (PyErr_Occurred()) SWIG_fail;
28491 }
28492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28493 return resultobj;
28494 fail:
28495 return NULL;
28496 }
28497
28498
28499 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28500 PyObject *resultobj;
28501 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28502 wxDataObject *arg2 = (wxDataObject *) 0 ;
28503 PyObject * obj0 = 0 ;
28504 PyObject * obj1 = 0 ;
28505 char *kwnames[] = {
28506 (char *) "self",(char *) "dataObject", NULL
28507 };
28508
28509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28511 if (SWIG_arg_fail(1)) SWIG_fail;
28512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28513 if (SWIG_arg_fail(2)) SWIG_fail;
28514 {
28515 PyThreadState* __tstate = wxPyBeginAllowThreads();
28516 (arg1)->SetDataObject(arg2);
28517
28518 wxPyEndAllowThreads(__tstate);
28519 if (PyErr_Occurred()) SWIG_fail;
28520 }
28521 Py_INCREF(Py_None); resultobj = Py_None;
28522 return resultobj;
28523 fail:
28524 return NULL;
28525 }
28526
28527
28528 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28529 PyObject *resultobj;
28530 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28531 int arg2 ;
28532 int arg3 ;
28533 wxDragResult arg4 ;
28534 wxDragResult result;
28535 PyObject * obj0 = 0 ;
28536 PyObject * obj1 = 0 ;
28537 PyObject * obj2 = 0 ;
28538 PyObject * obj3 = 0 ;
28539 char *kwnames[] = {
28540 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28541 };
28542
28543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28545 if (SWIG_arg_fail(1)) SWIG_fail;
28546 {
28547 arg2 = (int)(SWIG_As_int(obj1));
28548 if (SWIG_arg_fail(2)) SWIG_fail;
28549 }
28550 {
28551 arg3 = (int)(SWIG_As_int(obj2));
28552 if (SWIG_arg_fail(3)) SWIG_fail;
28553 }
28554 {
28555 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28556 if (SWIG_arg_fail(4)) SWIG_fail;
28557 }
28558 {
28559 PyThreadState* __tstate = wxPyBeginAllowThreads();
28560 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28561
28562 wxPyEndAllowThreads(__tstate);
28563 if (PyErr_Occurred()) SWIG_fail;
28564 }
28565 resultobj = SWIG_From_int((result));
28566 return resultobj;
28567 fail:
28568 return NULL;
28569 }
28570
28571
28572 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28573 PyObject *resultobj;
28574 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28575 int arg2 ;
28576 int arg3 ;
28577 wxDragResult arg4 ;
28578 wxDragResult result;
28579 PyObject * obj0 = 0 ;
28580 PyObject * obj1 = 0 ;
28581 PyObject * obj2 = 0 ;
28582 PyObject * obj3 = 0 ;
28583 char *kwnames[] = {
28584 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28585 };
28586
28587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28589 if (SWIG_arg_fail(1)) SWIG_fail;
28590 {
28591 arg2 = (int)(SWIG_As_int(obj1));
28592 if (SWIG_arg_fail(2)) SWIG_fail;
28593 }
28594 {
28595 arg3 = (int)(SWIG_As_int(obj2));
28596 if (SWIG_arg_fail(3)) SWIG_fail;
28597 }
28598 {
28599 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28600 if (SWIG_arg_fail(4)) SWIG_fail;
28601 }
28602 {
28603 PyThreadState* __tstate = wxPyBeginAllowThreads();
28604 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28605
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 resultobj = SWIG_From_int((result));
28610 return resultobj;
28611 fail:
28612 return NULL;
28613 }
28614
28615
28616 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28617 PyObject *resultobj;
28618 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28619 PyObject * obj0 = 0 ;
28620 char *kwnames[] = {
28621 (char *) "self", NULL
28622 };
28623
28624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28626 if (SWIG_arg_fail(1)) SWIG_fail;
28627 {
28628 PyThreadState* __tstate = wxPyBeginAllowThreads();
28629 (arg1)->base_OnLeave();
28630
28631 wxPyEndAllowThreads(__tstate);
28632 if (PyErr_Occurred()) SWIG_fail;
28633 }
28634 Py_INCREF(Py_None); resultobj = Py_None;
28635 return resultobj;
28636 fail:
28637 return NULL;
28638 }
28639
28640
28641 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28642 PyObject *resultobj;
28643 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28644 int arg2 ;
28645 int arg3 ;
28646 bool result;
28647 PyObject * obj0 = 0 ;
28648 PyObject * obj1 = 0 ;
28649 PyObject * obj2 = 0 ;
28650 char *kwnames[] = {
28651 (char *) "self",(char *) "x",(char *) "y", NULL
28652 };
28653
28654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28656 if (SWIG_arg_fail(1)) SWIG_fail;
28657 {
28658 arg2 = (int)(SWIG_As_int(obj1));
28659 if (SWIG_arg_fail(2)) SWIG_fail;
28660 }
28661 {
28662 arg3 = (int)(SWIG_As_int(obj2));
28663 if (SWIG_arg_fail(3)) SWIG_fail;
28664 }
28665 {
28666 PyThreadState* __tstate = wxPyBeginAllowThreads();
28667 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28668
28669 wxPyEndAllowThreads(__tstate);
28670 if (PyErr_Occurred()) SWIG_fail;
28671 }
28672 {
28673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28674 }
28675 return resultobj;
28676 fail:
28677 return NULL;
28678 }
28679
28680
28681 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28682 PyObject *resultobj;
28683 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28684 bool result;
28685 PyObject * obj0 = 0 ;
28686 char *kwnames[] = {
28687 (char *) "self", NULL
28688 };
28689
28690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
28691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28692 if (SWIG_arg_fail(1)) SWIG_fail;
28693 {
28694 PyThreadState* __tstate = wxPyBeginAllowThreads();
28695 result = (bool)(arg1)->GetData();
28696
28697 wxPyEndAllowThreads(__tstate);
28698 if (PyErr_Occurred()) SWIG_fail;
28699 }
28700 {
28701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28702 }
28703 return resultobj;
28704 fail:
28705 return NULL;
28706 }
28707
28708
28709 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
28710 PyObject *obj;
28711 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28712 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
28713 Py_INCREF(obj);
28714 return Py_BuildValue((char *)"");
28715 }
28716 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28717 PyObject *resultobj;
28718 wxPyTextDropTarget *result;
28719 char *kwnames[] = {
28720 NULL
28721 };
28722
28723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
28724 {
28725 PyThreadState* __tstate = wxPyBeginAllowThreads();
28726 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
28727
28728 wxPyEndAllowThreads(__tstate);
28729 if (PyErr_Occurred()) SWIG_fail;
28730 }
28731 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
28732 return resultobj;
28733 fail:
28734 return NULL;
28735 }
28736
28737
28738 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28739 PyObject *resultobj;
28740 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28741 PyObject *arg2 = (PyObject *) 0 ;
28742 PyObject *arg3 = (PyObject *) 0 ;
28743 PyObject * obj0 = 0 ;
28744 PyObject * obj1 = 0 ;
28745 PyObject * obj2 = 0 ;
28746 char *kwnames[] = {
28747 (char *) "self",(char *) "self",(char *) "_class", NULL
28748 };
28749
28750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28752 if (SWIG_arg_fail(1)) SWIG_fail;
28753 arg2 = obj1;
28754 arg3 = obj2;
28755 {
28756 PyThreadState* __tstate = wxPyBeginAllowThreads();
28757 (arg1)->_setCallbackInfo(arg2,arg3);
28758
28759 wxPyEndAllowThreads(__tstate);
28760 if (PyErr_Occurred()) SWIG_fail;
28761 }
28762 Py_INCREF(Py_None); resultobj = Py_None;
28763 return resultobj;
28764 fail:
28765 return NULL;
28766 }
28767
28768
28769 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28770 PyObject *resultobj;
28771 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28772 int arg2 ;
28773 int arg3 ;
28774 wxDragResult arg4 ;
28775 wxDragResult result;
28776 PyObject * obj0 = 0 ;
28777 PyObject * obj1 = 0 ;
28778 PyObject * obj2 = 0 ;
28779 PyObject * obj3 = 0 ;
28780 char *kwnames[] = {
28781 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28782 };
28783
28784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28786 if (SWIG_arg_fail(1)) SWIG_fail;
28787 {
28788 arg2 = (int)(SWIG_As_int(obj1));
28789 if (SWIG_arg_fail(2)) SWIG_fail;
28790 }
28791 {
28792 arg3 = (int)(SWIG_As_int(obj2));
28793 if (SWIG_arg_fail(3)) SWIG_fail;
28794 }
28795 {
28796 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28797 if (SWIG_arg_fail(4)) SWIG_fail;
28798 }
28799 {
28800 PyThreadState* __tstate = wxPyBeginAllowThreads();
28801 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28802
28803 wxPyEndAllowThreads(__tstate);
28804 if (PyErr_Occurred()) SWIG_fail;
28805 }
28806 resultobj = SWIG_From_int((result));
28807 return resultobj;
28808 fail:
28809 return NULL;
28810 }
28811
28812
28813 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28814 PyObject *resultobj;
28815 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28816 int arg2 ;
28817 int arg3 ;
28818 wxDragResult arg4 ;
28819 wxDragResult result;
28820 PyObject * obj0 = 0 ;
28821 PyObject * obj1 = 0 ;
28822 PyObject * obj2 = 0 ;
28823 PyObject * obj3 = 0 ;
28824 char *kwnames[] = {
28825 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28826 };
28827
28828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28830 if (SWIG_arg_fail(1)) SWIG_fail;
28831 {
28832 arg2 = (int)(SWIG_As_int(obj1));
28833 if (SWIG_arg_fail(2)) SWIG_fail;
28834 }
28835 {
28836 arg3 = (int)(SWIG_As_int(obj2));
28837 if (SWIG_arg_fail(3)) SWIG_fail;
28838 }
28839 {
28840 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28841 if (SWIG_arg_fail(4)) SWIG_fail;
28842 }
28843 {
28844 PyThreadState* __tstate = wxPyBeginAllowThreads();
28845 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28846
28847 wxPyEndAllowThreads(__tstate);
28848 if (PyErr_Occurred()) SWIG_fail;
28849 }
28850 resultobj = SWIG_From_int((result));
28851 return resultobj;
28852 fail:
28853 return NULL;
28854 }
28855
28856
28857 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28858 PyObject *resultobj;
28859 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28860 PyObject * obj0 = 0 ;
28861 char *kwnames[] = {
28862 (char *) "self", NULL
28863 };
28864
28865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28867 if (SWIG_arg_fail(1)) SWIG_fail;
28868 {
28869 PyThreadState* __tstate = wxPyBeginAllowThreads();
28870 (arg1)->base_OnLeave();
28871
28872 wxPyEndAllowThreads(__tstate);
28873 if (PyErr_Occurred()) SWIG_fail;
28874 }
28875 Py_INCREF(Py_None); resultobj = Py_None;
28876 return resultobj;
28877 fail:
28878 return NULL;
28879 }
28880
28881
28882 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28883 PyObject *resultobj;
28884 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28885 int arg2 ;
28886 int arg3 ;
28887 bool result;
28888 PyObject * obj0 = 0 ;
28889 PyObject * obj1 = 0 ;
28890 PyObject * obj2 = 0 ;
28891 char *kwnames[] = {
28892 (char *) "self",(char *) "x",(char *) "y", NULL
28893 };
28894
28895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28897 if (SWIG_arg_fail(1)) SWIG_fail;
28898 {
28899 arg2 = (int)(SWIG_As_int(obj1));
28900 if (SWIG_arg_fail(2)) SWIG_fail;
28901 }
28902 {
28903 arg3 = (int)(SWIG_As_int(obj2));
28904 if (SWIG_arg_fail(3)) SWIG_fail;
28905 }
28906 {
28907 PyThreadState* __tstate = wxPyBeginAllowThreads();
28908 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
28909
28910 wxPyEndAllowThreads(__tstate);
28911 if (PyErr_Occurred()) SWIG_fail;
28912 }
28913 {
28914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28915 }
28916 return resultobj;
28917 fail:
28918 return NULL;
28919 }
28920
28921
28922 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
28923 PyObject *resultobj;
28924 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
28925 int arg2 ;
28926 int arg3 ;
28927 wxDragResult arg4 ;
28928 wxDragResult result;
28929 PyObject * obj0 = 0 ;
28930 PyObject * obj1 = 0 ;
28931 PyObject * obj2 = 0 ;
28932 PyObject * obj3 = 0 ;
28933 char *kwnames[] = {
28934 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28935 };
28936
28937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
28939 if (SWIG_arg_fail(1)) SWIG_fail;
28940 {
28941 arg2 = (int)(SWIG_As_int(obj1));
28942 if (SWIG_arg_fail(2)) SWIG_fail;
28943 }
28944 {
28945 arg3 = (int)(SWIG_As_int(obj2));
28946 if (SWIG_arg_fail(3)) SWIG_fail;
28947 }
28948 {
28949 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28950 if (SWIG_arg_fail(4)) SWIG_fail;
28951 }
28952 {
28953 PyThreadState* __tstate = wxPyBeginAllowThreads();
28954 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
28955
28956 wxPyEndAllowThreads(__tstate);
28957 if (PyErr_Occurred()) SWIG_fail;
28958 }
28959 resultobj = SWIG_From_int((result));
28960 return resultobj;
28961 fail:
28962 return NULL;
28963 }
28964
28965
28966 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
28967 PyObject *obj;
28968 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28969 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
28970 Py_INCREF(obj);
28971 return Py_BuildValue((char *)"");
28972 }
28973 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28974 PyObject *resultobj;
28975 wxPyFileDropTarget *result;
28976 char *kwnames[] = {
28977 NULL
28978 };
28979
28980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
28981 {
28982 PyThreadState* __tstate = wxPyBeginAllowThreads();
28983 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
28984
28985 wxPyEndAllowThreads(__tstate);
28986 if (PyErr_Occurred()) SWIG_fail;
28987 }
28988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
28989 return resultobj;
28990 fail:
28991 return NULL;
28992 }
28993
28994
28995 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28996 PyObject *resultobj;
28997 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
28998 PyObject *arg2 = (PyObject *) 0 ;
28999 PyObject *arg3 = (PyObject *) 0 ;
29000 PyObject * obj0 = 0 ;
29001 PyObject * obj1 = 0 ;
29002 PyObject * obj2 = 0 ;
29003 char *kwnames[] = {
29004 (char *) "self",(char *) "self",(char *) "_class", NULL
29005 };
29006
29007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29009 if (SWIG_arg_fail(1)) SWIG_fail;
29010 arg2 = obj1;
29011 arg3 = obj2;
29012 {
29013 PyThreadState* __tstate = wxPyBeginAllowThreads();
29014 (arg1)->_setCallbackInfo(arg2,arg3);
29015
29016 wxPyEndAllowThreads(__tstate);
29017 if (PyErr_Occurred()) SWIG_fail;
29018 }
29019 Py_INCREF(Py_None); resultobj = Py_None;
29020 return resultobj;
29021 fail:
29022 return NULL;
29023 }
29024
29025
29026 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29027 PyObject *resultobj;
29028 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29029 int arg2 ;
29030 int arg3 ;
29031 wxDragResult arg4 ;
29032 wxDragResult result;
29033 PyObject * obj0 = 0 ;
29034 PyObject * obj1 = 0 ;
29035 PyObject * obj2 = 0 ;
29036 PyObject * obj3 = 0 ;
29037 char *kwnames[] = {
29038 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29039 };
29040
29041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29043 if (SWIG_arg_fail(1)) SWIG_fail;
29044 {
29045 arg2 = (int)(SWIG_As_int(obj1));
29046 if (SWIG_arg_fail(2)) SWIG_fail;
29047 }
29048 {
29049 arg3 = (int)(SWIG_As_int(obj2));
29050 if (SWIG_arg_fail(3)) SWIG_fail;
29051 }
29052 {
29053 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29054 if (SWIG_arg_fail(4)) SWIG_fail;
29055 }
29056 {
29057 PyThreadState* __tstate = wxPyBeginAllowThreads();
29058 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29059
29060 wxPyEndAllowThreads(__tstate);
29061 if (PyErr_Occurred()) SWIG_fail;
29062 }
29063 resultobj = SWIG_From_int((result));
29064 return resultobj;
29065 fail:
29066 return NULL;
29067 }
29068
29069
29070 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29071 PyObject *resultobj;
29072 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29073 int arg2 ;
29074 int arg3 ;
29075 wxDragResult arg4 ;
29076 wxDragResult result;
29077 PyObject * obj0 = 0 ;
29078 PyObject * obj1 = 0 ;
29079 PyObject * obj2 = 0 ;
29080 PyObject * obj3 = 0 ;
29081 char *kwnames[] = {
29082 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29083 };
29084
29085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29087 if (SWIG_arg_fail(1)) SWIG_fail;
29088 {
29089 arg2 = (int)(SWIG_As_int(obj1));
29090 if (SWIG_arg_fail(2)) SWIG_fail;
29091 }
29092 {
29093 arg3 = (int)(SWIG_As_int(obj2));
29094 if (SWIG_arg_fail(3)) SWIG_fail;
29095 }
29096 {
29097 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29098 if (SWIG_arg_fail(4)) SWIG_fail;
29099 }
29100 {
29101 PyThreadState* __tstate = wxPyBeginAllowThreads();
29102 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29103
29104 wxPyEndAllowThreads(__tstate);
29105 if (PyErr_Occurred()) SWIG_fail;
29106 }
29107 resultobj = SWIG_From_int((result));
29108 return resultobj;
29109 fail:
29110 return NULL;
29111 }
29112
29113
29114 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29115 PyObject *resultobj;
29116 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29117 PyObject * obj0 = 0 ;
29118 char *kwnames[] = {
29119 (char *) "self", NULL
29120 };
29121
29122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29124 if (SWIG_arg_fail(1)) SWIG_fail;
29125 {
29126 PyThreadState* __tstate = wxPyBeginAllowThreads();
29127 (arg1)->base_OnLeave();
29128
29129 wxPyEndAllowThreads(__tstate);
29130 if (PyErr_Occurred()) SWIG_fail;
29131 }
29132 Py_INCREF(Py_None); resultobj = Py_None;
29133 return resultobj;
29134 fail:
29135 return NULL;
29136 }
29137
29138
29139 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29140 PyObject *resultobj;
29141 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29142 int arg2 ;
29143 int arg3 ;
29144 bool result;
29145 PyObject * obj0 = 0 ;
29146 PyObject * obj1 = 0 ;
29147 PyObject * obj2 = 0 ;
29148 char *kwnames[] = {
29149 (char *) "self",(char *) "x",(char *) "y", NULL
29150 };
29151
29152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29154 if (SWIG_arg_fail(1)) SWIG_fail;
29155 {
29156 arg2 = (int)(SWIG_As_int(obj1));
29157 if (SWIG_arg_fail(2)) SWIG_fail;
29158 }
29159 {
29160 arg3 = (int)(SWIG_As_int(obj2));
29161 if (SWIG_arg_fail(3)) SWIG_fail;
29162 }
29163 {
29164 PyThreadState* __tstate = wxPyBeginAllowThreads();
29165 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29166
29167 wxPyEndAllowThreads(__tstate);
29168 if (PyErr_Occurred()) SWIG_fail;
29169 }
29170 {
29171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29172 }
29173 return resultobj;
29174 fail:
29175 return NULL;
29176 }
29177
29178
29179 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29180 PyObject *resultobj;
29181 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29182 int arg2 ;
29183 int arg3 ;
29184 wxDragResult arg4 ;
29185 wxDragResult result;
29186 PyObject * obj0 = 0 ;
29187 PyObject * obj1 = 0 ;
29188 PyObject * obj2 = 0 ;
29189 PyObject * obj3 = 0 ;
29190 char *kwnames[] = {
29191 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29192 };
29193
29194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29196 if (SWIG_arg_fail(1)) SWIG_fail;
29197 {
29198 arg2 = (int)(SWIG_As_int(obj1));
29199 if (SWIG_arg_fail(2)) SWIG_fail;
29200 }
29201 {
29202 arg3 = (int)(SWIG_As_int(obj2));
29203 if (SWIG_arg_fail(3)) SWIG_fail;
29204 }
29205 {
29206 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29207 if (SWIG_arg_fail(4)) SWIG_fail;
29208 }
29209 {
29210 PyThreadState* __tstate = wxPyBeginAllowThreads();
29211 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29212
29213 wxPyEndAllowThreads(__tstate);
29214 if (PyErr_Occurred()) SWIG_fail;
29215 }
29216 resultobj = SWIG_From_int((result));
29217 return resultobj;
29218 fail:
29219 return NULL;
29220 }
29221
29222
29223 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29224 PyObject *obj;
29225 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29226 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29227 Py_INCREF(obj);
29228 return Py_BuildValue((char *)"");
29229 }
29230 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29231 PyObject *resultobj;
29232 wxClipboard *result;
29233 char *kwnames[] = {
29234 NULL
29235 };
29236
29237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29238 {
29239 PyThreadState* __tstate = wxPyBeginAllowThreads();
29240 result = (wxClipboard *)new wxClipboard();
29241
29242 wxPyEndAllowThreads(__tstate);
29243 if (PyErr_Occurred()) SWIG_fail;
29244 }
29245 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29246 return resultobj;
29247 fail:
29248 return NULL;
29249 }
29250
29251
29252 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29253 PyObject *resultobj;
29254 wxClipboard *arg1 = (wxClipboard *) 0 ;
29255 PyObject * obj0 = 0 ;
29256 char *kwnames[] = {
29257 (char *) "self", NULL
29258 };
29259
29260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29262 if (SWIG_arg_fail(1)) SWIG_fail;
29263 {
29264 PyThreadState* __tstate = wxPyBeginAllowThreads();
29265 delete arg1;
29266
29267 wxPyEndAllowThreads(__tstate);
29268 if (PyErr_Occurred()) SWIG_fail;
29269 }
29270 Py_INCREF(Py_None); resultobj = Py_None;
29271 return resultobj;
29272 fail:
29273 return NULL;
29274 }
29275
29276
29277 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29278 PyObject *resultobj;
29279 wxClipboard *arg1 = (wxClipboard *) 0 ;
29280 bool result;
29281 PyObject * obj0 = 0 ;
29282 char *kwnames[] = {
29283 (char *) "self", NULL
29284 };
29285
29286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29288 if (SWIG_arg_fail(1)) SWIG_fail;
29289 {
29290 PyThreadState* __tstate = wxPyBeginAllowThreads();
29291 result = (bool)(arg1)->Open();
29292
29293 wxPyEndAllowThreads(__tstate);
29294 if (PyErr_Occurred()) SWIG_fail;
29295 }
29296 {
29297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29298 }
29299 return resultobj;
29300 fail:
29301 return NULL;
29302 }
29303
29304
29305 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29306 PyObject *resultobj;
29307 wxClipboard *arg1 = (wxClipboard *) 0 ;
29308 PyObject * obj0 = 0 ;
29309 char *kwnames[] = {
29310 (char *) "self", NULL
29311 };
29312
29313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29315 if (SWIG_arg_fail(1)) SWIG_fail;
29316 {
29317 PyThreadState* __tstate = wxPyBeginAllowThreads();
29318 (arg1)->Close();
29319
29320 wxPyEndAllowThreads(__tstate);
29321 if (PyErr_Occurred()) SWIG_fail;
29322 }
29323 Py_INCREF(Py_None); resultobj = Py_None;
29324 return resultobj;
29325 fail:
29326 return NULL;
29327 }
29328
29329
29330 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29331 PyObject *resultobj;
29332 wxClipboard *arg1 = (wxClipboard *) 0 ;
29333 bool result;
29334 PyObject * obj0 = 0 ;
29335 char *kwnames[] = {
29336 (char *) "self", NULL
29337 };
29338
29339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29341 if (SWIG_arg_fail(1)) SWIG_fail;
29342 {
29343 PyThreadState* __tstate = wxPyBeginAllowThreads();
29344 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29345
29346 wxPyEndAllowThreads(__tstate);
29347 if (PyErr_Occurred()) SWIG_fail;
29348 }
29349 {
29350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29351 }
29352 return resultobj;
29353 fail:
29354 return NULL;
29355 }
29356
29357
29358 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29359 PyObject *resultobj;
29360 wxClipboard *arg1 = (wxClipboard *) 0 ;
29361 wxDataObject *arg2 = (wxDataObject *) 0 ;
29362 bool result;
29363 PyObject * obj0 = 0 ;
29364 PyObject * obj1 = 0 ;
29365 char *kwnames[] = {
29366 (char *) "self",(char *) "data", NULL
29367 };
29368
29369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29371 if (SWIG_arg_fail(1)) SWIG_fail;
29372 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29373 if (SWIG_arg_fail(2)) SWIG_fail;
29374 {
29375 PyThreadState* __tstate = wxPyBeginAllowThreads();
29376 result = (bool)(arg1)->AddData(arg2);
29377
29378 wxPyEndAllowThreads(__tstate);
29379 if (PyErr_Occurred()) SWIG_fail;
29380 }
29381 {
29382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29383 }
29384 return resultobj;
29385 fail:
29386 return NULL;
29387 }
29388
29389
29390 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29391 PyObject *resultobj;
29392 wxClipboard *arg1 = (wxClipboard *) 0 ;
29393 wxDataObject *arg2 = (wxDataObject *) 0 ;
29394 bool result;
29395 PyObject * obj0 = 0 ;
29396 PyObject * obj1 = 0 ;
29397 char *kwnames[] = {
29398 (char *) "self",(char *) "data", NULL
29399 };
29400
29401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29403 if (SWIG_arg_fail(1)) SWIG_fail;
29404 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29405 if (SWIG_arg_fail(2)) SWIG_fail;
29406 {
29407 PyThreadState* __tstate = wxPyBeginAllowThreads();
29408 result = (bool)(arg1)->SetData(arg2);
29409
29410 wxPyEndAllowThreads(__tstate);
29411 if (PyErr_Occurred()) SWIG_fail;
29412 }
29413 {
29414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29415 }
29416 return resultobj;
29417 fail:
29418 return NULL;
29419 }
29420
29421
29422 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29423 PyObject *resultobj;
29424 wxClipboard *arg1 = (wxClipboard *) 0 ;
29425 wxDataFormat *arg2 = 0 ;
29426 bool result;
29427 PyObject * obj0 = 0 ;
29428 PyObject * obj1 = 0 ;
29429 char *kwnames[] = {
29430 (char *) "self",(char *) "format", NULL
29431 };
29432
29433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29435 if (SWIG_arg_fail(1)) SWIG_fail;
29436 {
29437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29438 if (SWIG_arg_fail(2)) SWIG_fail;
29439 if (arg2 == NULL) {
29440 SWIG_null_ref("wxDataFormat");
29441 }
29442 if (SWIG_arg_fail(2)) SWIG_fail;
29443 }
29444 {
29445 PyThreadState* __tstate = wxPyBeginAllowThreads();
29446 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29447
29448 wxPyEndAllowThreads(__tstate);
29449 if (PyErr_Occurred()) SWIG_fail;
29450 }
29451 {
29452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29453 }
29454 return resultobj;
29455 fail:
29456 return NULL;
29457 }
29458
29459
29460 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29461 PyObject *resultobj;
29462 wxClipboard *arg1 = (wxClipboard *) 0 ;
29463 wxDataObject *arg2 = 0 ;
29464 bool result;
29465 PyObject * obj0 = 0 ;
29466 PyObject * obj1 = 0 ;
29467 char *kwnames[] = {
29468 (char *) "self",(char *) "data", NULL
29469 };
29470
29471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29473 if (SWIG_arg_fail(1)) SWIG_fail;
29474 {
29475 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29476 if (SWIG_arg_fail(2)) SWIG_fail;
29477 if (arg2 == NULL) {
29478 SWIG_null_ref("wxDataObject");
29479 }
29480 if (SWIG_arg_fail(2)) SWIG_fail;
29481 }
29482 {
29483 PyThreadState* __tstate = wxPyBeginAllowThreads();
29484 result = (bool)(arg1)->GetData(*arg2);
29485
29486 wxPyEndAllowThreads(__tstate);
29487 if (PyErr_Occurred()) SWIG_fail;
29488 }
29489 {
29490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29491 }
29492 return resultobj;
29493 fail:
29494 return NULL;
29495 }
29496
29497
29498 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29499 PyObject *resultobj;
29500 wxClipboard *arg1 = (wxClipboard *) 0 ;
29501 PyObject * obj0 = 0 ;
29502 char *kwnames[] = {
29503 (char *) "self", NULL
29504 };
29505
29506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29508 if (SWIG_arg_fail(1)) SWIG_fail;
29509 {
29510 PyThreadState* __tstate = wxPyBeginAllowThreads();
29511 (arg1)->Clear();
29512
29513 wxPyEndAllowThreads(__tstate);
29514 if (PyErr_Occurred()) SWIG_fail;
29515 }
29516 Py_INCREF(Py_None); resultobj = Py_None;
29517 return resultobj;
29518 fail:
29519 return NULL;
29520 }
29521
29522
29523 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29524 PyObject *resultobj;
29525 wxClipboard *arg1 = (wxClipboard *) 0 ;
29526 bool result;
29527 PyObject * obj0 = 0 ;
29528 char *kwnames[] = {
29529 (char *) "self", NULL
29530 };
29531
29532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29534 if (SWIG_arg_fail(1)) SWIG_fail;
29535 {
29536 PyThreadState* __tstate = wxPyBeginAllowThreads();
29537 result = (bool)(arg1)->Flush();
29538
29539 wxPyEndAllowThreads(__tstate);
29540 if (PyErr_Occurred()) SWIG_fail;
29541 }
29542 {
29543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29544 }
29545 return resultobj;
29546 fail:
29547 return NULL;
29548 }
29549
29550
29551 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29552 PyObject *resultobj;
29553 wxClipboard *arg1 = (wxClipboard *) 0 ;
29554 bool arg2 = (bool) true ;
29555 PyObject * obj0 = 0 ;
29556 PyObject * obj1 = 0 ;
29557 char *kwnames[] = {
29558 (char *) "self",(char *) "primary", NULL
29559 };
29560
29561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29563 if (SWIG_arg_fail(1)) SWIG_fail;
29564 if (obj1) {
29565 {
29566 arg2 = (bool)(SWIG_As_bool(obj1));
29567 if (SWIG_arg_fail(2)) SWIG_fail;
29568 }
29569 }
29570 {
29571 PyThreadState* __tstate = wxPyBeginAllowThreads();
29572 (arg1)->UsePrimarySelection(arg2);
29573
29574 wxPyEndAllowThreads(__tstate);
29575 if (PyErr_Occurred()) SWIG_fail;
29576 }
29577 Py_INCREF(Py_None); resultobj = Py_None;
29578 return resultobj;
29579 fail:
29580 return NULL;
29581 }
29582
29583
29584 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29585 PyObject *resultobj;
29586 wxClipboard *result;
29587 char *kwnames[] = {
29588 NULL
29589 };
29590
29591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29592 {
29593 PyThreadState* __tstate = wxPyBeginAllowThreads();
29594 result = (wxClipboard *)wxClipboard::Get();
29595
29596 wxPyEndAllowThreads(__tstate);
29597 if (PyErr_Occurred()) SWIG_fail;
29598 }
29599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29600 return resultobj;
29601 fail:
29602 return NULL;
29603 }
29604
29605
29606 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29607 PyObject *obj;
29608 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29609 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29610 Py_INCREF(obj);
29611 return Py_BuildValue((char *)"");
29612 }
29613 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29614 PyObject *resultobj;
29615 wxClipboard *arg1 = (wxClipboard *) NULL ;
29616 wxClipboardLocker *result;
29617 PyObject * obj0 = 0 ;
29618 char *kwnames[] = {
29619 (char *) "clipboard", NULL
29620 };
29621
29622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
29623 if (obj0) {
29624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29625 if (SWIG_arg_fail(1)) SWIG_fail;
29626 }
29627 {
29628 PyThreadState* __tstate = wxPyBeginAllowThreads();
29629 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
29630
29631 wxPyEndAllowThreads(__tstate);
29632 if (PyErr_Occurred()) SWIG_fail;
29633 }
29634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
29635 return resultobj;
29636 fail:
29637 return NULL;
29638 }
29639
29640
29641 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29642 PyObject *resultobj;
29643 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29644 PyObject * obj0 = 0 ;
29645 char *kwnames[] = {
29646 (char *) "self", NULL
29647 };
29648
29649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
29650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29651 if (SWIG_arg_fail(1)) SWIG_fail;
29652 {
29653 PyThreadState* __tstate = wxPyBeginAllowThreads();
29654 delete arg1;
29655
29656 wxPyEndAllowThreads(__tstate);
29657 if (PyErr_Occurred()) SWIG_fail;
29658 }
29659 Py_INCREF(Py_None); resultobj = Py_None;
29660 return resultobj;
29661 fail:
29662 return NULL;
29663 }
29664
29665
29666 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
29667 PyObject *resultobj;
29668 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29669 bool result;
29670 PyObject * obj0 = 0 ;
29671 char *kwnames[] = {
29672 (char *) "self", NULL
29673 };
29674
29675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
29676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29677 if (SWIG_arg_fail(1)) SWIG_fail;
29678 {
29679 PyThreadState* __tstate = wxPyBeginAllowThreads();
29680 result = (bool)wxClipboardLocker___nonzero__(arg1);
29681
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 {
29686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29687 }
29688 return resultobj;
29689 fail:
29690 return NULL;
29691 }
29692
29693
29694 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
29695 PyObject *obj;
29696 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29697 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
29698 Py_INCREF(obj);
29699 return Py_BuildValue((char *)"");
29700 }
29701 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29702 PyObject *resultobj;
29703 int arg1 = (int) 0 ;
29704 int arg2 = (int) 0 ;
29705 int arg3 = (int) 0 ;
29706 int arg4 = (int) 0 ;
29707 wxVideoMode *result;
29708 PyObject * obj0 = 0 ;
29709 PyObject * obj1 = 0 ;
29710 PyObject * obj2 = 0 ;
29711 PyObject * obj3 = 0 ;
29712 char *kwnames[] = {
29713 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
29714 };
29715
29716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29717 if (obj0) {
29718 {
29719 arg1 = (int)(SWIG_As_int(obj0));
29720 if (SWIG_arg_fail(1)) SWIG_fail;
29721 }
29722 }
29723 if (obj1) {
29724 {
29725 arg2 = (int)(SWIG_As_int(obj1));
29726 if (SWIG_arg_fail(2)) SWIG_fail;
29727 }
29728 }
29729 if (obj2) {
29730 {
29731 arg3 = (int)(SWIG_As_int(obj2));
29732 if (SWIG_arg_fail(3)) SWIG_fail;
29733 }
29734 }
29735 if (obj3) {
29736 {
29737 arg4 = (int)(SWIG_As_int(obj3));
29738 if (SWIG_arg_fail(4)) SWIG_fail;
29739 }
29740 }
29741 {
29742 PyThreadState* __tstate = wxPyBeginAllowThreads();
29743 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
29744
29745 wxPyEndAllowThreads(__tstate);
29746 if (PyErr_Occurred()) SWIG_fail;
29747 }
29748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
29749 return resultobj;
29750 fail:
29751 return NULL;
29752 }
29753
29754
29755 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
29756 PyObject *resultobj;
29757 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29758 PyObject * obj0 = 0 ;
29759 char *kwnames[] = {
29760 (char *) "self", NULL
29761 };
29762
29763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
29764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29765 if (SWIG_arg_fail(1)) SWIG_fail;
29766 {
29767 PyThreadState* __tstate = wxPyBeginAllowThreads();
29768 delete arg1;
29769
29770 wxPyEndAllowThreads(__tstate);
29771 if (PyErr_Occurred()) SWIG_fail;
29772 }
29773 Py_INCREF(Py_None); resultobj = Py_None;
29774 return resultobj;
29775 fail:
29776 return NULL;
29777 }
29778
29779
29780 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
29781 PyObject *resultobj;
29782 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29783 wxVideoMode *arg2 = 0 ;
29784 bool result;
29785 PyObject * obj0 = 0 ;
29786 PyObject * obj1 = 0 ;
29787 char *kwnames[] = {
29788 (char *) "self",(char *) "other", NULL
29789 };
29790
29791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
29792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29793 if (SWIG_arg_fail(1)) SWIG_fail;
29794 {
29795 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29796 if (SWIG_arg_fail(2)) SWIG_fail;
29797 if (arg2 == NULL) {
29798 SWIG_null_ref("wxVideoMode");
29799 }
29800 if (SWIG_arg_fail(2)) SWIG_fail;
29801 }
29802 {
29803 PyThreadState* __tstate = wxPyBeginAllowThreads();
29804 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
29805
29806 wxPyEndAllowThreads(__tstate);
29807 if (PyErr_Occurred()) SWIG_fail;
29808 }
29809 {
29810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29811 }
29812 return resultobj;
29813 fail:
29814 return NULL;
29815 }
29816
29817
29818 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29819 PyObject *resultobj;
29820 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29821 int result;
29822 PyObject * obj0 = 0 ;
29823 char *kwnames[] = {
29824 (char *) "self", NULL
29825 };
29826
29827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
29828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29829 if (SWIG_arg_fail(1)) SWIG_fail;
29830 {
29831 PyThreadState* __tstate = wxPyBeginAllowThreads();
29832 result = (int)((wxVideoMode const *)arg1)->GetWidth();
29833
29834 wxPyEndAllowThreads(__tstate);
29835 if (PyErr_Occurred()) SWIG_fail;
29836 }
29837 {
29838 resultobj = SWIG_From_int((int)(result));
29839 }
29840 return resultobj;
29841 fail:
29842 return NULL;
29843 }
29844
29845
29846 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29847 PyObject *resultobj;
29848 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29849 int result;
29850 PyObject * obj0 = 0 ;
29851 char *kwnames[] = {
29852 (char *) "self", NULL
29853 };
29854
29855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
29856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29857 if (SWIG_arg_fail(1)) SWIG_fail;
29858 {
29859 PyThreadState* __tstate = wxPyBeginAllowThreads();
29860 result = (int)((wxVideoMode const *)arg1)->GetHeight();
29861
29862 wxPyEndAllowThreads(__tstate);
29863 if (PyErr_Occurred()) SWIG_fail;
29864 }
29865 {
29866 resultobj = SWIG_From_int((int)(result));
29867 }
29868 return resultobj;
29869 fail:
29870 return NULL;
29871 }
29872
29873
29874 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
29875 PyObject *resultobj;
29876 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29877 int result;
29878 PyObject * obj0 = 0 ;
29879 char *kwnames[] = {
29880 (char *) "self", NULL
29881 };
29882
29883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
29884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29885 if (SWIG_arg_fail(1)) SWIG_fail;
29886 {
29887 PyThreadState* __tstate = wxPyBeginAllowThreads();
29888 result = (int)((wxVideoMode const *)arg1)->GetDepth();
29889
29890 wxPyEndAllowThreads(__tstate);
29891 if (PyErr_Occurred()) SWIG_fail;
29892 }
29893 {
29894 resultobj = SWIG_From_int((int)(result));
29895 }
29896 return resultobj;
29897 fail:
29898 return NULL;
29899 }
29900
29901
29902 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
29903 PyObject *resultobj;
29904 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29905 bool result;
29906 PyObject * obj0 = 0 ;
29907 char *kwnames[] = {
29908 (char *) "self", NULL
29909 };
29910
29911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
29912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29913 if (SWIG_arg_fail(1)) SWIG_fail;
29914 {
29915 PyThreadState* __tstate = wxPyBeginAllowThreads();
29916 result = (bool)((wxVideoMode const *)arg1)->IsOk();
29917
29918 wxPyEndAllowThreads(__tstate);
29919 if (PyErr_Occurred()) SWIG_fail;
29920 }
29921 {
29922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29923 }
29924 return resultobj;
29925 fail:
29926 return NULL;
29927 }
29928
29929
29930 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
29931 PyObject *resultobj;
29932 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29933 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
29934 bool result;
29935 PyObject * obj0 = 0 ;
29936 PyObject * obj1 = 0 ;
29937 char *kwnames[] = {
29938 (char *) "self",(char *) "other", NULL
29939 };
29940
29941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
29942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29943 if (SWIG_arg_fail(1)) SWIG_fail;
29944 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29945 if (SWIG_arg_fail(2)) SWIG_fail;
29946 {
29947 PyThreadState* __tstate = wxPyBeginAllowThreads();
29948 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
29949
29950 wxPyEndAllowThreads(__tstate);
29951 if (PyErr_Occurred()) SWIG_fail;
29952 }
29953 {
29954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29955 }
29956 return resultobj;
29957 fail:
29958 return NULL;
29959 }
29960
29961
29962 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
29963 PyObject *resultobj;
29964 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29965 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
29966 bool result;
29967 PyObject * obj0 = 0 ;
29968 PyObject * obj1 = 0 ;
29969 char *kwnames[] = {
29970 (char *) "self",(char *) "other", NULL
29971 };
29972
29973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
29974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29975 if (SWIG_arg_fail(1)) SWIG_fail;
29976 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
29977 if (SWIG_arg_fail(2)) SWIG_fail;
29978 {
29979 PyThreadState* __tstate = wxPyBeginAllowThreads();
29980 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
29981
29982 wxPyEndAllowThreads(__tstate);
29983 if (PyErr_Occurred()) SWIG_fail;
29984 }
29985 {
29986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29987 }
29988 return resultobj;
29989 fail:
29990 return NULL;
29991 }
29992
29993
29994 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
29995 PyObject *resultobj;
29996 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
29997 int arg2 ;
29998 PyObject * obj0 = 0 ;
29999 PyObject * obj1 = 0 ;
30000 char *kwnames[] = {
30001 (char *) "self",(char *) "w", NULL
30002 };
30003
30004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30006 if (SWIG_arg_fail(1)) SWIG_fail;
30007 {
30008 arg2 = (int)(SWIG_As_int(obj1));
30009 if (SWIG_arg_fail(2)) SWIG_fail;
30010 }
30011 if (arg1) (arg1)->w = arg2;
30012
30013 Py_INCREF(Py_None); resultobj = Py_None;
30014 return resultobj;
30015 fail:
30016 return NULL;
30017 }
30018
30019
30020 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30021 PyObject *resultobj;
30022 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30023 int result;
30024 PyObject * obj0 = 0 ;
30025 char *kwnames[] = {
30026 (char *) "self", NULL
30027 };
30028
30029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30031 if (SWIG_arg_fail(1)) SWIG_fail;
30032 result = (int) ((arg1)->w);
30033
30034 {
30035 resultobj = SWIG_From_int((int)(result));
30036 }
30037 return resultobj;
30038 fail:
30039 return NULL;
30040 }
30041
30042
30043 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30044 PyObject *resultobj;
30045 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30046 int arg2 ;
30047 PyObject * obj0 = 0 ;
30048 PyObject * obj1 = 0 ;
30049 char *kwnames[] = {
30050 (char *) "self",(char *) "h", NULL
30051 };
30052
30053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30055 if (SWIG_arg_fail(1)) SWIG_fail;
30056 {
30057 arg2 = (int)(SWIG_As_int(obj1));
30058 if (SWIG_arg_fail(2)) SWIG_fail;
30059 }
30060 if (arg1) (arg1)->h = arg2;
30061
30062 Py_INCREF(Py_None); resultobj = Py_None;
30063 return resultobj;
30064 fail:
30065 return NULL;
30066 }
30067
30068
30069 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30070 PyObject *resultobj;
30071 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30072 int result;
30073 PyObject * obj0 = 0 ;
30074 char *kwnames[] = {
30075 (char *) "self", NULL
30076 };
30077
30078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30080 if (SWIG_arg_fail(1)) SWIG_fail;
30081 result = (int) ((arg1)->h);
30082
30083 {
30084 resultobj = SWIG_From_int((int)(result));
30085 }
30086 return resultobj;
30087 fail:
30088 return NULL;
30089 }
30090
30091
30092 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30093 PyObject *resultobj;
30094 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30095 int arg2 ;
30096 PyObject * obj0 = 0 ;
30097 PyObject * obj1 = 0 ;
30098 char *kwnames[] = {
30099 (char *) "self",(char *) "bpp", NULL
30100 };
30101
30102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30104 if (SWIG_arg_fail(1)) SWIG_fail;
30105 {
30106 arg2 = (int)(SWIG_As_int(obj1));
30107 if (SWIG_arg_fail(2)) SWIG_fail;
30108 }
30109 if (arg1) (arg1)->bpp = arg2;
30110
30111 Py_INCREF(Py_None); resultobj = Py_None;
30112 return resultobj;
30113 fail:
30114 return NULL;
30115 }
30116
30117
30118 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30119 PyObject *resultobj;
30120 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30121 int result;
30122 PyObject * obj0 = 0 ;
30123 char *kwnames[] = {
30124 (char *) "self", NULL
30125 };
30126
30127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30129 if (SWIG_arg_fail(1)) SWIG_fail;
30130 result = (int) ((arg1)->bpp);
30131
30132 {
30133 resultobj = SWIG_From_int((int)(result));
30134 }
30135 return resultobj;
30136 fail:
30137 return NULL;
30138 }
30139
30140
30141 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30142 PyObject *resultobj;
30143 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30144 int arg2 ;
30145 PyObject * obj0 = 0 ;
30146 PyObject * obj1 = 0 ;
30147 char *kwnames[] = {
30148 (char *) "self",(char *) "refresh", NULL
30149 };
30150
30151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30153 if (SWIG_arg_fail(1)) SWIG_fail;
30154 {
30155 arg2 = (int)(SWIG_As_int(obj1));
30156 if (SWIG_arg_fail(2)) SWIG_fail;
30157 }
30158 if (arg1) (arg1)->refresh = arg2;
30159
30160 Py_INCREF(Py_None); resultobj = Py_None;
30161 return resultobj;
30162 fail:
30163 return NULL;
30164 }
30165
30166
30167 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30168 PyObject *resultobj;
30169 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30170 int result;
30171 PyObject * obj0 = 0 ;
30172 char *kwnames[] = {
30173 (char *) "self", NULL
30174 };
30175
30176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30178 if (SWIG_arg_fail(1)) SWIG_fail;
30179 result = (int) ((arg1)->refresh);
30180
30181 {
30182 resultobj = SWIG_From_int((int)(result));
30183 }
30184 return resultobj;
30185 fail:
30186 return NULL;
30187 }
30188
30189
30190 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30191 PyObject *obj;
30192 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30193 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30194 Py_INCREF(obj);
30195 return Py_BuildValue((char *)"");
30196 }
30197 static int _wrap_DefaultVideoMode_set(PyObject *) {
30198 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30199 return 1;
30200 }
30201
30202
30203 static PyObject *_wrap_DefaultVideoMode_get(void) {
30204 PyObject *pyobj;
30205
30206 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30207 return pyobj;
30208 }
30209
30210
30211 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30212 PyObject *resultobj;
30213 size_t arg1 = (size_t) 0 ;
30214 wxDisplay *result;
30215 PyObject * obj0 = 0 ;
30216 char *kwnames[] = {
30217 (char *) "index", NULL
30218 };
30219
30220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30221 if (obj0) {
30222 {
30223 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30224 if (SWIG_arg_fail(1)) SWIG_fail;
30225 }
30226 }
30227 {
30228 PyThreadState* __tstate = wxPyBeginAllowThreads();
30229 result = (wxDisplay *)new wxDisplay(arg1);
30230
30231 wxPyEndAllowThreads(__tstate);
30232 if (PyErr_Occurred()) SWIG_fail;
30233 }
30234 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30235 return resultobj;
30236 fail:
30237 return NULL;
30238 }
30239
30240
30241 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30242 PyObject *resultobj;
30243 wxDisplay *arg1 = (wxDisplay *) 0 ;
30244 PyObject * obj0 = 0 ;
30245 char *kwnames[] = {
30246 (char *) "self", NULL
30247 };
30248
30249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30251 if (SWIG_arg_fail(1)) SWIG_fail;
30252 {
30253 PyThreadState* __tstate = wxPyBeginAllowThreads();
30254 delete arg1;
30255
30256 wxPyEndAllowThreads(__tstate);
30257 if (PyErr_Occurred()) SWIG_fail;
30258 }
30259 Py_INCREF(Py_None); resultobj = Py_None;
30260 return resultobj;
30261 fail:
30262 return NULL;
30263 }
30264
30265
30266 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30267 PyObject *resultobj;
30268 size_t result;
30269 char *kwnames[] = {
30270 NULL
30271 };
30272
30273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30274 {
30275 PyThreadState* __tstate = wxPyBeginAllowThreads();
30276 result = (size_t)wxDisplay::GetCount();
30277
30278 wxPyEndAllowThreads(__tstate);
30279 if (PyErr_Occurred()) SWIG_fail;
30280 }
30281 {
30282 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30283 }
30284 return resultobj;
30285 fail:
30286 return NULL;
30287 }
30288
30289
30290 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30291 PyObject *resultobj;
30292 wxPoint *arg1 = 0 ;
30293 int result;
30294 wxPoint temp1 ;
30295 PyObject * obj0 = 0 ;
30296 char *kwnames[] = {
30297 (char *) "pt", NULL
30298 };
30299
30300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30301 {
30302 arg1 = &temp1;
30303 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30304 }
30305 {
30306 PyThreadState* __tstate = wxPyBeginAllowThreads();
30307 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30308
30309 wxPyEndAllowThreads(__tstate);
30310 if (PyErr_Occurred()) SWIG_fail;
30311 }
30312 {
30313 resultobj = SWIG_From_int((int)(result));
30314 }
30315 return resultobj;
30316 fail:
30317 return NULL;
30318 }
30319
30320
30321 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30322 PyObject *resultobj;
30323 wxWindow *arg1 = (wxWindow *) 0 ;
30324 int result;
30325 PyObject * obj0 = 0 ;
30326 char *kwnames[] = {
30327 (char *) "window", NULL
30328 };
30329
30330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30332 if (SWIG_arg_fail(1)) SWIG_fail;
30333 {
30334 PyThreadState* __tstate = wxPyBeginAllowThreads();
30335 result = (int)Display_GetFromWindow(arg1);
30336
30337 wxPyEndAllowThreads(__tstate);
30338 if (PyErr_Occurred()) SWIG_fail;
30339 }
30340 {
30341 resultobj = SWIG_From_int((int)(result));
30342 }
30343 return resultobj;
30344 fail:
30345 return NULL;
30346 }
30347
30348
30349 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30350 PyObject *resultobj;
30351 wxDisplay *arg1 = (wxDisplay *) 0 ;
30352 bool result;
30353 PyObject * obj0 = 0 ;
30354 char *kwnames[] = {
30355 (char *) "self", NULL
30356 };
30357
30358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30360 if (SWIG_arg_fail(1)) SWIG_fail;
30361 {
30362 PyThreadState* __tstate = wxPyBeginAllowThreads();
30363 result = (bool)((wxDisplay const *)arg1)->IsOk();
30364
30365 wxPyEndAllowThreads(__tstate);
30366 if (PyErr_Occurred()) SWIG_fail;
30367 }
30368 {
30369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30370 }
30371 return resultobj;
30372 fail:
30373 return NULL;
30374 }
30375
30376
30377 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30378 PyObject *resultobj;
30379 wxDisplay *arg1 = (wxDisplay *) 0 ;
30380 wxRect result;
30381 PyObject * obj0 = 0 ;
30382 char *kwnames[] = {
30383 (char *) "self", NULL
30384 };
30385
30386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30388 if (SWIG_arg_fail(1)) SWIG_fail;
30389 {
30390 PyThreadState* __tstate = wxPyBeginAllowThreads();
30391 result = ((wxDisplay const *)arg1)->GetGeometry();
30392
30393 wxPyEndAllowThreads(__tstate);
30394 if (PyErr_Occurred()) SWIG_fail;
30395 }
30396 {
30397 wxRect * resultptr;
30398 resultptr = new wxRect((wxRect &)(result));
30399 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30400 }
30401 return resultobj;
30402 fail:
30403 return NULL;
30404 }
30405
30406
30407 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30408 PyObject *resultobj;
30409 wxDisplay *arg1 = (wxDisplay *) 0 ;
30410 wxString result;
30411 PyObject * obj0 = 0 ;
30412 char *kwnames[] = {
30413 (char *) "self", NULL
30414 };
30415
30416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30418 if (SWIG_arg_fail(1)) SWIG_fail;
30419 {
30420 PyThreadState* __tstate = wxPyBeginAllowThreads();
30421 result = ((wxDisplay const *)arg1)->GetName();
30422
30423 wxPyEndAllowThreads(__tstate);
30424 if (PyErr_Occurred()) SWIG_fail;
30425 }
30426 {
30427 #if wxUSE_UNICODE
30428 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30429 #else
30430 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30431 #endif
30432 }
30433 return resultobj;
30434 fail:
30435 return NULL;
30436 }
30437
30438
30439 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30440 PyObject *resultobj;
30441 wxDisplay *arg1 = (wxDisplay *) 0 ;
30442 bool result;
30443 PyObject * obj0 = 0 ;
30444 char *kwnames[] = {
30445 (char *) "self", NULL
30446 };
30447
30448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30450 if (SWIG_arg_fail(1)) SWIG_fail;
30451 {
30452 PyThreadState* __tstate = wxPyBeginAllowThreads();
30453 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30454
30455 wxPyEndAllowThreads(__tstate);
30456 if (PyErr_Occurred()) SWIG_fail;
30457 }
30458 {
30459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30460 }
30461 return resultobj;
30462 fail:
30463 return NULL;
30464 }
30465
30466
30467 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30468 PyObject *resultobj;
30469 wxDisplay *arg1 = (wxDisplay *) 0 ;
30470 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30471 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30472 PyObject *result;
30473 PyObject * obj0 = 0 ;
30474 PyObject * obj1 = 0 ;
30475 char *kwnames[] = {
30476 (char *) "self",(char *) "mode", NULL
30477 };
30478
30479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30481 if (SWIG_arg_fail(1)) SWIG_fail;
30482 if (obj1) {
30483 {
30484 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30485 if (SWIG_arg_fail(2)) SWIG_fail;
30486 if (arg2 == NULL) {
30487 SWIG_null_ref("wxVideoMode");
30488 }
30489 if (SWIG_arg_fail(2)) SWIG_fail;
30490 }
30491 }
30492 {
30493 PyThreadState* __tstate = wxPyBeginAllowThreads();
30494 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30495
30496 wxPyEndAllowThreads(__tstate);
30497 if (PyErr_Occurred()) SWIG_fail;
30498 }
30499 resultobj = result;
30500 return resultobj;
30501 fail:
30502 return NULL;
30503 }
30504
30505
30506 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30507 PyObject *resultobj;
30508 wxDisplay *arg1 = (wxDisplay *) 0 ;
30509 wxVideoMode result;
30510 PyObject * obj0 = 0 ;
30511 char *kwnames[] = {
30512 (char *) "self", NULL
30513 };
30514
30515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30517 if (SWIG_arg_fail(1)) SWIG_fail;
30518 {
30519 PyThreadState* __tstate = wxPyBeginAllowThreads();
30520 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30521
30522 wxPyEndAllowThreads(__tstate);
30523 if (PyErr_Occurred()) SWIG_fail;
30524 }
30525 {
30526 wxVideoMode * resultptr;
30527 resultptr = new wxVideoMode((wxVideoMode &)(result));
30528 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30529 }
30530 return resultobj;
30531 fail:
30532 return NULL;
30533 }
30534
30535
30536 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30537 PyObject *resultobj;
30538 wxDisplay *arg1 = (wxDisplay *) 0 ;
30539 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30540 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30541 bool result;
30542 PyObject * obj0 = 0 ;
30543 PyObject * obj1 = 0 ;
30544 char *kwnames[] = {
30545 (char *) "self",(char *) "mode", NULL
30546 };
30547
30548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30550 if (SWIG_arg_fail(1)) SWIG_fail;
30551 if (obj1) {
30552 {
30553 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30554 if (SWIG_arg_fail(2)) SWIG_fail;
30555 if (arg2 == NULL) {
30556 SWIG_null_ref("wxVideoMode");
30557 }
30558 if (SWIG_arg_fail(2)) SWIG_fail;
30559 }
30560 }
30561 {
30562 PyThreadState* __tstate = wxPyBeginAllowThreads();
30563 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30564
30565 wxPyEndAllowThreads(__tstate);
30566 if (PyErr_Occurred()) SWIG_fail;
30567 }
30568 {
30569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30570 }
30571 return resultobj;
30572 fail:
30573 return NULL;
30574 }
30575
30576
30577 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30578 PyObject *resultobj;
30579 wxDisplay *arg1 = (wxDisplay *) 0 ;
30580 PyObject * obj0 = 0 ;
30581 char *kwnames[] = {
30582 (char *) "self", NULL
30583 };
30584
30585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30587 if (SWIG_arg_fail(1)) SWIG_fail;
30588 {
30589 PyThreadState* __tstate = wxPyBeginAllowThreads();
30590 (arg1)->ResetMode();
30591
30592 wxPyEndAllowThreads(__tstate);
30593 if (PyErr_Occurred()) SWIG_fail;
30594 }
30595 Py_INCREF(Py_None); resultobj = Py_None;
30596 return resultobj;
30597 fail:
30598 return NULL;
30599 }
30600
30601
30602 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30603 PyObject *obj;
30604 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30605 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30606 Py_INCREF(obj);
30607 return Py_BuildValue((char *)"");
30608 }
30609 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30610 PyObject *resultobj;
30611 wxStandardPaths *result;
30612 char *kwnames[] = {
30613 NULL
30614 };
30615
30616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
30617 {
30618 PyThreadState* __tstate = wxPyBeginAllowThreads();
30619 result = (wxStandardPaths *)StandardPaths_Get();
30620
30621 wxPyEndAllowThreads(__tstate);
30622 if (PyErr_Occurred()) SWIG_fail;
30623 }
30624 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
30625 return resultobj;
30626 fail:
30627 return NULL;
30628 }
30629
30630
30631 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30632 PyObject *resultobj;
30633 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30634 wxString result;
30635 PyObject * obj0 = 0 ;
30636 char *kwnames[] = {
30637 (char *) "self", NULL
30638 };
30639
30640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
30641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30642 if (SWIG_arg_fail(1)) SWIG_fail;
30643 {
30644 PyThreadState* __tstate = wxPyBeginAllowThreads();
30645 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
30646
30647 wxPyEndAllowThreads(__tstate);
30648 if (PyErr_Occurred()) SWIG_fail;
30649 }
30650 {
30651 #if wxUSE_UNICODE
30652 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30653 #else
30654 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30655 #endif
30656 }
30657 return resultobj;
30658 fail:
30659 return NULL;
30660 }
30661
30662
30663 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30664 PyObject *resultobj;
30665 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30666 wxString result;
30667 PyObject * obj0 = 0 ;
30668 char *kwnames[] = {
30669 (char *) "self", NULL
30670 };
30671
30672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
30673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30674 if (SWIG_arg_fail(1)) SWIG_fail;
30675 {
30676 PyThreadState* __tstate = wxPyBeginAllowThreads();
30677 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
30678
30679 wxPyEndAllowThreads(__tstate);
30680 if (PyErr_Occurred()) SWIG_fail;
30681 }
30682 {
30683 #if wxUSE_UNICODE
30684 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30685 #else
30686 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30687 #endif
30688 }
30689 return resultobj;
30690 fail:
30691 return NULL;
30692 }
30693
30694
30695 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30696 PyObject *resultobj;
30697 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30698 wxString result;
30699 PyObject * obj0 = 0 ;
30700 char *kwnames[] = {
30701 (char *) "self", NULL
30702 };
30703
30704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
30705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30706 if (SWIG_arg_fail(1)) SWIG_fail;
30707 {
30708 PyThreadState* __tstate = wxPyBeginAllowThreads();
30709 result = ((wxStandardPaths const *)arg1)->GetDataDir();
30710
30711 wxPyEndAllowThreads(__tstate);
30712 if (PyErr_Occurred()) SWIG_fail;
30713 }
30714 {
30715 #if wxUSE_UNICODE
30716 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30717 #else
30718 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30719 #endif
30720 }
30721 return resultobj;
30722 fail:
30723 return NULL;
30724 }
30725
30726
30727 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30728 PyObject *resultobj;
30729 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30730 wxString result;
30731 PyObject * obj0 = 0 ;
30732 char *kwnames[] = {
30733 (char *) "self", NULL
30734 };
30735
30736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
30737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30738 if (SWIG_arg_fail(1)) SWIG_fail;
30739 {
30740 PyThreadState* __tstate = wxPyBeginAllowThreads();
30741 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
30742
30743 wxPyEndAllowThreads(__tstate);
30744 if (PyErr_Occurred()) SWIG_fail;
30745 }
30746 {
30747 #if wxUSE_UNICODE
30748 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30749 #else
30750 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30751 #endif
30752 }
30753 return resultobj;
30754 fail:
30755 return NULL;
30756 }
30757
30758
30759 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30760 PyObject *resultobj;
30761 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30762 wxString result;
30763 PyObject * obj0 = 0 ;
30764 char *kwnames[] = {
30765 (char *) "self", NULL
30766 };
30767
30768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
30769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30770 if (SWIG_arg_fail(1)) SWIG_fail;
30771 {
30772 PyThreadState* __tstate = wxPyBeginAllowThreads();
30773 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
30774
30775 wxPyEndAllowThreads(__tstate);
30776 if (PyErr_Occurred()) SWIG_fail;
30777 }
30778 {
30779 #if wxUSE_UNICODE
30780 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30781 #else
30782 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30783 #endif
30784 }
30785 return resultobj;
30786 fail:
30787 return NULL;
30788 }
30789
30790
30791 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
30792 PyObject *resultobj;
30793 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30794 wxString result;
30795 PyObject * obj0 = 0 ;
30796 char *kwnames[] = {
30797 (char *) "self", NULL
30798 };
30799
30800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
30801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30802 if (SWIG_arg_fail(1)) SWIG_fail;
30803 {
30804 PyThreadState* __tstate = wxPyBeginAllowThreads();
30805 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
30806
30807 wxPyEndAllowThreads(__tstate);
30808 if (PyErr_Occurred()) SWIG_fail;
30809 }
30810 {
30811 #if wxUSE_UNICODE
30812 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30813 #else
30814 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30815 #endif
30816 }
30817 return resultobj;
30818 fail:
30819 return NULL;
30820 }
30821
30822
30823 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
30824 PyObject *resultobj;
30825 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30826 wxString result;
30827 PyObject * obj0 = 0 ;
30828 char *kwnames[] = {
30829 (char *) "self", NULL
30830 };
30831
30832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
30833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30834 if (SWIG_arg_fail(1)) SWIG_fail;
30835 {
30836 PyThreadState* __tstate = wxPyBeginAllowThreads();
30837 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
30838
30839 wxPyEndAllowThreads(__tstate);
30840 if (PyErr_Occurred()) SWIG_fail;
30841 }
30842 {
30843 #if wxUSE_UNICODE
30844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30845 #else
30846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30847 #endif
30848 }
30849 return resultobj;
30850 fail:
30851 return NULL;
30852 }
30853
30854
30855 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
30856 PyObject *resultobj;
30857 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30858 wxString *arg2 = 0 ;
30859 bool temp2 = false ;
30860 PyObject * obj0 = 0 ;
30861 PyObject * obj1 = 0 ;
30862 char *kwnames[] = {
30863 (char *) "self",(char *) "prefix", NULL
30864 };
30865
30866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
30867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30868 if (SWIG_arg_fail(1)) SWIG_fail;
30869 {
30870 arg2 = wxString_in_helper(obj1);
30871 if (arg2 == NULL) SWIG_fail;
30872 temp2 = true;
30873 }
30874 {
30875 PyThreadState* __tstate = wxPyBeginAllowThreads();
30876 (arg1)->SetInstallPrefix((wxString const &)*arg2);
30877
30878 wxPyEndAllowThreads(__tstate);
30879 if (PyErr_Occurred()) SWIG_fail;
30880 }
30881 Py_INCREF(Py_None); resultobj = Py_None;
30882 {
30883 if (temp2)
30884 delete arg2;
30885 }
30886 return resultobj;
30887 fail:
30888 {
30889 if (temp2)
30890 delete arg2;
30891 }
30892 return NULL;
30893 }
30894
30895
30896 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
30897 PyObject *resultobj;
30898 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30899 wxString result;
30900 PyObject * obj0 = 0 ;
30901 char *kwnames[] = {
30902 (char *) "self", NULL
30903 };
30904
30905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
30906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30907 if (SWIG_arg_fail(1)) SWIG_fail;
30908 {
30909 PyThreadState* __tstate = wxPyBeginAllowThreads();
30910 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
30911
30912 wxPyEndAllowThreads(__tstate);
30913 if (PyErr_Occurred()) SWIG_fail;
30914 }
30915 {
30916 #if wxUSE_UNICODE
30917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30918 #else
30919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30920 #endif
30921 }
30922 return resultobj;
30923 fail:
30924 return NULL;
30925 }
30926
30927
30928 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
30929 PyObject *obj;
30930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30931 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
30932 Py_INCREF(obj);
30933 return Py_BuildValue((char *)"");
30934 }
30935 static PyMethodDef SwigMethods[] = {
30936 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
30937 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
30938 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
30939 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
30940 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
30941 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
30942 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
30943 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
30944 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
30945 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
30946 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
30947 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
30948 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
30949 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
30950 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
30951 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
30952 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
30953 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
30954 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
30955 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
30956 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
30957 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
30958 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
30959 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
30960 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
30961 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
30962 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
30963 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
30964 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
30965 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
30966 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
30967 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
30968 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
30969 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
30970 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
30971 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
30972 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
30973 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
30974 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
30975 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
30976 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
30977 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
30978 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
30979 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
30980 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
30981 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
30982 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
30983 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
30984 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
30985 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
30986 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
30987 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
30988 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
30989 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
30990 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
30991 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
30992 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
30993 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
30994 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
30995 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
30996 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
30997 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
30998 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
30999 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31000 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31001 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31002 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31003 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31004 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31005 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31006 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31007 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31008 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31009 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31010 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31011 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31012 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31013 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31014 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31015 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31016 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31017 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31018 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31019 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31020 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31021 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31022 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31023 { (char *)"delete_Caret", (PyCFunction) _wrap_delete_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31024 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31025 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31026 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31027 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31028 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31029 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31030 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31031 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31032 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31033 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31034 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31035 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31036 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31037 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31038 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31039 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31040 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31041 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31042 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31043 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31044 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31045 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31046 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31047 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31048 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31049 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31050 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31051 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31052 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31053 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31054 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31055 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31056 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31057 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31058 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31059 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31060 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31061 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31062 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31063 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31064 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31065 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31066 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31067 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31068 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31069 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31070 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31071 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31072 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31073 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31074 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31075 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31076 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31077 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31078 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31079 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31080 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31081 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31082 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31083 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31084 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31085 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31086 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31087 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31088 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31089 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31090 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31091 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31092 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31093 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31094 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31095 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31096 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31097 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31098 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31099 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31100 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31101 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31102 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31103 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31104 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31105 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31106 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31107 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31108 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31109 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31110 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31111 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31112 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31113 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31114 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31115 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31116 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31117 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31118 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31119 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31120 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31121 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31122 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31123 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31124 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31125 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31126 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31127 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31128 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31129 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31130 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31131 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31132 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31133 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31134 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31135 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31136 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31137 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31138 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31139 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31140 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31141 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31142 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31143 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31144 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31145 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31146 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31147 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31148 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31149 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31150 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31151 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31152 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31153 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31154 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31155 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31156 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31157 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31158 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31159 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31160 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31161 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31162 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31163 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31164 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31165 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31166 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31167 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31168 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31169 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31170 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31171 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31172 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31173 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31174 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31175 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31176 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31177 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31178 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31179 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31180 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31181 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31182 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31183 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31184 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31185 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31186 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31187 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31188 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31189 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31190 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31191 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31192 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31193 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31194 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31195 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31196 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31197 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31198 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31199 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31200 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31201 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31202 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31203 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31204 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31205 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31206 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31207 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31208 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31209 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31210 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31211 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31212 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31213 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31214 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31215 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31216 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31217 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31218 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31219 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31220 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31221 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31222 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31223 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31224 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31225 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31226 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31227 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31228 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31229 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31230 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31231 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31232 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31233 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31234 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31235 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31236 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31237 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31238 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31239 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31240 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31241 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31242 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31243 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31244 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31245 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31246 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31247 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31248 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31249 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31250 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31251 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31252 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31253 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31254 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31255 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31256 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31257 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31258 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31259 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31260 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31261 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31262 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31263 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31264 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31265 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31266 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31267 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31268 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31269 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31270 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31271 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31272 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31273 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31274 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31275 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31276 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31277 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31278 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31279 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31280 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31281 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31282 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31283 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31284 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31285 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31286 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31287 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31288 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31289 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31290 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31291 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31292 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31293 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31294 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31295 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31296 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31297 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31299 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31300 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31301 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31302 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31303 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31304 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31305 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31306 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31307 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31308 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31309 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31311 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31312 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31313 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31314 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31315 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31316 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31317 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31318 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31319 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31320 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31321 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31322 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31323 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31325 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31326 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31329 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31331 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31333 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31338 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31339 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31342 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31369 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31372 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31375 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31379 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31472 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31473 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31474 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31475 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31492 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31537 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31571 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31579 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31580 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31585 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31594 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31601 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31604 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31607 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
31612 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
31615 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
31619 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
31622 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
31626 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
31627 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
31631 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
31635 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
31637 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
31647 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
31658 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
31666 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
31674 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
31688 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
31692 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
31710 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
31724 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
31735 { NULL, NULL, 0, NULL }
31736 };
31737
31738
31739 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
31740
31741 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
31742 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
31743 }
31744 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
31745 return (void *)((wxEvent *) ((wxMenuEvent *) x));
31746 }
31747 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
31748 return (void *)((wxEvent *) ((wxCloseEvent *) x));
31749 }
31750 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
31751 return (void *)((wxEvent *) ((wxMouseEvent *) x));
31752 }
31753 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
31754 return (void *)((wxEvent *) ((wxEraseEvent *) x));
31755 }
31756 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
31757 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
31758 }
31759 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
31760 return (void *)((wxEvent *) ((wxTimerEvent *) x));
31761 }
31762 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
31763 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
31764 }
31765 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
31766 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
31767 }
31768 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
31769 return (void *)((wxEvent *) ((wxPyEvent *) x));
31770 }
31771 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
31772 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
31773 }
31774 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
31775 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
31776 }
31777 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
31778 return (void *)((wxEvent *) ((wxIdleEvent *) x));
31779 }
31780 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
31781 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
31782 }
31783 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
31784 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
31785 }
31786 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
31787 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
31788 }
31789 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
31790 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
31791 }
31792 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
31793 return (void *)((wxEvent *) ((wxActivateEvent *) x));
31794 }
31795 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
31796 return (void *)((wxEvent *) ((wxSizeEvent *) x));
31797 }
31798 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
31799 return (void *)((wxEvent *) ((wxMoveEvent *) x));
31800 }
31801 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
31802 return (void *)((wxEvent *) ((wxPaintEvent *) x));
31803 }
31804 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
31805 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
31806 }
31807 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
31808 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
31809 }
31810 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
31811 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
31812 }
31813 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
31814 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
31815 }
31816 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
31817 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
31818 }
31819 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
31820 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
31821 }
31822 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
31823 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
31824 }
31825 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
31826 return (void *)((wxEvent *) ((wxFocusEvent *) x));
31827 }
31828 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
31829 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
31830 }
31831 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
31832 return (void *)((wxEvent *) ((wxProcessEvent *) x));
31833 }
31834 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
31835 return (void *)((wxEvent *) ((wxShowEvent *) x));
31836 }
31837 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
31838 return (void *)((wxEvent *) ((wxCommandEvent *) x));
31839 }
31840 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
31841 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
31842 }
31843 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
31844 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
31845 }
31846 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
31847 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
31848 }
31849 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
31850 return (void *)((wxEvent *) ((wxKeyEvent *) x));
31851 }
31852 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
31853 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
31854 }
31855 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
31856 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
31857 }
31858 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
31859 return (void *)((wxConfigBase *) ((wxConfig *) x));
31860 }
31861 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
31862 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31863 }
31864 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
31865 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
31866 }
31867 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
31868 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
31869 }
31870 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
31871 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
31872 }
31873 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
31874 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
31875 }
31876 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
31877 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
31878 }
31879 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
31880 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
31881 }
31882 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
31883 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
31884 }
31885 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
31886 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31887 }
31888 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
31889 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
31890 }
31891 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
31892 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
31893 }
31894 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
31895 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
31896 }
31897 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
31898 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
31899 }
31900 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
31901 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
31902 }
31903 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
31904 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
31905 }
31906 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
31907 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
31908 }
31909 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
31910 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
31911 }
31912 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
31913 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
31914 }
31915 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
31916 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
31917 }
31918 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
31919 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
31920 }
31921 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
31922 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
31923 }
31924 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
31925 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
31926 }
31927 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
31928 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
31929 }
31930 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
31931 return (void *)((wxEvtHandler *) ((wxWindow *) x));
31932 }
31933 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
31934 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
31935 }
31936 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
31937 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
31938 }
31939 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
31940 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
31941 }
31942 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
31943 return (void *)((wxEvtHandler *) ((wxValidator *) x));
31944 }
31945 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
31946 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
31947 }
31948 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
31949 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
31950 }
31951 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
31952 return (void *)((wxEvtHandler *) ((wxMenu *) x));
31953 }
31954 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
31955 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
31956 }
31957 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
31958 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
31959 }
31960 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
31961 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
31962 }
31963 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
31964 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
31965 }
31966 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
31967 return (void *)((wxObject *) ((wxSizerItem *) x));
31968 }
31969 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
31970 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
31971 }
31972 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
31973 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
31974 }
31975 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
31976 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
31977 }
31978 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
31979 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
31980 }
31981 static void *_p_wxSizerTo_p_wxObject(void *x) {
31982 return (void *)((wxObject *) ((wxSizer *) x));
31983 }
31984 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
31985 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
31986 }
31987 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
31988 return (void *)((wxObject *) ((wxFileHistory *) x));
31989 }
31990 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
31991 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
31992 }
31993 static void *_p_wxEventTo_p_wxObject(void *x) {
31994 return (void *)((wxObject *) ((wxEvent *) x));
31995 }
31996 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
31997 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
31998 }
31999 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32000 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32001 }
32002 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32003 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32004 }
32005 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32006 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32007 }
32008 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32009 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32010 }
32011 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32012 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32013 }
32014 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32015 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32016 }
32017 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32018 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32019 }
32020 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32021 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32022 }
32023 static void *_p_wxControlTo_p_wxObject(void *x) {
32024 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32025 }
32026 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32027 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32028 }
32029 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32030 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32031 }
32032 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32033 return (void *)((wxObject *) ((wxFSFile *) x));
32034 }
32035 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32036 return (void *)((wxObject *) ((wxClipboard *) x));
32037 }
32038 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32039 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32040 }
32041 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32042 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32043 }
32044 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32045 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32046 }
32047 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32048 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32049 }
32050 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32051 return (void *)((wxObject *) ((wxToolTip *) x));
32052 }
32053 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32054 return (void *)((wxObject *) ((wxMenuItem *) x));
32055 }
32056 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32057 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32058 }
32059 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32060 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32061 }
32062 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32063 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32064 }
32065 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32066 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32067 }
32068 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32069 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32070 }
32071 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32072 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32073 }
32074 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32075 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32076 }
32077 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32078 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32079 }
32080 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32081 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32082 }
32083 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32084 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32085 }
32086 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32087 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32088 }
32089 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32090 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32091 }
32092 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32093 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32094 }
32095 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32096 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32097 }
32098 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32099 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32100 }
32101 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32102 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32103 }
32104 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32105 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32106 }
32107 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32108 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32109 }
32110 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32111 return (void *)((wxObject *) ((wxImageHandler *) x));
32112 }
32113 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32114 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32115 }
32116 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32117 return (void *)((wxObject *) ((wxEvtHandler *) x));
32118 }
32119 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32120 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32121 }
32122 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32123 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32124 }
32125 static void *_p_wxImageTo_p_wxObject(void *x) {
32126 return (void *)((wxObject *) ((wxImage *) x));
32127 }
32128 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32129 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32130 }
32131 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32132 return (void *)((wxObject *) ((wxSystemOptions *) x));
32133 }
32134 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32135 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32136 }
32137 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32138 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32139 }
32140 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32141 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32142 }
32143 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32144 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32145 }
32146 static void *_p_wxWindowTo_p_wxObject(void *x) {
32147 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32148 }
32149 static void *_p_wxMenuTo_p_wxObject(void *x) {
32150 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32151 }
32152 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32153 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32154 }
32155 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32156 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32157 }
32158 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32159 return (void *)((wxObject *) ((wxFileSystem *) x));
32160 }
32161 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32162 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32163 }
32164 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32165 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32166 }
32167 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32168 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32169 }
32170 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32171 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32172 }
32173 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32174 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32175 }
32176 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32177 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32178 }
32179 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32180 return (void *)((wxObject *) ((wxBusyInfo *) x));
32181 }
32182 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32183 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32184 }
32185 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32186 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32187 }
32188 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32189 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32190 }
32191 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32192 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32193 }
32194 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32195 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32196 }
32197 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32198 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32199 }
32200 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32201 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32202 }
32203 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32204 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32205 }
32206 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32207 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32208 }
32209 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32210 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32211 }
32212 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32213 return (void *)((wxLog *) ((wxLogStderr *) x));
32214 }
32215 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32216 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32217 }
32218 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32219 return (void *)((wxLog *) ((wxLogWindow *) x));
32220 }
32221 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32222 return (void *)((wxLog *) ((wxLogChain *) x));
32223 }
32224 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32225 return (void *)((wxLog *) ((wxLogGui *) x));
32226 }
32227 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32228 return (void *)((wxLog *) ((wxPyLog *) x));
32229 }
32230 static void *_p_wxControlTo_p_wxWindow(void *x) {
32231 return (void *)((wxWindow *) ((wxControl *) x));
32232 }
32233 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32234 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32235 }
32236 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32237 return (void *)((wxWindow *) ((wxMenuBar *) x));
32238 }
32239 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32240 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32241 }
32242 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32243 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32244 }
32245 static swig_type_info _swigt__p_wxLogChain[] = {{"_p_wxLogChain", 0, "wxLogChain *", 0, 0, 0, 0},{"_p_wxLogChain", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32246 static swig_type_info _swigt__p_wxMutexGuiLocker[] = {{"_p_wxMutexGuiLocker", 0, "wxMutexGuiLocker *", 0, 0, 0, 0},{"_p_wxMutexGuiLocker", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32247 static swig_type_info _swigt__p_wxFileHistory[] = {{"_p_wxFileHistory", 0, "wxFileHistory *", 0, 0, 0, 0},{"_p_wxFileHistory", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32248 static swig_type_info _swigt__p_wxLog[] = {{"_p_wxLog", 0, "wxLog *", 0, 0, 0, 0},{"_p_wxLogStderr", _p_wxLogStderrTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogTextCtrl", _p_wxLogTextCtrlTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogWindow", _p_wxLogWindowTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogChain", _p_wxLogChainTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLogGui", _p_wxLogGuiTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxPyLog", _p_wxPyLogTo_p_wxLog, 0, 0, 0, 0, 0},{"_p_wxLog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32249 static swig_type_info _swigt__p_wxMenu[] = {{"_p_wxMenu", 0, "wxMenu *", 0, 0, 0, 0},{"_p_wxMenu", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32250 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32251 static swig_type_info _swigt__p_wxDateTime__TimeZone[] = {{"_p_wxDateTime__TimeZone", 0, "wxDateTime::TimeZone *", 0, 0, 0, 0},{"_p_wxDateTime__TimeZone", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32252 static swig_type_info _swigt__p_wxConfigBase[] = {{"_p_wxConfigBase", 0, "wxConfigBase *", 0, 0, 0, 0},{"_p_wxFileConfig", _p_wxFileConfigTo_p_wxConfigBase, 0, 0, 0, 0, 0},{"_p_wxConfigBase", 0, 0, 0, 0, 0, 0},{"_p_wxConfig", _p_wxConfigTo_p_wxConfigBase, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32253 static swig_type_info _swigt__p_wxDisplay[] = {{"_p_wxDisplay", 0, "wxDisplay *", 0, 0, 0, 0},{"_p_wxDisplay", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32254 static swig_type_info _swigt__p_wxFileType[] = {{"_p_wxFileType", 0, "wxFileType *", 0, 0, 0, 0},{"_p_wxFileType", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32255 static swig_type_info _swigt__p_wxLogGui[] = {{"_p_wxLogGui", 0, "wxLogGui *", 0, 0, 0, 0},{"_p_wxLogGui", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32256 static swig_type_info _swigt__p_wxFont[] = {{"_p_wxFont", 0, "wxFont *", 0, 0, 0, 0},{"_p_wxFont", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32257 static swig_type_info _swigt__p_wxDataFormat[] = {{"_p_wxDataFormat", 0, "wxDataFormat *", 0, 0, 0, 0},{"_p_wxDataFormat", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32258 static swig_type_info _swigt__p_wxTimerEvent[] = {{"_p_wxTimerEvent", 0, "wxTimerEvent *", 0, 0, 0, 0},{"_p_wxTimerEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32259 static swig_type_info _swigt__p_wxCaret[] = {{"_p_wxCaret", 0, "wxCaret *", 0, 0, 0, 0},{"_p_wxCaret", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32260 static swig_type_info _swigt__ptrdiff_t[] = {{"_ptrdiff_t", 0, "ptrdiff_t", 0, 0, 0, 0},{"_ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32261 static swig_type_info _swigt__std__ptrdiff_t[] = {{"_std__ptrdiff_t", 0, "std::ptrdiff_t", 0, 0, 0, 0},{"_std__ptrdiff_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32262 static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int *", 0, 0, 0, 0},{"_p_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32263 static swig_type_info _swigt__p_wxSize[] = {{"_p_wxSize", 0, "wxSize *", 0, 0, 0, 0},{"_p_wxSize", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32264 static swig_type_info _swigt__p_wxClipboard[] = {{"_p_wxClipboard", 0, "wxClipboard *", 0, 0, 0, 0},{"_p_wxClipboard", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32265 static swig_type_info _swigt__p_wxStopWatch[] = {{"_p_wxStopWatch", 0, "wxStopWatch *", 0, 0, 0, 0},{"_p_wxStopWatch", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32266 static swig_type_info _swigt__p_wxClipboardLocker[] = {{"_p_wxClipboardLocker", 0, "wxClipboardLocker *", 0, 0, 0, 0},{"_p_wxClipboardLocker", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32267 static swig_type_info _swigt__p_wxIcon[] = {{"_p_wxIcon", 0, "wxIcon *", 0, 0, 0, 0},{"_p_wxIcon", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32268 static swig_type_info _swigt__p_wxLogStderr[] = {{"_p_wxLogStderr", 0, "wxLogStderr *", 0, 0, 0, 0},{"_p_wxLogStderr", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32269 static swig_type_info _swigt__p_wxLogTextCtrl[] = {{"_p_wxLogTextCtrl", 0, "wxLogTextCtrl *", 0, 0, 0, 0},{"_p_wxLogTextCtrl", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32270 static swig_type_info _swigt__p_wxTextCtrl[] = {{"_p_wxTextCtrl", 0, "wxTextCtrl *", 0, 0, 0, 0},{"_p_wxTextCtrl", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32271 static swig_type_info _swigt__p_wxBusyCursor[] = {{"_p_wxBusyCursor", 0, "wxBusyCursor *", 0, 0, 0, 0},{"_p_wxBusyCursor", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32272 static swig_type_info _swigt__p_wxBitmapDataObject[] = {{"_p_wxBitmapDataObject", 0, "wxBitmapDataObject *", 0, 0, 0, 0},{"_p_wxBitmapDataObject", 0, 0, 0, 0, 0, 0},{"_p_wxPyBitmapDataObject", _p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32273 static swig_type_info _swigt__p_wxTextDataObject[] = {{"_p_wxTextDataObject", 0, "wxTextDataObject *", 0, 0, 0, 0},{"_p_wxTextDataObject", 0, 0, 0, 0, 0, 0},{"_p_wxPyTextDataObject", _p_wxPyTextDataObjectTo_p_wxTextDataObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32274 static swig_type_info _swigt__p_wxDataObject[] = {{"_p_wxDataObject", 0, "wxDataObject *", 0, 0, 0, 0},{"_p_wxDataObjectSimple", _p_wxDataObjectSimpleTo_p_wxDataObject, 0, 0, 0, 0, 0},{"_p_wxPyDataObjectSimple", _p_wxPyDataObjectSimpleTo_p_wxDataObject, 0, 0, 0, 0, 0},{"_p_wxDataObjectComposite", _p_wxDataObjectCompositeTo_p_wxDataObject, 0, 0, 0, 0, 0},{"_p_wxDataObject", 0, 0, 0, 0, 0, 0},{"_p_wxTextDataObject", _p_wxTextDataObjectTo_p_wxDataObject, 0, 0, 0, 0, 0},{"_p_wxPyTextDataObject", _p_wxPyTextDataObjectTo_p_wxDataObject, 0, 0, 0, 0, 0},{"_p_wxBitmapDataObject", _p_wxBitmapDataObjectTo_p_wxDataObject, 0, 0, 0, 0, 0},{"_p_wxPyBitmapDataObject", _p_wxPyBitmapDataObjectTo_p_wxDataObject, 0, 0, 0, 0, 0},{"_p_wxFileDataObject", _p_wxFileDataObjectTo_p_wxDataObject, 0, 0, 0, 0, 0},{"_p_wxCustomDataObject", _p_wxCustomDataObjectTo_p_wxDataObject, 0, 0, 0, 0, 0},{"_p_wxMetafileDataObject", _p_wxMetafileDataObjectTo_p_wxDataObject, 0, 0, 0, 0, 0},{"_p_wxURLDataObject", _p_wxURLDataObjectTo_p_wxDataObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32275 static swig_type_info _swigt__p_wxPyTextDataObject[] = {{"_p_wxPyTextDataObject", 0, "wxPyTextDataObject *", 0, 0, 0, 0},{"_p_wxPyTextDataObject", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32276 static swig_type_info _swigt__p_wxPyBitmapDataObject[] = {{"_p_wxPyBitmapDataObject", 0, "wxPyBitmapDataObject *", 0, 0, 0, 0},{"_p_wxPyBitmapDataObject", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32277 static swig_type_info _swigt__p_wxFileDataObject[] = {{"_p_wxFileDataObject", 0, "wxFileDataObject *", 0, 0, 0, 0},{"_p_wxFileDataObject", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32278 static swig_type_info _swigt__p_wxCustomDataObject[] = {{"_p_wxCustomDataObject", 0, "wxCustomDataObject *", 0, 0, 0, 0},{"_p_wxCustomDataObject", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32279 static swig_type_info _swigt__p_wxURLDataObject[] = {{"_p_wxURLDataObject", 0, "wxURLDataObject *", 0, 0, 0, 0},{"_p_wxURLDataObject", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32280 static swig_type_info _swigt__p_wxMetafileDataObject[] = {{"_p_wxMetafileDataObject", 0, "wxMetafileDataObject *", 0, 0, 0, 0},{"_p_wxMetafileDataObject", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32281 static swig_type_info _swigt__p_wxSound[] = {{"_p_wxSound", 0, "wxSound *", 0, 0, 0, 0},{"_p_wxSound", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32282 static swig_type_info _swigt__p_wxTimerRunner[] = {{"_p_wxTimerRunner", 0, "wxTimerRunner *", 0, 0, 0, 0},{"_p_wxTimerRunner", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32283 static swig_type_info _swigt__p_wxLogWindow[] = {{"_p_wxLogWindow", 0, "wxLogWindow *", 0, 0, 0, 0},{"_p_wxLogWindow", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32284 static swig_type_info _swigt__p_wxTimeSpan[] = {{"_p_wxTimeSpan", 0, "wxTimeSpan *", 0, 0, 0, 0},{"_p_wxTimeSpan", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32285 static swig_type_info _swigt__p_wxArrayString[] = {{"_p_wxArrayString", 0, "wxArrayString *", 0, 0, 0, 0},{"_p_wxArrayString", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32286 static swig_type_info _swigt__p_wxWindowDisabler[] = {{"_p_wxWindowDisabler", 0, "wxWindowDisabler *", 0, 0, 0, 0},{"_p_wxWindowDisabler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32287 static swig_type_info _swigt__p_form_ops_t[] = {{"_p_form_ops_t", 0, "enum form_ops_t *|form_ops_t *", 0, 0, 0, 0},{"_p_form_ops_t", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32288 static swig_type_info _swigt__p_wxToolTip[] = {{"_p_wxToolTip", 0, "wxToolTip *", 0, 0, 0, 0},{"_p_wxToolTip", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32289 static swig_type_info _swigt__p_wxDataObjectComposite[] = {{"_p_wxDataObjectComposite", 0, "wxDataObjectComposite *", 0, 0, 0, 0},{"_p_wxDataObjectComposite", 0, 0, 0, 0, 0, 0},{"_p_wxURLDataObject", _p_wxURLDataObjectTo_p_wxDataObjectComposite, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32290 static swig_type_info _swigt__p_wxFileConfig[] = {{"_p_wxFileConfig", 0, "wxFileConfig *", 0, 0, 0, 0},{"_p_wxFileConfig", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32291 static swig_type_info _swigt__p_wxSystemSettings[] = {{"_p_wxSystemSettings", 0, "wxSystemSettings *", 0, 0, 0, 0},{"_p_wxSystemSettings", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32292 static swig_type_info _swigt__p_wxVideoMode[] = {{"_p_wxVideoMode", 0, "wxVideoMode *", 0, 0, 0, 0},{"_p_wxVideoMode", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32293 static swig_type_info _swigt__p_wxDataObjectSimple[] = {{"_p_wxDataObjectSimple", 0, "wxDataObjectSimple *", 0, 0, 0, 0},{"_p_wxDataObjectSimple", 0, 0, 0, 0, 0, 0},{"_p_wxPyDataObjectSimple", _p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple, 0, 0, 0, 0, 0},{"_p_wxTextDataObject", _p_wxTextDataObjectTo_p_wxDataObjectSimple, 0, 0, 0, 0, 0},{"_p_wxPyTextDataObject", _p_wxPyTextDataObjectTo_p_wxDataObjectSimple, 0, 0, 0, 0, 0},{"_p_wxBitmapDataObject", _p_wxBitmapDataObjectTo_p_wxDataObjectSimple, 0, 0, 0, 0, 0},{"_p_wxPyBitmapDataObject", _p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple, 0, 0, 0, 0, 0},{"_p_wxFileDataObject", _p_wxFileDataObjectTo_p_wxDataObjectSimple, 0, 0, 0, 0, 0},{"_p_wxCustomDataObject", _p_wxCustomDataObjectTo_p_wxDataObjectSimple, 0, 0, 0, 0, 0},{"_p_wxMetafileDataObject", _p_wxMetafileDataObjectTo_p_wxDataObjectSimple, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32294 static swig_type_info _swigt__p_wxPyDataObjectSimple[] = {{"_p_wxPyDataObjectSimple", 0, "wxPyDataObjectSimple *", 0, 0, 0, 0},{"_p_wxPyDataObjectSimple", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32295 static swig_type_info _swigt__p_wxDuplexMode[] = {{"_p_wxDuplexMode", 0, "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0, 0},{"_p_wxDuplexMode", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32296 static swig_type_info _swigt__p_wxEvtHandler[] = {{"_p_wxEvtHandler", 0, "wxEvtHandler *", 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", 0, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyTimer", _p_wxPyTimerTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{"_p_wxPyProcess", _p_wxPyProcessTo_p_wxEvtHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32297 static swig_type_info _swigt__p_wxRect[] = {{"_p_wxRect", 0, "wxRect *", 0, 0, 0, 0},{"_p_wxRect", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32298 static swig_type_info _swigt__p_char[] = {{"_p_char", 0, "char *", 0, 0, 0, 0},{"_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32299 static swig_type_info _swigt__p_wxSingleInstanceChecker[] = {{"_p_wxSingleInstanceChecker", 0, "wxSingleInstanceChecker *", 0, 0, 0, 0},{"_p_wxSingleInstanceChecker", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32300 static swig_type_info _swigt__p_wxStandardPaths[] = {{"_p_wxStandardPaths", 0, "wxStandardPaths *", 0, 0, 0, 0},{"_p_wxStandardPaths", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32301 static swig_type_info _swigt__p_wxFileTypeInfo[] = {{"_p_wxFileTypeInfo", 0, "wxFileTypeInfo *", 0, 0, 0, 0},{"_p_wxFileTypeInfo", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32302 static swig_type_info _swigt__p_wxFrame[] = {{"_p_wxFrame", 0, "wxFrame *", 0, 0, 0, 0},{"_p_wxFrame", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32303 static swig_type_info _swigt__p_wxTimer[] = {{"_p_wxTimer", 0, "wxTimer *", 0, 0, 0, 0},{"_p_wxTimer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32304 static swig_type_info _swigt__p_wxPaperSize[] = {{"_p_wxPaperSize", 0, "enum wxPaperSize *|wxPaperSize *", 0, 0, 0, 0},{"_p_wxPaperSize", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32305 static swig_type_info _swigt__p_wxMimeTypesManager[] = {{"_p_wxMimeTypesManager", 0, "wxMimeTypesManager *", 0, 0, 0, 0},{"_p_wxMimeTypesManager", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32306 static swig_type_info _swigt__p_wxPyArtProvider[] = {{"_p_wxPyArtProvider", 0, "wxPyArtProvider *", 0, 0, 0, 0},{"_p_wxPyArtProvider", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32307 static swig_type_info _swigt__p_wxPyTipProvider[] = {{"_p_wxPyTipProvider", 0, "wxPyTipProvider *", 0, 0, 0, 0},{"_p_wxPyTipProvider", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32308 static swig_type_info _swigt__p_wxTipProvider[] = {{"_p_wxTipProvider", 0, "wxTipProvider *", 0, 0, 0, 0},{"_p_wxTipProvider", 0, 0, 0, 0, 0, 0},{"_p_wxPyTipProvider", _p_wxPyTipProviderTo_p_wxTipProvider, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32309 static swig_type_info _swigt__p_wxJoystick[] = {{"_p_wxJoystick", 0, "wxJoystick *", 0, 0, 0, 0},{"_p_wxJoystick", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32310 static swig_type_info _swigt__p_wxSystemOptions[] = {{"_p_wxSystemOptions", 0, "wxSystemOptions *", 0, 0, 0, 0},{"_p_wxSystemOptions", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32311 static swig_type_info _swigt__p_wxPoint[] = {{"_p_wxPoint", 0, "wxPoint *", 0, 0, 0, 0},{"_p_wxPoint", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32312 static swig_type_info _swigt__p_wxJoystickEvent[] = {{"_p_wxJoystickEvent", 0, "wxJoystickEvent *", 0, 0, 0, 0},{"_p_wxJoystickEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32313 static swig_type_info _swigt__p_wxCursor[] = {{"_p_wxCursor", 0, "wxCursor *", 0, 0, 0, 0},{"_p_wxCursor", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32314 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileHistory", _p_wxFileHistoryTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTimerEvent", _p_wxTimerEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxClipboard", _p_wxClipboardTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxToolTip", _p_wxToolTipTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSystemOptions", _p_wxSystemOptionsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJoystickEvent", _p_wxJoystickEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyProcess", _p_wxPyProcessTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBusyInfo", _p_wxBusyInfoTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxProcessEvent", _p_wxProcessEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyTimer", _p_wxPyTimerTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32315 static swig_type_info _swigt__p_wxOutputStream[] = {{"_p_wxOutputStream", 0, "wxOutputStream *", 0, 0, 0, 0},{"_p_wxOutputStream", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32316 static swig_type_info _swigt__p_wxDateTime[] = {{"_p_wxDateTime", 0, "wxDateTime *", 0, 0, 0, 0},{"_p_wxDateTime", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32317 static swig_type_info _swigt__p_wxPyDropSource[] = {{"_p_wxPyDropSource", 0, "wxPyDropSource *", 0, 0, 0, 0},{"_p_wxPyDropSource", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32318 static swig_type_info _swigt__p_unsigned_long[] = {{"_p_unsigned_long", 0, "unsigned long *|wxLogLevel *", 0, 0, 0, 0},{"_p_unsigned_long", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32319 static swig_type_info _swigt__p_wxKillError[] = {{"_p_wxKillError", 0, "enum wxKillError *|wxKillError *", 0, 0, 0, 0},{"_p_wxKillError", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32320 static swig_type_info _swigt__p_wxWindow[] = {{"_p_wxWindow", 0, "wxWindow *", 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxWindow", 0, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxWindow, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxWindow, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32321 static swig_type_info _swigt__p_wxString[] = {{"_p_wxString", 0, "wxString *", 0, 0, 0, 0},{"_p_wxString", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32322 static swig_type_info _swigt__p_wxPyProcess[] = {{"_p_wxPyProcess", 0, "wxPyProcess *", 0, 0, 0, 0},{"_p_wxPyProcess", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32323 static swig_type_info _swigt__p_wxBitmap[] = {{"_p_wxBitmap", 0, "wxBitmap *", 0, 0, 0, 0},{"_p_wxBitmap", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32324 static swig_type_info _swigt__p_wxConfig[] = {{"_p_wxConfig", 0, "wxConfig *", 0, 0, 0, 0},{"_p_wxConfig", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32325 static swig_type_info _swigt__unsigned_int[] = {{"_unsigned_int", 0, "unsigned int|std::size_t", 0, 0, 0, 0},{"_unsigned_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32326 static swig_type_info _swigt__p_unsigned_int[] = {{"_p_unsigned_int", 0, "unsigned int *|time_t *", 0, 0, 0, 0},{"_p_unsigned_int", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32327 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *|byte *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32328 static swig_type_info _swigt__p_wxChar[] = {{"_p_wxChar", 0, "wxChar *", 0, 0, 0, 0},{"_p_wxChar", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32329 static swig_type_info _swigt__p_wxBusyInfo[] = {{"_p_wxBusyInfo", 0, "wxBusyInfo *", 0, 0, 0, 0},{"_p_wxBusyInfo", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32330 static swig_type_info _swigt__p_wxPyDropTarget[] = {{"_p_wxPyDropTarget", 0, "wxPyDropTarget *", 0, 0, 0, 0},{"_p_wxPyDropTarget", 0, 0, 0, 0, 0, 0},{"_p_wxPyTextDropTarget", _p_wxPyTextDropTargetTo_p_wxPyDropTarget, 0, 0, 0, 0, 0},{"_p_wxPyFileDropTarget", _p_wxPyFileDropTargetTo_p_wxPyDropTarget, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32331 static swig_type_info _swigt__p_wxPyTextDropTarget[] = {{"_p_wxPyTextDropTarget", 0, "wxPyTextDropTarget *", 0, 0, 0, 0},{"_p_wxPyTextDropTarget", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32332 static swig_type_info _swigt__p_wxPyFileDropTarget[] = {{"_p_wxPyFileDropTarget", 0, "wxPyFileDropTarget *", 0, 0, 0, 0},{"_p_wxPyFileDropTarget", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32333 static swig_type_info _swigt__p_wxProcessEvent[] = {{"_p_wxProcessEvent", 0, "wxProcessEvent *", 0, 0, 0, 0},{"_p_wxProcessEvent", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32334 static swig_type_info _swigt__p_wxPyLog[] = {{"_p_wxPyLog", 0, "wxPyLog *", 0, 0, 0, 0},{"_p_wxPyLog", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32335 static swig_type_info _swigt__p_wxLogNull[] = {{"_p_wxLogNull", 0, "wxLogNull *", 0, 0, 0, 0},{"_p_wxLogNull", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32336 static swig_type_info _swigt__p_wxColour[] = {{"_p_wxColour", 0, "wxColour *", 0, 0, 0, 0},{"_p_wxColour", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32337 static swig_type_info _swigt__p_wxPyTimer[] = {{"_p_wxPyTimer", 0, "wxPyTimer *", 0, 0, 0, 0},{"_p_wxPyTimer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32338 static swig_type_info _swigt__p_wxConfigPathChanger[] = {{"_p_wxConfigPathChanger", 0, "wxConfigPathChanger *", 0, 0, 0, 0},{"_p_wxConfigPathChanger", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32339 static swig_type_info _swigt__p_wxDateSpan[] = {{"_p_wxDateSpan", 0, "wxDateSpan *", 0, 0, 0, 0},{"_p_wxDateSpan", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32340
32341 static swig_type_info *swig_types_initial[] = {
32342 _swigt__p_wxLogChain,
32343 _swigt__p_wxMutexGuiLocker,
32344 _swigt__p_wxFileHistory,
32345 _swigt__p_wxLog,
32346 _swigt__p_wxMenu,
32347 _swigt__p_wxEvent,
32348 _swigt__p_wxDateTime__TimeZone,
32349 _swigt__p_wxConfigBase,
32350 _swigt__p_wxDisplay,
32351 _swigt__p_wxFileType,
32352 _swigt__p_wxLogGui,
32353 _swigt__p_wxFont,
32354 _swigt__p_wxDataFormat,
32355 _swigt__p_wxTimerEvent,
32356 _swigt__p_wxCaret,
32357 _swigt__ptrdiff_t,
32358 _swigt__std__ptrdiff_t,
32359 _swigt__p_int,
32360 _swigt__p_wxSize,
32361 _swigt__p_wxClipboard,
32362 _swigt__p_wxStopWatch,
32363 _swigt__p_wxClipboardLocker,
32364 _swigt__p_wxIcon,
32365 _swigt__p_wxLogStderr,
32366 _swigt__p_wxLogTextCtrl,
32367 _swigt__p_wxTextCtrl,
32368 _swigt__p_wxBusyCursor,
32369 _swigt__p_wxBitmapDataObject,
32370 _swigt__p_wxTextDataObject,
32371 _swigt__p_wxDataObject,
32372 _swigt__p_wxPyTextDataObject,
32373 _swigt__p_wxPyBitmapDataObject,
32374 _swigt__p_wxFileDataObject,
32375 _swigt__p_wxCustomDataObject,
32376 _swigt__p_wxURLDataObject,
32377 _swigt__p_wxMetafileDataObject,
32378 _swigt__p_wxSound,
32379 _swigt__p_wxTimerRunner,
32380 _swigt__p_wxLogWindow,
32381 _swigt__p_wxTimeSpan,
32382 _swigt__p_wxArrayString,
32383 _swigt__p_wxWindowDisabler,
32384 _swigt__p_form_ops_t,
32385 _swigt__p_wxToolTip,
32386 _swigt__p_wxDataObjectComposite,
32387 _swigt__p_wxFileConfig,
32388 _swigt__p_wxSystemSettings,
32389 _swigt__p_wxVideoMode,
32390 _swigt__p_wxDataObjectSimple,
32391 _swigt__p_wxPyDataObjectSimple,
32392 _swigt__p_wxDuplexMode,
32393 _swigt__p_wxEvtHandler,
32394 _swigt__p_wxRect,
32395 _swigt__p_char,
32396 _swigt__p_wxSingleInstanceChecker,
32397 _swigt__p_wxStandardPaths,
32398 _swigt__p_wxFileTypeInfo,
32399 _swigt__p_wxFrame,
32400 _swigt__p_wxTimer,
32401 _swigt__p_wxPaperSize,
32402 _swigt__p_wxMimeTypesManager,
32403 _swigt__p_wxPyArtProvider,
32404 _swigt__p_wxPyTipProvider,
32405 _swigt__p_wxTipProvider,
32406 _swigt__p_wxJoystick,
32407 _swigt__p_wxSystemOptions,
32408 _swigt__p_wxPoint,
32409 _swigt__p_wxJoystickEvent,
32410 _swigt__p_wxCursor,
32411 _swigt__p_wxObject,
32412 _swigt__p_wxOutputStream,
32413 _swigt__p_wxDateTime,
32414 _swigt__p_wxPyDropSource,
32415 _swigt__p_unsigned_long,
32416 _swigt__p_wxKillError,
32417 _swigt__p_wxWindow,
32418 _swigt__p_wxString,
32419 _swigt__p_wxPyProcess,
32420 _swigt__p_wxBitmap,
32421 _swigt__p_wxConfig,
32422 _swigt__unsigned_int,
32423 _swigt__p_unsigned_int,
32424 _swigt__p_unsigned_char,
32425 _swigt__p_wxChar,
32426 _swigt__p_wxBusyInfo,
32427 _swigt__p_wxPyDropTarget,
32428 _swigt__p_wxPyTextDropTarget,
32429 _swigt__p_wxPyFileDropTarget,
32430 _swigt__p_wxProcessEvent,
32431 _swigt__p_wxPyLog,
32432 _swigt__p_wxLogNull,
32433 _swigt__p_wxColour,
32434 _swigt__p_wxPyTimer,
32435 _swigt__p_wxConfigPathChanger,
32436 _swigt__p_wxDateSpan,
32437 0
32438 };
32439
32440
32441 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32442
32443 static swig_const_info swig_const_table[] = {
32444 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32445 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32446 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32447 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32448 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32449 {0, 0, 0, 0.0, 0, 0}};
32450
32451 #ifdef __cplusplus
32452 }
32453 #endif
32454
32455
32456 #ifdef __cplusplus
32457 extern "C" {
32458 #endif
32459
32460 /* Python-specific SWIG API */
32461 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32462 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32463 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32464
32465 /* -----------------------------------------------------------------------------
32466 * global variable support code.
32467 * ----------------------------------------------------------------------------- */
32468
32469 typedef struct swig_globalvar {
32470 char *name; /* Name of global variable */
32471 PyObject *(*get_attr)(); /* Return the current value */
32472 int (*set_attr)(PyObject *); /* Set the value */
32473 struct swig_globalvar *next;
32474 } swig_globalvar;
32475
32476 typedef struct swig_varlinkobject {
32477 PyObject_HEAD
32478 swig_globalvar *vars;
32479 } swig_varlinkobject;
32480
32481 static PyObject *
32482 swig_varlink_repr(swig_varlinkobject *v) {
32483 v = v;
32484 return PyString_FromString("<Swig global variables>");
32485 }
32486
32487 static int
32488 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32489 swig_globalvar *var;
32490 flags = flags;
32491 fprintf(fp,"Swig global variables { ");
32492 for (var = v->vars; var; var=var->next) {
32493 fprintf(fp,"%s", var->name);
32494 if (var->next) fprintf(fp,", ");
32495 }
32496 fprintf(fp," }\n");
32497 return 0;
32498 }
32499
32500 static PyObject *
32501 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32502 swig_globalvar *var = v->vars;
32503 while (var) {
32504 if (strcmp(var->name,n) == 0) {
32505 return (*var->get_attr)();
32506 }
32507 var = var->next;
32508 }
32509 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32510 return NULL;
32511 }
32512
32513 static int
32514 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32515 swig_globalvar *var = v->vars;
32516 while (var) {
32517 if (strcmp(var->name,n) == 0) {
32518 return (*var->set_attr)(p);
32519 }
32520 var = var->next;
32521 }
32522 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32523 return 1;
32524 }
32525
32526 static PyTypeObject varlinktype = {
32527 PyObject_HEAD_INIT(0)
32528 0, /* Number of items in variable part (ob_size) */
32529 (char *)"swigvarlink", /* Type name (tp_name) */
32530 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32531 0, /* Itemsize (tp_itemsize) */
32532 0, /* Deallocator (tp_dealloc) */
32533 (printfunc) swig_varlink_print, /* Print (tp_print) */
32534 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32535 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32536 0, /* tp_compare */
32537 (reprfunc) swig_varlink_repr, /* tp_repr */
32538 0, /* tp_as_number */
32539 0, /* tp_as_sequence */
32540 0, /* tp_as_mapping */
32541 0, /* tp_hash */
32542 0, /* tp_call */
32543 0, /* tp_str */
32544 0, /* tp_getattro */
32545 0, /* tp_setattro */
32546 0, /* tp_as_buffer */
32547 0, /* tp_flags */
32548 0, /* tp_doc */
32549 #if PY_VERSION_HEX >= 0x02000000
32550 0, /* tp_traverse */
32551 0, /* tp_clear */
32552 #endif
32553 #if PY_VERSION_HEX >= 0x02010000
32554 0, /* tp_richcompare */
32555 0, /* tp_weaklistoffset */
32556 #endif
32557 #if PY_VERSION_HEX >= 0x02020000
32558 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32559 #endif
32560 #if PY_VERSION_HEX >= 0x02030000
32561 0, /* tp_del */
32562 #endif
32563 #ifdef COUNT_ALLOCS
32564 0,0,0,0 /* tp_alloc -> tp_next */
32565 #endif
32566 };
32567
32568 /* Create a variable linking object for use later */
32569 static PyObject *
32570 SWIG_Python_newvarlink(void) {
32571 swig_varlinkobject *result = 0;
32572 result = PyMem_NEW(swig_varlinkobject,1);
32573 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32574 result->ob_type = &varlinktype;
32575 result->vars = 0;
32576 result->ob_refcnt = 0;
32577 Py_XINCREF((PyObject *) result);
32578 return ((PyObject*) result);
32579 }
32580
32581 static void
32582 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32583 swig_varlinkobject *v;
32584 swig_globalvar *gv;
32585 v= (swig_varlinkobject *) p;
32586 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32587 gv->name = (char *) malloc(strlen(name)+1);
32588 strcpy(gv->name,name);
32589 gv->get_attr = get_attr;
32590 gv->set_attr = set_attr;
32591 gv->next = v->vars;
32592 v->vars = gv;
32593 }
32594
32595 /* -----------------------------------------------------------------------------
32596 * constants/methods manipulation
32597 * ----------------------------------------------------------------------------- */
32598
32599 /* Install Constants */
32600 static void
32601 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32602 PyObject *obj = 0;
32603 size_t i;
32604 for (i = 0; constants[i].type; i++) {
32605 switch(constants[i].type) {
32606 case SWIG_PY_INT:
32607 obj = PyInt_FromLong(constants[i].lvalue);
32608 break;
32609 case SWIG_PY_FLOAT:
32610 obj = PyFloat_FromDouble(constants[i].dvalue);
32611 break;
32612 case SWIG_PY_STRING:
32613 if (constants[i].pvalue) {
32614 obj = PyString_FromString((char *) constants[i].pvalue);
32615 } else {
32616 Py_INCREF(Py_None);
32617 obj = Py_None;
32618 }
32619 break;
32620 case SWIG_PY_POINTER:
32621 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32622 break;
32623 case SWIG_PY_BINARY:
32624 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32625 break;
32626 default:
32627 obj = 0;
32628 break;
32629 }
32630 if (obj) {
32631 PyDict_SetItemString(d,constants[i].name,obj);
32632 Py_DECREF(obj);
32633 }
32634 }
32635 }
32636
32637 /* -----------------------------------------------------------------------------*/
32638 /* Fix SwigMethods to carry the callback ptrs when needed */
32639 /* -----------------------------------------------------------------------------*/
32640
32641 static void
32642 SWIG_Python_FixMethods(PyMethodDef *methods,
32643 swig_const_info *const_table,
32644 swig_type_info **types,
32645 swig_type_info **types_initial) {
32646 size_t i;
32647 for (i = 0; methods[i].ml_name; ++i) {
32648 char *c = methods[i].ml_doc;
32649 if (c && (c = strstr(c, "swig_ptr: "))) {
32650 int j;
32651 swig_const_info *ci = 0;
32652 char *name = c + 10;
32653 for (j = 0; const_table[j].type; j++) {
32654 if (strncmp(const_table[j].name, name,
32655 strlen(const_table[j].name)) == 0) {
32656 ci = &(const_table[j]);
32657 break;
32658 }
32659 }
32660 if (ci) {
32661 size_t shift = (ci->ptype) - types;
32662 swig_type_info *ty = types_initial[shift];
32663 size_t ldoc = (c - methods[i].ml_doc);
32664 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
32665 char *ndoc = (char*)malloc(ldoc + lptr + 10);
32666 char *buff = ndoc;
32667 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
32668 strncpy(buff, methods[i].ml_doc, ldoc);
32669 buff += ldoc;
32670 strncpy(buff, "swig_ptr: ", 10);
32671 buff += 10;
32672 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
32673 methods[i].ml_doc = ndoc;
32674 }
32675 }
32676 }
32677 }
32678
32679 /* -----------------------------------------------------------------------------*
32680 * Initialize type list
32681 * -----------------------------------------------------------------------------*/
32682
32683 #if PY_MAJOR_VERSION < 2
32684 /* PyModule_AddObject function was introduced in Python 2.0. The following function
32685 is copied out of Python/modsupport.c in python version 2.3.4 */
32686 static int
32687 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
32688 {
32689 PyObject *dict;
32690 if (!PyModule_Check(m)) {
32691 PyErr_SetString(PyExc_TypeError,
32692 "PyModule_AddObject() needs module as first arg");
32693 return -1;
32694 }
32695 if (!o) {
32696 PyErr_SetString(PyExc_TypeError,
32697 "PyModule_AddObject() needs non-NULL value");
32698 return -1;
32699 }
32700
32701 dict = PyModule_GetDict(m);
32702 if (dict == NULL) {
32703 /* Internal error -- modules must have a dict! */
32704 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
32705 PyModule_GetName(m));
32706 return -1;
32707 }
32708 if (PyDict_SetItemString(dict, name, o))
32709 return -1;
32710 Py_DECREF(o);
32711 return 0;
32712 }
32713 #endif
32714
32715 static swig_type_info **
32716 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
32717 static PyMethodDef swig_empty_runtime_method_table[] = {
32718 {
32719 NULL, NULL, 0, NULL
32720 }
32721 };/* Sentinel */
32722
32723 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
32724 swig_empty_runtime_method_table);
32725 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
32726 if (pointer && module) {
32727 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
32728 }
32729 return type_list_handle;
32730 }
32731
32732 static swig_type_info **
32733 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
32734 swig_type_info **type_pointer;
32735
32736 /* first check if module already created */
32737 type_pointer = SWIG_Python_GetTypeListHandle();
32738 if (type_pointer) {
32739 return type_pointer;
32740 } else {
32741 /* create a new module and variable */
32742 return SWIG_Python_SetTypeListHandle(type_list_handle);
32743 }
32744 }
32745
32746 #ifdef __cplusplus
32747 }
32748 #endif
32749
32750 /* -----------------------------------------------------------------------------*
32751 * Partial Init method
32752 * -----------------------------------------------------------------------------*/
32753
32754 #ifdef SWIG_LINK_RUNTIME
32755 #ifdef __cplusplus
32756 extern "C"
32757 #endif
32758 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
32759 #endif
32760
32761 #ifdef __cplusplus
32762 extern "C"
32763 #endif
32764 SWIGEXPORT(void) SWIG_init(void) {
32765 static PyObject *SWIG_globals = 0;
32766 static int typeinit = 0;
32767 PyObject *m, *d;
32768 int i;
32769 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
32770
32771 /* Fix SwigMethods to carry the callback ptrs when needed */
32772 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
32773
32774 m = Py_InitModule((char *) SWIG_name, SwigMethods);
32775 d = PyModule_GetDict(m);
32776
32777 if (!typeinit) {
32778 #ifdef SWIG_LINK_RUNTIME
32779 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
32780 #else
32781 # ifndef SWIG_STATIC_RUNTIME
32782 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
32783 # endif
32784 #endif
32785 for (i = 0; swig_types_initial[i]; i++) {
32786 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
32787 }
32788 typeinit = 1;
32789 }
32790 SWIG_InstallConstants(d,swig_const_table);
32791
32792 {
32793 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
32794 }
32795 {
32796 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
32797 }
32798 {
32799 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
32800 }
32801 {
32802 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
32803 }
32804 {
32805 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
32806 }
32807 {
32808 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
32809 }
32810 {
32811 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
32812 }
32813 {
32814 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
32815 }
32816 {
32817 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
32818 }
32819 {
32820 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
32821 }
32822 {
32823 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
32824 }
32825 {
32826 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
32827 }
32828 {
32829 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
32830 }
32831 {
32832 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
32833 }
32834 {
32835 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
32836 }
32837 {
32838 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
32839 }
32840 {
32841 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
32842 }
32843 {
32844 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
32845 }
32846 {
32847 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
32848 }
32849 {
32850 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
32851 }
32852 {
32853 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
32854 }
32855 {
32856 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
32857 }
32858 {
32859 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
32860 }
32861 {
32862 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
32863 }
32864 {
32865 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
32866 }
32867 {
32868 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
32869 }
32870 {
32871 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
32872 }
32873 {
32874 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
32875 }
32876 {
32877 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
32878 }
32879 {
32880 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
32881 }
32882 {
32883 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
32884 }
32885 {
32886 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
32887 }
32888 {
32889 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
32890 }
32891 {
32892 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
32893 }
32894 {
32895 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
32896 }
32897 {
32898 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
32899 }
32900 {
32901 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
32902 }
32903 {
32904 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
32905 }
32906 {
32907 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
32908 }
32909 {
32910 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
32911 }
32912 {
32913 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
32914 }
32915 {
32916 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
32917 }
32918 {
32919 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
32920 }
32921 {
32922 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
32923 }
32924 {
32925 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
32926 }
32927 {
32928 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
32929 }
32930 {
32931 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
32932 }
32933 {
32934 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
32935 }
32936 {
32937 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
32938 }
32939 {
32940 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
32941 }
32942 {
32943 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
32944 }
32945 {
32946 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
32947 }
32948 {
32949 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
32950 }
32951 {
32952 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
32953 }
32954 {
32955 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
32956 }
32957 {
32958 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
32959 }
32960 {
32961 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
32962 }
32963 {
32964 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
32965 }
32966 {
32967 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
32968 }
32969 {
32970 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
32971 }
32972 {
32973 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
32974 }
32975 {
32976 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
32977 }
32978 {
32979 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
32980 }
32981 {
32982 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
32983 }
32984 {
32985 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
32986 }
32987 {
32988 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
32989 }
32990 {
32991 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
32992 }
32993 {
32994 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
32995 }
32996 {
32997 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
32998 }
32999 {
33000 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33001 }
33002 {
33003 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33004 }
33005 {
33006 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33007 }
33008 {
33009 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33010 }
33011 {
33012 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33013 }
33014 {
33015 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33016 }
33017 {
33018 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33019 }
33020 {
33021 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33022 }
33023 {
33024 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33025 }
33026 {
33027 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33028 }
33029 {
33030 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33031 }
33032 {
33033 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33034 }
33035 {
33036 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33037 }
33038 {
33039 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33040 }
33041 {
33042 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33043 }
33044 {
33045 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33046 }
33047 {
33048 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33049 }
33050 {
33051 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33052 }
33053 {
33054 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33055 }
33056 {
33057 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33058 }
33059 {
33060 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33061 }
33062 {
33063 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33064 }
33065 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33066 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33067 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33068 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33069 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33070 {
33071 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33072 }
33073 {
33074 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33075 }
33076 {
33077 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33078 }
33079 {
33080 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33081 }
33082 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33083
33084 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33085
33086 {
33087 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33088 }
33089 {
33090 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33091 }
33092 {
33093 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33094 }
33095 {
33096 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33097 }
33098 {
33099 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33100 }
33101 {
33102 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33103 }
33104 {
33105 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33106 }
33107 {
33108 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33109 }
33110 {
33111 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33112 }
33113 {
33114 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33115 }
33116 {
33117 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33118 }
33119 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33120 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33121 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33122 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33123 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33124 {
33125 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33126 }
33127 {
33128 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33129 }
33130 {
33131 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33132 }
33133 {
33134 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33135 }
33136 {
33137 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33138 }
33139 {
33140 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33141 }
33142 {
33143 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33144 }
33145 {
33146 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33147 }
33148 {
33149 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33150 }
33151 {
33152 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33153 }
33154 {
33155 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33156 }
33157 {
33158 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33159 }
33160 {
33161 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33162 }
33163 {
33164 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33165 }
33166 {
33167 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33168 }
33169 {
33170 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33171 }
33172 {
33173 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33174 }
33175 {
33176 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33177 }
33178 {
33179 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33180 }
33181 {
33182 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33183 }
33184 {
33185 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33186 }
33187 {
33188 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33189 }
33190 {
33191 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33192 }
33193 {
33194 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33195 }
33196 {
33197 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33198 }
33199 {
33200 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33201 }
33202 {
33203 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33204 }
33205 {
33206 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33207 }
33208 {
33209 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33210 }
33211 {
33212 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33213 }
33214 {
33215 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33216 }
33217 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33218 {
33219 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33220 }
33221 {
33222 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33223 }
33224 {
33225 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33226 }
33227 {
33228 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33229 }
33230 {
33231 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33232 }
33233
33234 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33235
33236 {
33237 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33238 }
33239 {
33240 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33241 }
33242 {
33243 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33244 }
33245 {
33246 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33247 }
33248 {
33249 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33250 }
33251 {
33252 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33253 }
33254 {
33255 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33256 }
33257 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33258 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33259 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33260 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33261 {
33262 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33263 }
33264 {
33265 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33266 }
33267 {
33268 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33269 }
33270 {
33271 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33272 }
33273 {
33274 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33275 }
33276 {
33277 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33278 }
33279 {
33280 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33281 }
33282 {
33283 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33284 }
33285 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33286 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33287 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33288 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33289 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33290 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33291 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33292 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33293 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33294 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33295 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33296 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33297 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33298 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33299 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33300 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33301 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33302 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33303 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33304 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33305 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33306 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33307 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33308 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33309 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33310 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33311 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33312 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33313 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33314 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33315 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33316 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33317 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33318 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33319 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33320 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33321 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33322 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33323 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33324 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33325 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33326 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33327 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33328 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33329 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33330
33331 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33332
33333 {
33334 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33335 }
33336 {
33337 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33338 }
33339 {
33340 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33341 }
33342 {
33343 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33344 }
33345 {
33346 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33347 }
33348 {
33349 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33350 }
33351 {
33352 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33353 }
33354 {
33355 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33356 }
33357 {
33358 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33359 }
33360 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33361 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33362 {
33363 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33364 }
33365 {
33366 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33367 }
33368 {
33369 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33370 }
33371 {
33372 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33373 }
33374 {
33375 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33376 }
33377 {
33378 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33379 }
33380 {
33381 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33382 }
33383 {
33384 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33385 }
33386 {
33387 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33388 }
33389 {
33390 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33391 }
33392 {
33393 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33394 }
33395 {
33396 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33397 }
33398 {
33399 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33400 }
33401 {
33402 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33403 }
33404 {
33405 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33406 }
33407 {
33408 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33409 }
33410 {
33411 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33412 }
33413 {
33414 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33415 }
33416 {
33417 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33418 }
33419 {
33420 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33421 }
33422 {
33423 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33424 }
33425 {
33426 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33427 }
33428 {
33429 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33430 }
33431 {
33432 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33433 }
33434 {
33435 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33439 }
33440 {
33441 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33442 }
33443 {
33444 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33445 }
33446 {
33447 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33463 }
33464 {
33465 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33466 }
33467 {
33468 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33469 }
33470 {
33471 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33472 }
33473 {
33474 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33475 }
33476 {
33477 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33478 }
33479 {
33480 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33481 }
33482 {
33483 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33484 }
33485 {
33486 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33487 }
33488 {
33489 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33490 }
33491 {
33492 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33493 }
33494 {
33495 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33496 }
33497 {
33498 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33499 }
33500 {
33501 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33502 }
33503 {
33504 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33505 }
33506 {
33507 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33508 }
33509 {
33510 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33511 }
33512 {
33513 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33514 }
33515 {
33516 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33517 }
33518 {
33519 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33520 }
33521 {
33522 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33523 }
33524 {
33525 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33526 }
33527 {
33528 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33529 }
33530 {
33531 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33532 }
33533 {
33534 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33535 }
33536 {
33537 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33538 }
33539 {
33540 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33541 }
33542 {
33543 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33544 }
33545 {
33546 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33547 }
33548 {
33549 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33550 }
33551 {
33552 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33553 }
33554 {
33555 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33556 }
33557 {
33558 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33559 }
33560 {
33561 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33562 }
33563 {
33564 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33565 }
33566 {
33567 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33568 }
33569 {
33570 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33571 }
33572 {
33573 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33574 }
33575 {
33576 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33577 }
33578 {
33579 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33580 }
33581 {
33582 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33583 }
33584 {
33585 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33586 }
33587 {
33588 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33589 }
33590 {
33591 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
33592 }
33593 {
33594 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
33595 }
33596 {
33597 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
33598 }
33599 {
33600 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
33601 }
33602 {
33603 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
33604 }
33605 {
33606 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
33607 }
33608 {
33609 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
33610 }
33611 {
33612 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
33613 }
33614 {
33615 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
33616 }
33617 {
33618 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
33619 }
33620 {
33621 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
33622 }
33623 {
33624 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
33625 }
33626 {
33627 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
33628 }
33629 {
33630 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
33631 }
33632 {
33633 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
33634 }
33635 {
33636 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
33637 }
33638 {
33639 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
33640 }
33641 {
33642 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
33643 }
33644 {
33645 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
33646 }
33647 {
33648 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
33649 }
33650 {
33651 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
33652 }
33653 {
33654 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
33655 }
33656 {
33657 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
33658 }
33659 {
33660 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
33661 }
33662 {
33663 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
33664 }
33665 {
33666 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
33667 }
33668 {
33669 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
33670 }
33671 {
33672 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
33673 }
33674 {
33675 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
33676 }
33677 {
33678 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
33679 }
33680 {
33681 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
33682 }
33683 {
33684 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
33685 }
33686 {
33687 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
33688 }
33689 {
33690 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
33691 }
33692 {
33693 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
33694 }
33695 {
33696 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
33697 }
33698 {
33699 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
33700 }
33701 {
33702 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
33703 }
33704 {
33705 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
33706 }
33707 {
33708 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
33709 }
33710 {
33711 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
33712 }
33713 {
33714 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
33715 }
33716 {
33717 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
33718 }
33719 {
33720 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
33721 }
33722 {
33723 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
33724 }
33725 {
33726 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
33727 }
33728 {
33729 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
33730 }
33731 {
33732 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
33733 }
33734 {
33735 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
33736 }
33737 {
33738 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
33739 }
33740 {
33741 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
33742 }
33743 {
33744 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
33745 }
33746 {
33747 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
33748 }
33749 {
33750 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
33751 }
33752 {
33753 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
33754 }
33755 {
33756 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
33757 }
33758 {
33759 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
33760 }
33761 {
33762 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
33763 }
33764 {
33765 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
33781 }
33782 {
33783 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
33784 }
33785 {
33786 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
33790 }
33791 {
33792 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
33793 }
33794 {
33795 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
33796 }
33797 {
33798 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
33799 }
33800 {
33801 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
33802 }
33803 {
33804 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
33805 }
33806 {
33807 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
33808 }
33809 {
33810 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
33811 }
33812 {
33813 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
33814 }
33815 {
33816 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
33817 }
33818 {
33819 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
33820 }
33821 {
33822 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
33823 }
33824 {
33825 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
33826 }
33827 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
33828 {
33829 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
33836 }
33837 {
33838 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
33857 }
33858 {
33859 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
33860 }
33861 {
33862 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
33863 }
33864 {
33865 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
33866 }
33867 {
33868 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
33869 }
33870 {
33871 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
33872 }
33873 {
33874 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
33875 }
33876 {
33877 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
33878 }
33879 {
33880 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
33881 }
33882 {
33883 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
33884 }
33885 {
33886 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
33887 }
33888 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
33889 {
33890 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
33891 }
33892 {
33893 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
33894 }
33895 {
33896 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
33897 }
33898 {
33899 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
33900 }
33901 {
33902 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
33903 }
33904 {
33905 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
33906 }
33907 {
33908 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
33909 }
33910 {
33911 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
33912 }
33913 {
33914 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
33915 }
33916 {
33917 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
33918 }
33919 {
33920 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
33921 }
33922 {
33923 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
33924 }
33925
33926 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
33927 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
33928 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
33929 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
33930
33931 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
33932 }
33933
wxWidgets (Impactor)